torch 函数整理

torch.nn.Conv2d

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)
卷积操作，输入矩阵大小 (N, Cin, H, W)，输入矩阵大小N, Cout, Hout, Wout)

参数说明

• in_channels (int) – 输入特征矩阵的通道数 Cin
• out_channels (int) – 输出特征矩阵的通道数 Cout
• kernel_size (int or tuple) – 卷积核的大小
• stride (int or tuple, optional) – 卷积核的步长. 默认: 1
• padding (int or tuple, optional) – 边缘的扩充，使用0进行扩充 Default: 0
• dilation (int or tuple, optional) – 内核之间的距离. Default: 1
• groups (int, optional) – Number of blocked connections from input channels to output channels. Default: 1
• bias (bool, optional) – If True, adds a learnable bias to the output. Default: True

torch.nn.BatchNorm2d

torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)

参数说明

• num_features – 输入特征图(N,C,H,W)中的C
• eps – a value added to the denominator for numerical stability. Default: 1e-5
• momentum – the value used for the running_mean and running_var computation. Can be set to None for cumulative moving average (i.e. simple average). Default: 0.1
• affine – a boolean value that when set to True, this module has learnable affine parameters. Default: True
• track_running_stats – a boolean value that when set to True, this module tracks the running mean and variance, and when set to False, this module does not track such statistics and always uses batch statistics in both training and eval modes. Default: True

torch.nn.Upsample

torch.nn.Upsample(size=None, scale_factor=None, mode='nearest', align_corners=None)
对输入的多通道数据进行上采样

• size (tuple ，optional)– 是输出矩阵大小（[optional D_out], [optional H_out], W_out）的元组。
• scale_factor (int / tuple of python:ints, optional) – 图像宽/高/深度的倍数
• mode – (string, optional) – 上采样方法: 有nearest, linear, bilinear, bicubic and trilinear. 默认是: nearest
• align_corners (bool, optional) – 如果为true，则输入和输入tensor的角点像素对齐，从而保留这些像素的像素值。 默认值: False

1. 张量Tensors

torch.is_tensor(obj):

如果obj是一个pytorch张量，则返回True

torch.is_storage(obj):

如果obj是一个pytorch storage对象，则返回True

torch.numel(input):

返回input张量中的元素个数。

2. 创建操作

torch.eye(n, m=None, out=None):

返回一个2维张量，对角线为1,其它位置为0

• n (int) -行数
• m (int, optional)列数，如果为None,则默认为n
• out (Tensor, optional)

torch.from_numpy(ndarray):

将numpy.ndarray转换为Tensor，返回的张量tensor和numpy的ndarray共享同一内存空间，修改一个会导致另一个也被修改，返回的张量不能改变大小

torch.linspace(start, end, steps=100, out=None):

返回一个1维张量，包含在start和end上均匀间隔的steps个点

• start (float) -序列起点
• end (float) - 序列终点
• steps (int) - 在start与end间生成的样本数
• out (Tensor, optional) - 结果张量

torch.logspace(start, end, steps=100, out=None):

返回一个1维张量，包含在区间10exp(start)和10exp(end)上以对数刻度均匀间隔的 steps个点。

torch.ones(*sizes, out=None):

返回一个全为1的张量，形状由可变参数sizes定义

• sizes (int...) - 整数序列，定义了输出形状

torch.rand(*sizes, out=None):

返回一个张量，包含了从区间(0, 1)的均匀分布中抽取的一组随机数，形状由可变参数sizes定义。

torch.randn(*sizes, out=None):

返回一个张量，包含了从标准正态分布(mean=0, std=1)中抽取一组随机数，形状由可变参数sizes定义。

torch.randperm(n, out=None):

给定参数n，返回一个从0到n-1的随机整数排列

