Pytorch 学习（4）： Pytorch中Torch 工具包的数学操作汇总速查

torch package 包含了多维张量的数据结构, 以及基于其上的多种数学操作. 此外, 它还提供了许多用于高效序列化 Tensor 和任意类型的实用工具包, 以及一起其它有用的实用工具包.

torch的操作方法汇总如下：

Tensors (张量)
torch.is_tensor(*obj*)	如果 obj 是一个 pytorch tensor, 则返回True.
torch.is_storage(*obj*)	如果 obj 是一个 pytorch storage object, 则返回True
torch.set_default_tensor_type(t)	设置默认类型
torch.numel(**input) → int**	返回 input Tensor 中的元素总数
torch.set_printoptions(*precision=None, threshold=None, edgeitems=None, linewidth=None, profile=None*)	设置打印选项. 从 Numpy 中采集数据


Creation Ops (创建操作)
torch.eye(n, *m=None, out=None*)	返回对角线位置全为1, 其它位置全为0的二维 tensor
torch.from_numpy(**ndarray) → Tensor**	从 numpy.ndarray 类创建一个 Tensor 类
torch.linspace(*start, end, steps=100, *out=None) → Tensor**	返回 start 和 end 之间等间隔 steps 点的一维 Tensor.输出是尺寸 steps 为一维 tensor
torch.logspace(*start, end, steps=100, *out=None) → Tensor**	返回一个在 10^start和 10^end之间的对数间隔 steps 点的一维 Tensor，输出是长度为 steps 的一维 tensor
torch.ones(sizes, *out=None) → Tensor**	返回填充了标量值 1 的 Tensor, 其形状由可变参数 sizes 定义
torch.ones_like(*input, *out=None) → Tensor**	返回一个用标量值 1 填充的张量, 大小与 input 相同
torch.arange(*start=0, end, step=1, *out=None) → Tensor**	从 start 用步长为 step 开始, 间隔在 [start, end) 中的值返回大小层次为 floor((end−start)/step)floor((end−start)/step) 的一维 Tensor.
torch.range(*start, end, step=1, *out=None) → Tensor**	返回一个在 start 到 end 并且步长为 step 的区间内, 大小为 floor((end−start)/step)+1floor((end−start)/step)+1 为一维 Tensor.
torch.zeros(sizes, *out=None) → Tensor**	返回填充了标量值为 0 的 Tensor, 其形状由可变参量 sizes 定义
torch.zeros_like(*input, *out=None) → Tensor**	返回一个用标量值 0 填充的 Tensor, 其大小与 input 相同.