• n (int) - 上边界(不包含）

torch.arange(start, end, step=1, out=None):

返回一个1维张量，长度为floor((end-start)/step)，以step`为步长的一组序列值。

• start (float) - 起点
• end (float) - 终点(不包含）
• step (float) - 相邻点的间隔大小
• out (Tensor, optional)

torch.range(start, end, step=1, out=None):

还是推荐使用torch.arange()

torch.zeros(*sizes, out=None):

返回一个全为标量0的张量，形状由可变参数sizes定义

3. 索引，切片，连接，换位(Index, Slicing, Joining, Mutating)

torch.cat(inputs, dimension=0):

在给定维度上对输入的张量序列seq进行连接操作。

• inputs (sequence of Tensors)
• dimension (int optional) - 沿着此维连接张量序列

torch.chunk(tensor, chunks, dim=0):

在给定维度上将输入张量进行分块

• tensors(Tensors) - 待分场的输入张量
• chunks (int) - 分块的个数
• dim (int) - 沿着此维度

torch.gather(input, dim, index, out=None):

沿给定轴dim,将输入索引张量index指定位置的值进行聚合。

• input(Tensor) - 源张量
• dim(int) - 索引的轴
• index(LongTensor) - 聚合元素的下标
• out - 目标张量

torch.index_select(input, dim, index, out=None):

沿指定维度对输入进行切片，取index中指定的相应项，然后返回一个新的张量，返回的张量与原始张量有相同的维度(在指定轴上)，返回的张量与原始张量不共享内存空间

• input(Tensor) - 输入张量
• dim(int) - 索引的轴
• index(LongTensor) - 包含索引下标的一维张量
• out - 目标张量

torch.masked_select(input, mask, out=None):

根据掩码张量mask中的二元值，取输入张量中的指定项，将取值返回到一个新的1D张量。
张量mask须跟input张量有相同的元素数目，但形状或维度不需要相同。返回的张量不与原始张量共享内存空间

• input(Tensor) - 输入张量
• mask(ByteTensor) - 掩码张量，包含了二元索引值
• out - 目标张量

torch.nonzero(input, out=None):

返回一个包含输入input中非零元素索引的张量，输出张量中的每行包含输入中非零元素的索引
若输入input有n维，则输出的索引张量output形状为z * n, 这里z是输入张量input中所有非零元素的个数

• input(Tensor) - 输入张量
• out - 包含索引值的结果张量

torch.split(tensor, split_size, dim=0):

将输入张量分割成相等形状的chunks(如果可分)。如果沿指定维的张量形状大小不能被split_size整分，则最后一个分块会小于其它分块。

• tensor(Tensor) - 待分割张量
• split_size(int) - 单个分块的形状大小
• dim(int) - 沿着此维进行分割

torch.squeeze(input, dim=None, out=None):

将输入张量形状中的1去除并返回，如果输入是形如(A * 1 * B * 1 * C * 1 *D)，那么输出形状就为：(A * B * C * D)。
当给定dim时，则只在给定维度上进行挤压，如输入形状为(A * 1 * B)，squeeze(input, 0)，将会保持张量不变，只有用squeeze(input, 1)，形状会变成(A *B)。
输入张量与返回张量共享内存

• input(Tensor) - 输入张量
• dim(int, optional) - 如果给定，则只在给定维度挤压
• out(Tensor, optional) - 输出张量

torch.stack(sequence, dim=0):

沿着一个新维度对输入张量进行连接，序列中所有张量都应该为相同的形状。

• sequence(Sequence) - 待连接的张量序列
• dim(int) - 插入的维度

torch.t(input, out=None):

输入一个矩阵(2维张量)，并转置0,1维，可以被视为transpose(input, 0, 1)的简写函数

• input(Tensor) - 输入张量
• out(Tensor, optional) - 结果张量

torch.transpose(input, dim0, dim1, out=None):

返回输入矩阵input的转置，交换维度dim0和dim1。输入张量与输出张量共享内存。

• input(Tensor) - 输入张量
• dim0(int) - 转置的第一维
• dim1(int) - 转置的第二维

torch.unbind(tensor, dim=0)[source]:

移除指定维度后，返回一个元组，包含了沿着指定维切片后的各个切片

• tensor(Tensor) - 输入张量
• dim(int) - 删除的维度

torch.unsequeeze(input, dim, out=None):

返回一个新的张量，对输入的指定位置插入维度1，返回张量与输入张量共享内存，若dim为负，则将被转化为dim+input.dim()+1

• tensor(Tensor) - 输入张量
• dim(int) - 插入维度的索引
• out(Tensor, optional) - 结果张量

4. 随机抽样Random sampling

torch.manual_seed(seed):

设定生成随机数的种子，并返回一个torch._C.Generator对象

torch.initial_seed():

返回生成随机数的原始种子值

torch.rng_state()[source]

返回随机生成器状态(ByteTensor)

torch.set_rng_state(new_state)[source]:

设定随机生成器状态参数：new_state(torch.ByteTensor) - 期望的状态

torch.default_generator

torch.bernoulli(input, out=None):

从伯努利分布中抽取二元随机数(0或者1），输入中所有值必须在[0, 1]区间，输出张量的第i个元素值，将以输入张量的第i个概率值等于1。
返回值将会是与输入相同大小的张量，每个值为0或1

• input(Tensor) - 输入为伯努利分布的概率值
• out(Tensor, optional)

torch.multinomial(input, num_samples, replacement=False, out=None):

返回一个张量，每行包含从input相应行中定义的多项式分布中抽取的num_samples个样本。
input每行的值不需要总和为1,但必须非负且总和不能为0.

• input(Tensor) - 包含概率值的张量
• num_samples(int) - 抽取的样本数
• replacement(bool, optional) - 布尔值，决定是否能重复抽取
• out(Tensor, optional)

torch.normal(means, std, out=None):

返回一个张量，包含从给定means, std的离散正态分布中抽取随机数，均值和标准差的形状不须匹配，但每个张量的元素个数须相同

• means(Tensor) - 均值
• std(Tensor) - 标准差
• out(Tensor, optional)

5. 序列化 Serialization

torch.saves(obj, f, pickle_module, pickle_protocol=2):

保存一个对象到一个硬盘文件上

• obj - 保存对象
• f - 类文件对象
• pickle_module - 用于pickling元数据和对象的模块
• pickle_protocol - 指定pickle protocal可以覆盖默认参数

torch.load(f, map_location=None, pickle_module=):

从磁盘文件中读取一个通过torch.save()保存的对象，可通过参数map_location动态地进行内存重映射

• f - 类文件对象
• map_location - 一个函数或字典规定如何remap存储位置
• pickle_module - 用于unpickling元数据和对象的模块

6. 并行化 Parallelism

torch.get_num_threads():

获得用于并行化CPU操作的OpenMP线程数

torch.set_num_threads(int):

设定用于并行化CPU操作的OpenMP线程数

7. 数学操作 Math operations

7.1 Pointwise Ops

torch.abs(input, out=None):

计算输入张量的每个元素绝对值

• input(Tensor) - 输入张量
• out(Tensor, optional) - 结果张量

torch.acos(input, out=None):

返回一个新张量，包含输入张量每个元素的反余弦

• input(Tensor) - 输入张量
• out(Tensor, optional)

torch.add(input, value, out=None):

对输入张量input逐元素加上标量值value，并返回结果到一个新的张量。

• input(Tensor) - 输入张量
• value(Number) - 添加到输入每个元素的数
• out(Tensor, optional)

torch.addcdiv(tensor, value=1, tensor1, tensor2, out=None):

用tensor2对tensor1逐元素相除，然后乘以标量值value并加到tensor上。

• tensor(Tensor) - 张量
• value(Number, optional) - 标量
• tensor1(Tensor) - 张量，作为分子
• tensor2(Tensor) - 张量，作为分母
• out(Tensor, optional)

torch.addcmul(tensor, value=1, tensor1, tensor2, out=None):

用tensor2对tensor1逐元素相乘，并对结果乘以标量值value然后加到tensor，张量形状不需要匹配，但元素数量必须一致。

• tensor(Tensor) - 张量
• value(Number, optional) - 标量，
• tensor1(Tensor) - 张量，乘子1
• tensor2(Tensor) - 张量，乘子2
• out(Tensor, optional)

torch.asin(input, out=None):

返回一个新张量，包含输入input张量每个元素的反正弦函数

• input(Tensor) - 输入张量
• out(Tensor, optional)

torch.atan(input, out=None):

返回一个新张量，包含输入input张量每个元素的反正切函数

• input(Tensor)
• out(Tensor, optional)

torch.atan2(input1, input2, out=None):

返回一个新张量，包含两个输入张量input1和input2的反正切函数

• input1(Tensor) - 第一个输入张量
• input2(Tensor) - 第二个输入张量
• out(Tensor, optional)

torch.ceil(input, out=None):

对输入input张量每个元素向上取整，即取不小于每个元素的最小整数，并返回结果到输出

• input(Tensor) - 输入张量
• out(Tensor, optional)

torch.clamp(input, min, max, out=None):

将输入input张量每个元素值约束到区间[min, max]，并返回结果到一个新张量
也可以只设定min或只设定max

• input(Tensor) - 输入张量
• min(Number) - 限制范围下限
• max(Number) - 限制范围上限
• out(Tensor, optional)

torch.cos(input, out=None):

返回一个新张量，包含输入input张量每个元素的余弦

• input(Tensor)
• out(Tensor, optional)

torch.cosh(input, out=None):

• input(Tensor)
• out(Tensor, optional)

torch.div(input, value, out=None):

将input逐元素除以标量值value，并返回结果到输出张量out

• input(Tensor) - 输入张量
• value(Number) - 除数
• out(Tensor, optional)

torch.exp(tensor, out=None):

返回一个新张量，包含输入input张量每个元素的指数

• input(Tensor)
• out(Tensor, optional)

torch.floor(input, out=None):

返回一个新张量，包含输入input张量每个元素的floor，即不大于元素的最大整数。

• input(Tensor)
• out(Tensor, optional)

torch.fmod(input, divisor, out=None):

计算除法余数，余数的正负与被除数相同

• input(Tensor)
• divisor(Tensor or float) - 除数
• out(Tensor, optional)

torch.frac(tensor, out=None):

返回每个元素的分数部分

torch.lerp(start, end, weight, out=None):

对两个张量以start, end做线性插值，将结果返回到输出张量
out = start + weight*(end - start)

• start(Tensor) - 起始点张量
• end(Tensor) - 终止点张量
• weight(float) - 插值公式中的weight
• out(Tensor, optional)

torch.log(input, out=None):

计算input的自然对数

torch.log1p(input, out=None):

计算input + 1的自然对数y = log(x + 1)
对值比较小的输入，此函数比torch.log()更准确

• input(Tensor)
• out(Tensor, optional)

torch.mul(input, value, out=None):

用标量值value乘以输入input的每个元素，并返回一个新的结果张量

torch.mul(input, other, out=None):

两个张量input, other按元素相乘，并返回到输出张量，两个张量形状不须匹配，但总元素数须一致。当形状不匹配时，input的形状作为输出张量的形状

• input(Tensor) - 第一个张量
• other(Tensor) - 第二个张量
• out(Tensor, optional)

torch.neg(input, out=None):

返回一个新张量，包含输入input张量按元素取负。

torch.pow(input, exponent, out=None):

对输入input按元素求exponent次幂，并返回结果张量。幂可以为float数或与input相同元素数的张量

• input(Tensor) - 输入张量
• exponent(float or Tensor) - 幂值
• out(Tensor, optional)

torch.pow(base, input, out=None):

base为标量浮点值，input为张量。

• base(float) - 标量值，指数的底
• input(Tensor) - 幂值
• out(Tensor, optional)

torch.reciprocal(input, out=None):

返回一个新张量，包含输入input张量每个元素的倒数，即1.0/x

torch.remainder(input, divisor, out=None):

返回一个新张量，包含输入input张量每个元素的除法余数，余数与除数有相同的符号。

• input(Tensor) - 被除数
• divisor(Tensor or float) - 除数
• out(Tensor, optional)

torch.round(input, out=None):

返回一个新张量，将输入input张量每个元素四舍五入到最近的整数。

torch.rsqrt(input, out=None):

返回一个新张量，包含输入input张量每个元素的平方根倒数。

torch.sigmoid(input, out=None):

返回一个新张量，包含输入input张量每个元素的sigmoid值

torch.sign(input, out=None):

符号函数：返回一个新张量，包含输入input张量每个元素的正负。

torch.sin(input, out=None):

返回一个新张量，包含输入input张量每个元素的正弦。

torch.sinh(input, out=None):

返回一个新张量，包含输入input张量每个元素的双曲正弦。

torch.sqrt(input, out=None):

返回一个新张量，包含输入input张量每个元素的平方根。

torch.tan(input, out=None):

返回一个新张量，包含输入input张量每个元素的正切。

torch.tanh(input, out=None):

返回一个新张量，包含输入input张量每个元素的双曲正切。

torch.trunc(input, out=None):

返回一个新张量，包含输入input张量每个元素的截断值，使更接近零。即有符号数的小数部分被舍弃。

7.2 Reduction Ops

torch.cumprod(input, dim, out=None) -> Tensor:

返回输入沿指定维度的累积积，如输入是一个N元向量，则结果也是一个N元向量，第i个输出元素值为yi = x1 * x2 * x3 * ...* xi

• input(Tensor) - 输入张量
• dim(int) - 累积乘积操作的维度
• out(Tensor, optional)

torch.cumsum(input, dim, out=None) -> Tensor:

返回输入沿指定维度的累积和

torch.dist(input, other, p=2, out=None) -> Tensor:

返回(input - other)的p范数

• input(Tensor) - 输入张量
• other(Tensor) - 右侧输入张量
• p(float, optional) - 要计算的范数
• out(Tensor, optional)

torch.mean(input) -> float:

返回输入张量所有元素的均值

torch.mean(input, dim, out=None):

返回输入张量给定维度dim上每行的均值，输出形状与输入相同，除了给定维度上为1。

torch.median(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor):

返回输入张量给定维度每行的中位数，同时返回一个包含中位数的索引。dim默认为输入张量的最后一维

• input(Tensor) - 输入张量
• dim(int) - 缩减的维度
• values(Tensor, optional) - 结果张量
• indices(Tensor, optional) - 返回的索引结果张量

torch.mode(input, dim=-1, values=None, indices=None) - > (Tensor, LongTensor):

返回给定维度dim上，每行的众数值，同时返回一个索引张量。dim值默认为输入张量的最后一维。输出形状与输入相同，除了给定维度上为1。

torch.norm(input, p=2) -> float:

返回输入张量input的p范数。

• input(Tensor) - 输入张量
• p(float, optional) - 范数计算中的幂指数值

torch.norm(input, p, dim, out=None) -> Tensor:

返回输入张量给定维度dim上每行的p范数。

torch.prod(input) -> float:

返回输入张量input所有元素的积

torch.prod(input, dim, out=None) -> Tensor:

返回输入张量给定维度上每行的积。

torch.std(input) -> float:

返回输入张量input所有元素的标准差

torch.std(input, dim, out=None):

返回输入张量给定维度上每行的标准差。

torch.sum(input) -> float:

返回输入张量input所有元素的各

torch.sum(input, dim, out=None) -> Tensor:

返回输入疑是给定维度上每行的和

torch.var(input) -> float:

返回输入张量所有元素的方差

torch.var(input, dim, out=None) -> Tensor:

返回输入张量给定维度上每行的方差。

7.3 比较操作Comparison Ops

torch.eq(input, other, out=None) -> Tensor:

比较元素相等性，第二个参数可为一个数，或与第一个参数同类型形状的张量

• input(Tensor) - 待比较张量
• other(Tensor or float) - 比较张量或数
• out(Tensor, optional) - 输出张量，须为ByteTensor类型或与input同类型

torch.equal(tensor1, tensor2) -> bool:

若两个张量有相同的形状和元素值，则返回True， 否则False。

torch.ge(input, other, out=None) -> Tensor:

逐元素比较input和other，即是否input >= other
第二个参数可以为一个数或与第一个参数相同形状和类型的张量。

• input(Tensor) - 待对比的张量
• other(Tensor or float) - 对比的张量或float值
• out(Tensor, optional) - 输出张量，必须为ByteTensor或与第一个参数相同类型。

torch.gt(input, other, out=None) -> Tensor:

逐元素比较input和other，是否input > other。若两个张量有相同的形状和元素值，则返回True，否则False。第二个参数
可以为一个数或与第一个参数相同形状和类型的张量。

torch.kthvalue(input, k, dim=None, out=None) -> (Tensor, LongTensor):

取输入张量input指定维度上第k个最小值，若不指定dim，则默认为input的最后一维。返回一个元组，其中indices是原始输入张量input中沿dim维的第k个最小值下标。

• input(Tensor) - 输入张量
• k(int) - 第k个最小值
• dim(int, optional)` - 沿着此维度进行排序
• out(tuple, optional) - 输出元组

torch.le(input, other, out=None) -> Tensor:

逐元素比较input和other，即是否input <= other，第二个参数可以为一个数或与第一个参数相同形状和类型的张量。

torch.lt(input, other, out=None) -> Tensor:

逐元素比较input和other，即是否input < other

torch.max(input, dim, max=None, max_indice=None) -> (Tensor, LongTensor):

返回输入张量给定维度上每行的最大值，并同时返回每个最大值的位置索引。

• input(Tensor) - 输入张量
• dim(int) - 指定的维度
• max(Tensor, optional) - 结果张量，包含给定维度上的最大值
• max_indices(LongTensor, optional) - 包含给定维度上每个最大值的位置索引。

torch.min(input, dim, min=None, min_indices=None) -> (Tensor, LongTensor):

返回输入张量给定维度上每行的最小值，并同时返回每个最小值的位置索引。

torch.min(input, other, out=None) -> Tensor:

input中逐元素与other相应位置的元素对比，返回最小值到输出张量。两张量形状不需匹配，但元素数须相同。

torch.ne(input, other, out=Tensor) -> Tensor:

逐元素比较input和other， 即是否input != other。第二个参数可以为一个数或与第一个参数相同形状和类型的张量。
返回值：一个torch.ByteTensor张量，包含了每个位置的比较结果(如果tensor != other 为True，返回1)。

torch.sort(input, dim=None, descending=False, out=None) -> (Tensor, LongTensor):

对输入张量input沿着指定维度按升序排序，如果不给定dim，默认为输入的最后一维。如果指定参数descending为True，则按降序排序。
返回两项：重排后的张量，和重排后元素在原张量的索引

• input(Tensor) - 输入张量
• dim(int, optional) - 沿此维排序，默认为最后一维
• descending(bool, optional) - 布尔值，默认升序

torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor):

沿给定dim维度返回输入张量input中k个最大值，不指定dim，则默认为最后一维，如果largest为False，则返回最小的k个值。

7.4 其它操作 Other Operations

torch.cross(input, other, dim=-1, out=None) -> Tensor:

返回沿着维度dim上，两个张量input和other的叉积。input和other必须有相同的形状，且指定的dim维上size必须为3。如果不指定dim，则默认为第一个尺度为3的维。

torch.diag(input, diagonal=0, out=None) -> Tensor:

如果输入是一个向量，则返回一个以input为对角线元素的2D方阵
如果输入是一个矩阵，则返回一个包含input为对角元素的1D张量
参数diagonal指定对角线：

• diagonal = 0, 主对角线
• diagonal > 0, 主对角线之上
• diagonal < 0, 主对角线之下

torch.histc(input, bins=100, min=0, max=0, out=None) -> Tensor:

计算输入张量的直方图。如果min和max都为0,则利用数据中的最大最小值作为边界。

torch.renorm(input, p, dim, maxnorm, out=None) -> Tensor:

返回一个张量，包含规范化后的各个子张量，使得沿着dim维划分的各子张量的p范数小于maxnorm。如果p范数的值小于maxnorm，则当前子张量不需要修改。

torch.trace(input) -> float:

返回输入2维矩阵对角元素的和(迹)

torch.tril(input, diagonal=0, out=None) -> Tensor:

返回一个张量，包含输入张量(2D张量)的下三角部分，其余部分设为0，参数diagonal控制对角线。

torch.triu（input, diagonal=0, out=None) -> Tensor:

返回一个张量，包含输入矩阵的上三角部分，其余被置为0。

7.5 BLAS and LAPACK Operations

torch.dot(tensor1, tensor2) -> float:

计算两个张量的点乘，两个张量都为1-D向量

torch.eig(a, eigenvectors=False, out=None) -> (Tensor, Tensor):

计算方阵a的特征值和特征向量。

• a(Tensor) - 方阵
• eigenvectors(bool) - 如果为True，同时计算特征值和特征微量，否则只计算特征值
  返回值：
• e(Tensor) - a的右特征向量
• v(Tensor) - 如果eigenvectors为True，则为包含特征向量的张量，否则为空。

torch.inverse(input, out=None) -> Tensor:

对方阵input求逆

torch.mm(mat1, mat2, out=None) -> Tensor:

对矩阵mat1和mat2进行相乘。

torch.mv(mat, vec, out=None) -> Tensor:

对矩阵mat和向量vec进行相乘。