Indexing, Slicing, Joining, Mutating Ops (索引, 切片, 连接, 换位) 操作
torch.cat(*seq, dim=0, *out=None) → Tensor**	在给定维度上对输入的张量序列 seq 进行连接操作. 所有张量必须具有相同的形状(在 cat 维度中除外) 或为空.
torch.chunk(tensor, chunks, dim=0)	在给定维度(轴)上将输入张量进行分块处理.
torch.gather(*input, dim, index, *out=None) → Tensor**	沿给定轴 dim ,将输入索引张量 index 指定位置的值进行聚合.
torch.index_select(*input, dim, index, *out=None) → Tensor**	沿着指定维度 dim 对输入进行切片,取 index 中指定的相应项 ( index 为一个 LongTensor ),然后返回到一个新的张量.返回的张量与原始张量 Tensor 有相同的维度(在指定轴上)
torch.masked_select(*input, mask, *out=None) → Tensor**	根据掩码张量 mask 中的二元值,取输入张量中的指定项 ( mask 为一个 ByteTensor ),将取值返回到一个新的一维张量.张量 mask 与 input 的 shape 或维度不需要相同,但是他们必须是 broadcastable .
torch.nonzero(*input, *out=None) → LongTensor**	返回一个包含输入 input 中非零元素索引的张量. 输出张量中的每行包含 input 中非零元素的索引.如果输入张量 input 有 n 维,则输出的索引张量 out 的 size 为 z x n , 这里 z 是输入张量 input 中所有非零元素的个数.
torch.split(tensor, split_size, dim=0)	将输入张量分割成相等 size 的 chunks (如果可分).如果沿指定维的张量形状大小不能被 split_size 整分, 则最后一个分块会小于其它分块
torch.squeeze(input, dim=None, out=None)	将 input 张量 size 中的 1 去除并返回.如果 input 的 shape 如 (Ax1xBxCx1xD)(Ax1xBxCx1xD) ,那么输出 shape 就为: (AxBxCxD)
torch.stack(sequence, dim=0, out=None)	沿着一个新维度对输入张量序列进行连接.序列中所有的张量都应该为相同 size .
torch.t(*input, *out=None) → Tensor**	预期 input 为一个矩阵 (2 维张量), 并转置 0, 1 维.可以被视为函数 transpose(input, 0, 1) 的简写函数
torch.take(*input, *indices) → Tensor**	在给定的索引处返回一个新的 Tensor ,其元素为 input . 输入张量被看作是一维张量.结果与索引具有相同的 shape
torch.transpose(*input, dim0, dim1, *out=None) → Tensor**	返回输入矩阵 input 的转置.交换给定维度 dim0 和 dim1 .out 张量与 input 张量共享内存,所以改变其中一个会导致另外一个也被修改.
torch.unbind(tensor, dim=0)	移除一个张量的维度
torch.unsqueeze(input, dim, out=None)	返回在指定位置插入维度 size 为 1 的新张量.返回张量与输入张量共享内存,所以改变其中一个的内容会改变另一个.如果 dim 为负,则将会被转化 dim+input.dim()+1



Random sampling (随机采样)
torch.manual_seed(seed)	设置生成随机数的种子,并返回一个 torch._C.Generator 对象
torch.initial_seed()	返回用于生成随机数字的初始种子 (python long)
torch.get_rng_state()	以ByteTensor的形式返回随机数发生器的状态
torch.set_rng_state(new_state)	设置随机数发生器的参数
torch.bernoulli(*input, *out=None) → Tensor**	从伯努利分布中抽取二进制随机数 (0 或 1)
torch.multinomial(*input, num_samples, replacement=False, *out=None)→ LongTensor**	返回一个张量, 其中每一行包含在 input 张量对应行中多项式分布取样的 num_samples 索引
torch.normal(means, std, out=None)	返回一个随机数张量, 随机数从给定平均值和标准差的离散正态分布中抽取.
torch.normal(mean=0.0, std, out=None)	功能与上面函数类似, 但所有被抽取的元素共享均值
torch.normal(means, std=1.0, out=None)	功能与上面函数类似, 但所有被抽取的元素共享标准差
torch.rand(sizes, *out=None) → Tensor**	在区间 [0,1)[0,1) 中, 返回一个填充了均匀分布的随机数的张量.这个张量的形状由可变参数 sizes 来定义
torch.randn(sizes, *out=None) → Tensor**	返回一个从正态分布中填充随机数的张量, 其均值为 0 , 方差为 1 .这个张量的形状被可变参数 sizes 定义
torch.randperm(n, **out=None) → LongTensor**	返回一个从 0 to n - 1 的整数的随机排列
In-place random sampling (直接随机采样)
torch.Tensor.bernoulli_()	torch.bernoulli() 的 in-place 版本
torch.Tensor.cauchy_()	从柯西分布中抽取数字
torch.Tensor.exponential_()	从指数分布中抽取数字
torch.Tensor.geometric_()	从几何分布中抽取元素
torch.Tensor.log_normal_()	对数正态分布中的样本
torch.Tensor.normal_()	是 torch.normal() 的 in-place 版本
torch.Tensor.random_()	离散均匀分布中采样的数字
torch.Tensor.uniform_()	正态分布中采样的数字


Serialization (序列化)
torch.save(obj, f, pickle_module=<module 'cPickle' from '/usr/lib64/python2.7/lib-dynload/cPickle.so'>, pickle_protocol=2)	将一个对象保存到一个磁盘文件中.
torch.load(f, map_location=None, pickle_module=<module 'cPickle' from '/usr/lib64/python2.7/lib-dynload/cPickle.so'>)	从磁盘文件中加载一个用 torch.save() 保存的对象.


Parallelism (并行化)
torch.get_num_threads() → int	获得 OpenMP 并行化操作的线程数目
torch.set_num_threads(int)	设置 OpenMP 并行化操作的线程数目


Math operations (数学操作)
Pointwise Ops (逐点操作)
torch.abs(*input, *out=None) → Tensor**	计算给定 input 张量的元素的绝对值
torch.acos(*input, *out=None) → Tensor**	用 input 元素的反余弦返回一个新的张量
torch.add(input, value, out=None)	将标量值 value 添加到输入张量 attr:input 的每个元素并返回一个新的结果张量
torch.add(input, value=1, other, out=None)	张量 other 的每个元素乘以标量值 value 并加到张量 input 上, 返回生成的张量 out
torch.addcdiv(*tensor, value=1, tensor1, tensor2, *out=None) → Tensor**	将张量 tensor1 逐元素除以张量 tensor2, 然后乘以标量值 value 并加到张量 tensor 上.
torch.addcmul(*tensor, value=1, tensor1, tensor2, *out=None) → Tensor**	将张量 tensor1 逐元素与张量 tensor2 相乘, 然后乘以标量值 value 并加到张量 tensor 上.
torch.asin(*input, *out=None) → Tensor**	返回一个新的 Tensor , 其元素为张量 input 的每个元素的反正弦
torch.atan(*input, *out=None) → Tensor**	返回一个新的 Tensor , 其元素为张量 input 的每个元素的反正切
torch.atan2(*input1, input2, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是输入张量 input1 和输入张量 input2 元素的反正切.
torch.ceil(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是张量 input 的元素向上取整(取不小于每个元素的最小整数).
torch.clamp(*input, min, max, *out=None) → Tensor**	将输入张量 input 所有元素限制在区间 [min, max] 中并返回一个结果张量
torch.clamp(*input, , *min, *out=None) → Tensor**	张量 input 的所有元素值大于或者等于 min
torch.clamp(*input, , *max, *out=None) → Tensor**	张量 input 的所有元素值小于或者等于 max.
torch.cos(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是张量 input 每个元素的余弦
torch.cosh(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是张量 input 每个元素的双曲余弦
torch.div(input, value, out=None)	将张量 input 的元素逐一除以标量值 value , 其结果作为一个新的张量返回.
torch.div(input, other, out=None)	张量 input 的元素与张量 other 的元素逐一相除. 返回一个新的结果张量 out . 张量 input 与张量 other 的形状必须可 broadcastable.outi=inputi/otheri
torch.erf(*tensor, *out=None) → Tensor**	计算每个元素的误差函数
torch.erfinv(*tensor, *out=None) → Tensor**	计算每个元素的反向误差函数
torch.exp(*tensor, *out=None) → Tensor**	计算每个元素的指数
torch.floor(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是张量 input 的元素向下取整(取不大于每个元素的最大整数).
torch.fmod(*input, divisor, *out=None) → Tensor**	计算除法余数.
torch.frac(*tensor, *out=None) → Tensor**	计算张量 tensor 每个元素的分数部分.
torch.lerp(start, end, weight, out=None)	基于标量值 weight: , 在张量 start 与张量 end 之间做线性插值并返回结果张量 out 。outi=starti+weight∗(endi−starti)
torch.log(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是张量 input 所有元素的自然对数.
torch.log1p(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是(1 + input) 的自然对数.yi=log(xi+1)
torch.mul(input, value, out=None)	将输入张量 input 的每个元素与标量值 value 相乘并返回一个新的结果张量.out=tensor∗value
torch.mul(input, other, out=None)	张量 input 的元素与张量 other 的元素逐一相乘. 其结果作为一个新的张量返回.
torch.neg(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是张量 input 的元素的负值.out=−1∗input
torch.pow(input, exponent, out=None)	对输入张量 input 按元素求 exponent 次幂值并返回结果张量(其值作为结果张量的元素).
torch.pow(base, input, out=None)	base 是一个标量浮点值, input 是一个张量. 返回的张量 out 的形状与张量 input 的形状相同.
torch.reciprocal(*input, *out=None) → Tensor**	返回一个新的 Tensor , 其元素是张量 input 元素的倒数, i.e. 1.0/x
torch.remainder(*input, divisor, *out=None) → Tensor**	计算元素的除法的余数.
torch.round(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是输入张量的元素四舍五入到最近的整数
torch.rsqrt(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是张量 input 元素的平方根的倒数.
torch.sigmoid(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是张量 input 元素的sigmoid值
torch.sign(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是张量 input 元素的符号.
torch.sin(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是张量 input 元素的正弦.
torch.sinh(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是张量 input 元素的双曲正弦
torch.sqrt(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是张量 input 元素的平方根
torch.tan(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是张量 input 元素的正切
torch.tanh(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是张量 input 元素的双曲正切
torch.trunc(*input, *out=None) → Tensor**	返回一个新的张量 Tensor , 其元素是张量 input 元素的截断整数值 (直接去除小数部分) .
Reduction Ops (归约操作)
torch.cumprod(*input, dim, *out=None) → Tensor**	返回元素 input 在给定维度 dim 下的累积积
torch.cumsum(*input, dim, *out=None) → Tensor**	返回元素 input 在给定维度 dim 下的累积和
torch.dist(*input, other, *p=2) → float**	返回(input - other)的p-范数 input 和 other 的形状必须满足 broadcastable.
torch.mean(**input) → float**	返回张量 input 所有元素的均值.
torch.mean(*input, dim, keepdim=False, *out=None) → Tensor**	返回张量 input 在给定维度 dim 上每行的均值
torch.median(**input) → float**	返回输出张量 input 所有元素的中位数.
torch.median(input, dim=-1, keepdim=False, values=None, indices=None) -> (Tensor, LongTensor)	返回输出张量 input 在给定维度 dim 下每行的中位数. 同时返回一个包含中位数的索引 LongTensor.
torch.mode(input, dim=-1, keepdim=False, values=None, indices=None) -> (Tensor, LongTensor)	返回输入张量 input 在给定维数 dim 下每行元素的众数值. 同时也返回众数值的索引 LongTensor.
torch.norm(*input, *p=2) → float**	返回输入张量 input 的p-范数
torch.norm(*input, p, dim, keepdim=False, *out=None) → Tensor**	返回输入张量 input 在给定维度 dim 下每行元素的p-范数.
torch.prod(**input) → float**	返回输入张量 input 所有元素的乘积.
torch.prod(*input, dim, keepdim=False, *out=None) → Tensor**	返回输入张量 input 在给定维度 dim 下每行元素的积.
torch.std(*input, *unbiased=True) → float**	返回输入张量 input 所有元素的标准差
torch.std(*input, dim, keepdim=False, unbiased=True, *out=None) → Tensor**	返回输入张量 input 在给定维度 dim 下每行元素的标准差
torch.sum(**input) → float**	返回输入张量 input 所有元素的和
torch.sum(*input, dim, keepdim=False, *out=None) → Tensor**	返回输入张量 input 在给定维度 dim 下每行元素的和
torch.var(*input, *unbiased=True) → float**	返回输入张量 input 的方差.
torch.var(*input, dim, keepdim=False, unbiased=True, *out=None) → Tensor**	返回输入张量 input 在给定维度 dim 下每行的方差
Comparison Ops (比较操作)
torch.eq(*input, other, *out=None) → Tensor**	比较元素是否相等
torch.equal(*tensor1, *tensor2) → bool**	如果两个张量有相同的形状和元素值, 则返回 True , 否则 False .
torch.ge(*input, other, *out=None) → Tensor**	逐元素比较 input 和 other , 即是否 input>=other .
torch.gt(*input, other, *out=None) → Tensor**	逐元素比较 input 和 other , 即是否 input>other 如果两个张量有相同的形状和元素值, 则返回 True ,否则 False
torch.kthvalue(input, k, dim=None, keepdim=False, out=None) -> (Tensor, LongTensor)	取输入张量 input 指定维上第 k 个最小值. 如果不指定 dim , 则默认为 input 的最后一维
torch.le(*input, other, *out=None) → Tensor**	逐元素比较 input 和 other , 即是否 input<=other 如果两个张量有相同的形状和元素值, 则返回 True ,否则 False .
torch.lt(*input, other, *out=None) → Tensor**	逐元素比较 input 和 other , 即是否 input<other 如果两个张量有相同的形状和元素值, 则返回 True ,否则 False
torch.max(**input) → float**	返回输入 input 张量所有元素的最大值
torch.max(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor)	返回输入张量 input 在给定维度 dim 上每行的最大值, 并同时返回每个最大值的位置索引.
torch.max(*input, other, *out=None) → Tensor**	输入 input 每一个元素和对应的比较张量 other 进行比较, 留下较大的元素 max.
torch.min(**input) → float**	返回输入张量 input 所有元素的最小值
torch.min(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor)	返回输入张量 input 在给定维度 dim 下每行元素的最小值. 其中第二个返回值是每个被找出的最小值的索引位置 ( argmin )
torch.min(*input, other, *out=None) → Tensor**	输入 input 每一个元素和对应的比较张量 other 进行比较, 留下较小的元素 min .
torch.ne(*input, other, *out=None) → Tensor**	逐元素比较 input 和 other , 即是否 tensor != other 如果两个张量有相同的形状和元素值, 则返回 True , 否则 False .
torch.sort(input, dim=None, descending=False, out=None) -> (Tensor, LongTensor)	对输入张量 input 沿着指定维按升序排序.
torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor)	沿给定 dim 维度返回输入张量 input 中 k 个最大值. 如果不指定 dim , 则默认为 input 的最后一维. 如果为 largest 为 False ,则返回最小的 k 个值. 返回一个元组 (values, indices) , 其中 indices 是原始输入张量 input 中测元素下标. 如果设定布尔值 sorted 为 True , 将会确保返回的 k 个值被排序.
Other Operations (其它操作)
torch.cross(*input, other, dim=-1, *out=None) → Tensor**	返回沿着维度 dim 上, 两个张量 input 和 other 的向量积 (叉积), input 和 other 必须有相同的形状, 且指定的 dim 维上 size 必须为 3.
torch.diag(*input, diagonal=0, *out=None) → Tensor**	如果输入是一个向量( 1D 张量), 则返回一个以 input 为对角线元素的 2D 方阵.如果输入是一个矩阵( 2D 张量), 则返回一个包含 input 对角线元素的1D张量.
torch.histc(*input, bins=100, min=0, max=0, *out=None) → Tensor**	计算输入张量的直方图
torch.renorm(*input, p, dim, maxnorm, *out=None) → Tensor**	返回一个张量, 包含规范化后的各个子张量, 使得沿着 dim 维划分的各子张量的 p 范数小于 maxnorm
torch.trace(**input) → float**	返回输入 2 维矩阵对角线元素的和(迹).
torch.tril(*input, diagonal=0, *out=None) → Tensor**	返回一个张量, 包含输入矩阵 ( 2D 张量)的下三角部分, 其余部分被设为 0.
torch.triu(*input, diagonal=0, *out=None) → Tensor**	返回一个张量, 包含输入矩阵 ( 2D 张量)的上三角部分, 其余部分被设为 0.



BLAS and LAPACK Operations (BLAS和LAPACK操作)
torch.addbmm(*beta=1, mat, alpha=1, batch1, batch2, *out=None) → Tensor**	执行保存在 batch1 和 batch2 中的矩阵的批量点乘, 伴随着一个减少的相加步骤 (所有的矩阵乘法沿第一维累加). mat 被相加到最终的结果中.
torch.addmm(*beta=1, mat, alpha=1, mat1, mat2, *out=None) → Tensor**	执行矩阵 mat1 和 mat2 的相乘. 矩阵 mat 将与相乘的最终计算结果相加.
torch.addmv(*beta=1, tensor, alpha=1, mat, vec, *out=None) → Tensor**	执行矩阵 mat 和向量 vec 的相乘. 矩阵 tensor 将与相乘的最终计算结果相加.
torch.addr(*beta=1, mat, alpha=1, vec1, vec2, *out=None) → Tensor**	执行向量:attr:vec1 和 vec2 的外积, 并把外积计算结果与矩阵 mat相加
torch.baddbmm(*beta=1, mat, alpha=1, batch1, batch2, *out=None) → Tensor**	执行保存在 batch1 和 batch2 中的矩阵的批量点乘. mat 被相加到最终的结果中.
torch.bmm(*batch1, batch2, *out=None) → Tensor**	执行保存在 batch1 和 batch2 中的矩阵的批量点乘.
torch.btrifact(A, *info=None, *pivot=True) → Tensor, IntTensor**	批量 LU 分解.
torch.btrisolve(b, *LU_data, *LU_pivots) → Tensor**	批量 LU 解.返回线性系统 Ax = b 的 LU 解
torch.dot(*tensor1, *tensor2) → float**	计算两个张量的点乘 (内积).
torch.eig(a, eigenvectors=False, out=None) -> (Tensor, Tensor)	计算实数方阵的特征值和特征向量.
torch.gels(B, A, **out=None) → Tensor**	计算秩为 mm 的，大小为 m x n 的矩阵 AA 最小二乘和最小范数问题的解
torch.geqrf(input, out=None) -> (Tensor, Tensor)	直接调用 LAPACK 的低层函数
torch.ger(*vec1, vec2, *out=None) → Tensor**	计算 vec1 和 vec2 的外积. 如果 vec1 是一个长度为 n 的向量, vec2 是一个长度为 m 的向量, 那么 out 必须是一个 n x m 的矩阵
torch.gesv(B, A, out=None) -> (Tensor, Tensor)	X, LU = torch.gesv(B, A) , 该函数返回线性系统 AX=B 的解
torch.inverse(*input, *out=None) → Tensor**	计算方阵 input 的逆.
torch.matmul(tensor1, tensor2, out=None)	Matrix product of two tensors
torch.mm(*mat1, mat2, *out=None) → Tensor**	执行 mat1 和 mat2 的矩阵乘法.
torch.mv(*mat, vec, *out=None) → Tensor**	执行矩阵 mat 与向量 vec 的乘法操作.
torch.potrf(a, out=None)	计算半正定矩阵 a: 的 Cholesky 分解
torch.potri(u, out=None)	给定一个半正定矩阵的 Cholesky 分解因子 u, 计算该半正定矩阵的逆.
torch.potrs(b, u, out=None)	Solves a linear system of equations with a positive semidefinite matrix to be inverted given its given a Cholesky factor matrix u
torch.pstrf(a, out=None)	Computes the pivoted Cholesky decomposition of a positive semidefinite matrix a: returns matrices u and piv
torch.qr(input, out=None) -> (Tensor, Tensor)	计算矩阵 input 的 QR 分解. 返回矩阵 q 和 r 使得 x=q∗rx=q∗r, 且 q 是一个正交矩阵, r 是一个上三角矩阵
torch.svd(input, some=True, out=None) -> (Tensor, Tensor, Tensor)	U, S, V = torch.svd(A) 返回大小为 (n x m) 的实矩阵 A 的奇异值分解, 使得 A=USV′∗
torch.symeig(input, eigenvectors=False, upper=True, out=None) -> (Tensor, Tensor)	e, V = torch.symeig(input) 返回实对称矩阵 input 的特征值和特征向量.

详细案例参考Pytorch官网链接（http://pytorch.apachecn.org/cn/docs/0.3.0/torch.html#reduction-ops）

The development of full artificial intelligencecould spell the end of the human race。
人工智能的发展可能会终结人类。

-----斯蒂芬·威廉·霍金（Stephen WilliamHawking）

Pytorch 学习（4）： Pytorch中Torch 工具包的数学操作汇总速查

猜你喜欢