pytorch【笔记】

pytorch中常用的函数。

torch.is_tensor

• 用法：torch.is_tensor(temp)
• 作用：判断temp是不是一个tensor类型的数据，是的话返回true不是则返回false

torch.is_storage

Storage类型是pytorch中的一个类型，它与tensor是对应的。 tensor分为头信息区(Tensor)和
存储区(Storage)。信息区主要存储tensor的形状、步长、数据类型等信息，真正的数据保存为连续数组，存储在存储区中。

在PyTorch中，张量（tensor）对象和底层存储（storage）对象是分开存储的。张量对象仅仅包含元数据（如形状和数据类型），而不包含元素的实际值。相反，张量中存储的是一个指向底层存储对象的指针，底层存储中存储了实际的元素值。print(a.storage())输出的结果是底层存储中的元素值，而不是存储的地址或指针。如果想要获取底层存储的内存地址，可以使用a.storage().data_ptr()方法。

• 用法：torch.is_storage(temp)
• 作用：判断temp是不是一个pytorch storage类型的对象，是的话返回true不是则返回false。

torch.__set_default_tensor_type

• 作用：设置pytorch中默认的浮点类型。

文章推荐

torch.numel

• 用法: torch.numel(temp)
• 作用：返回temp张量中的元素个数。

torch.set_printoptions

• 用法：torch.set_printoptions(precision=None, threshold=None,edgeitems=None, linewidth=None, profile=None)

• 作用：设置打印选项。

  • precision-浮点数输出的精度位数 (默认为 8 )。
  • threshold – 阈值，触发汇总显示而不是完全显示(repr)的数组元素的总数 (默认为 1000)。
  • edgeitems – 汇总显示中，每维（轴）两端显示的项数(默认值为 3)。
  • linewidth – 用于插入行间隔的每行字符数（默认为 80）。Thresholded matricies will ignore this parameter。
  • profile – pretty 打印的完全默认值。 可以覆盖上述所有选项 (默认为 short, full)。

torch.eye

• 用法：torch.eye(n, m=None, out=None)
• 作用：返回一个对角矩阵
  • n (int ) – 行数
  • m (int, optional) – 列数.如果为 None,则默认为 n
  • out (Tensor, optinal) - Output tensor

from_numpy

• 用法：torch.from_numpy(temp)

• 作用：Numpy 桥，将 numpy.ndarray 转换为 pytorch 的 Tensor。返回的张量 tensor 和 numpy

  的 ndarray 共享同一内存空间。修改一个会导致另外一个也被修改。返回的张量不能改变大

  小。

torch.linspace

• 用法：torch.linspace(start, end, steps=100, out=None)

• 作用: 返回一个 1 维张量，包含在区间 start 和 end 上均匀间隔的 step 个点。 输出 1 维张量

  的长度为steps。

torch.logspace

• 用法：torch.logspace(start, end, steps=100, out=None)

• 作用: 返回一个1维张量，包含在区间10^start和10^end上以对数刻度均匀间隔的 steps 个点。

  输出1维张量的长度为 steps。

torch.ones

• 用法：torch.ones(*sizes, out=None) → Tensor

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

torch.rand

• 用法：torch.rand(*sizes, out=None) → Tensor

• 作用：返回一个张量，包含了从区间[0,1)的均匀分布中抽取的一组随机数，形状由可变参数

  sizes 定义。

torch.randn

• 用法：torch.randn(*sizes, out=None) → Tensor
• 作用：返回一个张量，包含了从标准正态分布(均值为 0，方差为 1，即高斯白噪声)中抽取一组随机数，形状由可变参数 sizes 定义。

torch.randperm

• 用法：torch.randperm(n, out=None) → LongTensor
• 作用：给定参数 n，返回一个从 0 到 n-1 的随机整数排列。

torch.arange

• 用法：torch.arange(start, end, step=1, out=None) → Tensor
• 作用: 返回一个 1 维张量，长度为 floor((end−start)/step)。包含从 start 到 end，以 step 为步长的一组序列值(默认步长为 1)。

torch.zeros

• 用法: torch.zeros(*sizes, out=None) → Tensor
• 作用: 返回一个全为标量 0 的张量，形状由可变参数 sizes 定义。

torch.cat

• 用法: torch.cat(inputs, dimension=0) → Tensor
• 作用: 在给定维度上对输入的张量序列 seq 进行连接操作。

tensor([[[6.9594e-04, 3.6253e-01, 7.6570e-01, 4.6291e-01],
         [6.4427e-01, 4.8336e-01, 8.9257e-01, 8.5959e-02],
         [2.0228e-01, 8.4989e-01, 2.0906e-01, 1.3927e-02]],

        [[9.8929e-01, 5.9420e-01, 4.2963e-02, 4.3119e-01],
         [7.3574e-01, 3.5665e-01, 2.7318e-01, 4.1550e-01],
         [2.6392e-01, 8.3804e-01, 5.9530e-01, 4.0026e-01]]])
tensor([[[6.9594e-04, 3.6253e-01, 7.6570e-01, 4.6291e-01],
         [6.4427e-01, 4.8336e-01, 8.9257e-01, 8.5959e-02],
         [2.0228e-01, 8.4989e-01, 2.0906e-01, 1.3927e-02]],

        [[9.8929e-01, 5.9420e-01, 4.2963e-02, 4.3119e-01],
         [7.3574e-01, 3.5665e-01, 2.7318e-01, 4.1550e-01],
         [2.6392e-01, 8.3804e-01, 5.9530e-01, 4.0026e-01]],

        [[6.9594e-04, 3.6253e-01, 7.6570e-01, 4.6291e-01],
         [6.4427e-01, 4.8336e-01, 8.9257e-01, 8.5959e-02],
         [2.0228e-01, 8.4989e-01, 2.0906e-01, 1.3927e-02]],

        [[9.8929e-01, 5.9420e-01, 4.2963e-02, 4.3119e-01],
         [7.3574e-01, 3.5665e-01, 2.7318e-01, 4.1550e-01],
         [2.6392e-01, 8.3804e-01, 5.9530e-01, 4.0026e-01]]])
tensor([[[6.9594e-04, 3.6253e-01, 7.6570e-01, 4.6291e-01],
         [6.4427e-01, 4.8336e-01, 8.9257e-01, 8.5959e-02],
         [2.0228e-01, 8.4989e-01, 2.0906e-01, 1.3927e-02],
         [6.9594e-04, 3.6253e-01, 7.6570e-01, 4.6291e-01],
         [6.4427e-01, 4.8336e-01, 8.9257e-01, 8.5959e-02],
         [2.0228e-01, 8.4989e-01, 2.0906e-01, 1.3927e-02]],

        [[9.8929e-01, 5.9420e-01, 4.2963e-02, 4.3119e-01],
         [7.3574e-01, 3.5665e-01, 2.7318e-01, 4.1550e-01],
         [2.6392e-01, 8.3804e-01, 5.9530e-01, 4.0026e-01],
         [9.8929e-01, 5.9420e-01, 4.2963e-02, 4.3119e-01],
         [7.3574e-01, 3.5665e-01, 2.7318e-01, 4.1550e-01],
         [2.6392e-01, 8.3804e-01, 5.9530e-01, 4.0026e-01]]])
tensor([[[6.9594e-04, 3.6253e-01, 7.6570e-01, 4.6291e-01, 6.9594e-04,
          3.6253e-01, 7.6570e-01, 4.6291e-01],
         [6.4427e-01, 4.8336e-01, 8.9257e-01, 8.5959e-02, 6.4427e-01,
          4.8336e-01, 8.9257e-01, 8.5959e-02],
         [2.0228e-01, 8.4989e-01, 2.0906e-01, 1.3927e-02, 2.0228e-01,
          8.4989e-01, 2.0906e-01, 1.3927e-02]],

        [[9.8929e-01, 5.9420e-01, 4.2963e-02, 4.3119e-01, 9.8929e-01,
          5.9420e-01, 4.2963e-02, 4.3119e-01],
         [7.3574e-01, 3.5665e-01, 2.7318e-01, 4.1550e-01, 7.3574e-01,
          3.5665e-01, 2.7318e-01, 4.1550e-01],
         [2.6392e-01, 8.3804e-01, 5.9530e-01, 4.0026e-01, 2.6392e-01,
          8.3804e-01, 5.9530e-01, 4.0026e-01]]])

torch.chunk

• 用法：torch.chunk(tensor, chunks, dim=0)
• 作用: 在给定维度(轴)上将输入张量进行分块儿。
  • tensor (Tensor) – 待分块的输入张量。
  • chunks (int) – 分块的个数。
  • dim (int) – 沿着此维度进行分块。

torch.gather

• 用法: torch.gather(input, dim, index, out=None) → Tensor
• 作用: 沿给定轴 dim，将输入索引张量 index 指定位置的值进行聚合。

好的文章

torch.index_select

• 用法: torch.index_select(input, dim, index, out=None) → Tensor
• 作用: 沿着指定维度对输入进行切片，取 index 中指定的相应项(index 为一个 LongTensor)，然后返回到一个新的张量， 返回的张量与原始张量_Tensor_有相同的维度(在指定轴上)。注意： 返回的张量不与原始张量共享内存空间。

torch.masked_select

• 用法：torch.masked_select(input, mask, out=None) → Tensor

• 作用：根据掩码张量 mask 中的二元值，取输入张量中的指定项( mask 为一个 ByteTensor)，将取

  值返回到一个新的 1D 张量，张量 mask 须跟 input 张量有相同数量的元素数目，但形状或维度不需要相同。 注意：返回的张量不与原始张量共享内存空间。

torch.nonzero

• 用法：torch.nonzero(input, out=None) → LongTensor
• 作用：返回一个包含输入 input 中非零元素索引的张量。输出张量中的每行包含输入中非零元素的索引。

torch.split

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

• 将输入张量分割成相等形状的 chunks（如果可分）。 如果沿指定维的张量形状大小不能被

  split_size 整分， 则最后一个分块会小于其它分块。

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

torch.squeeze

• 用法：torch.squeeze(input, dim=None, out=None)

• 作用：将输入张量形状中的 1 去除并返回。 如果输入是形如(A×1×B×1×C×1×D)，那么输出形状就

  为：(A×B×C×D)当给定 dim 时 ， 那 么 挤 压 操 作 只 在 给 定 维 度 上 。 注意： 返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。

torch.stack

• 用法：torch.stack(sequence, dim=0)
• 作用：沿着一个新维度对输入张量序列进行连接。 序列中所有的张量都应该为相同形状。

torch.t

• 用法：torch.t(input, out=None) → Tensor
• 作用：将张量转置(维度必须是小于等于2维的)

torch.transpose

• 用法：torch.transpose(input, dim0, dim1, out=None) → Tensor

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

  所以改变其中一个会导致另外一个也被修改。

torch.unbind

• 用法：torch.unbind(tensor, dim=0)
• 作用：移除指定维后，返回一个元组，包含了沿着指定维切片后的各个切片。

torch.unsqueeze

• 用法：torch.unsqueeze(input, dim, out=None)
• 作用：返回一个新的张量，对输入的制定位置插入维度 1。比如原来x的size=([4])，x.unsqueeze(0)之后就变成了size=([1, 4])，而x.unsqueeze(1)之后就变成了size=([4, 1])。注意： 返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。如果 dim 为负，则将会被转化 dim+input.dim()+1。

torch.manual_seed

• 用法：torch.manual_seed(seed)

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

torch.initial_seed

• 用法：torch.initial_seed()
• 作用：返回生成随机数的原始种子值（python long）。

torch.get_rng_state

• 用法：torch.get_rng_state()
• 作用: 返回随机生成器状态。

torch.set_rng_state

• 用法：torch.set_rng_state(new_state)
• 作用：设定随机生成器状态。

torch.saves

• 用法：torch.save(obj, f, pickle_module=<module 'pickle' from '/home/jenkins/miniconda/lib/python3.5/pickle.py'>, pickle_protocol=2)

• 作用：保存一个对象到一个硬盘文件上。

  • obj – 保存对象 。

  • f － 类文件对象 (返回文件描述符)或一个保存文件名的字符串。

  • pickle_module – 用于 pickling 元数据和对象的模块。

  • pickle_protocol – 指定 pickle protocal 可以覆盖默认参数。

torch.load

• 用法：torch.load(f, map_location=None, pickle_module=<module 'pickle' from '/home/jenkins/miniconda/lib/python3.5/pickle.py'>)
• 作用：从磁盘文件中读取一个通过 torch.save()保存的对象。 torch.load() 可通过参数map_location 动态地进行内存重映射，使其能从不动设备中读取文件。一般调用时，需两个参数: storage 和 location tag. 返回不同地址中的 storage，或着返回 None (此时地址可以通过默认方法进行解析). 如果这个参数是字典的话，意味着其是从文件的地址标记到当前系统的地址标记的映射。默认情况下， location tags 中 "cpu"对应 host tensors，‘cuda:device_id’ (e.g. ‘cuda:2’) 对应 cuda tensors。 用户可以通过 register_package 进行扩展，使用自己定义的标记和反序列化方法。
  • f – 类文件对象 (返回文件描述符)或一个保存文件名的字符串。
  • map_location – 一个函数或字典规定如何 remap 存储位置。
  • pickle_module – 用于 unpickling 元数据和对象的模块 (必须匹配序列化文件时的 pickle_module )。

torch.get_num_threads

• 用法：torch.get_num_threads() → int
• 作用: 获得用于并行化 CPU 操作的 OpenMP 线程数。

torch.set_num_threads

• 用法：torch.set_num_threads(int)
• 作用：设定用于并行化 CPU 操作的 OpenMP 线程数。

torch.abs

• 用法：torch.abs(input, out=None) → Tensor
• 作用: 计算输入张量的每个元素绝对值。

torch.acos(）

• 用法：torch.acos(input, out=None) → Tensor
• 作用：返回一个新张量，包含输入张量每个元素的反余弦。

torch.add()

• 用法：torch.add(input, value, out=None)
• 作用：对输入张量 input 逐元素加上标量值 value，并返回结果到一个新的张量 out.

• 用法：torch.add(input, value=1, other, out=None)
• 作用：other 张量的每个元素乘以一个标量值 value，并加到 iput 张量上。返回结果到输出张量 out。即，out=input+(other∗value).

​c=a+10*b

torch.addcdiv

• 用法：torch.addcdiv(tensor, value=1, tensor1, tensor2, out=None) → Tensor
• 作用：用 tensor2 对 tensor1 逐元素相除，然后乘以标量值 value 并加到 tensor。

torch.addcmul

• 用法：torch.addcmul(tensor, value=1, tensor1, tensor2, out=None) → Tensor
• 作用: 用 tensor2 对 tensor1 逐元素相乘，并对结果乘以标量值 value 然后加到 tensor。

torch.asin

• 用法：torch.asin(input, out=None) → Tensor
• 作用：返回一个新张量，包含输入 input 张量每个元素的反正弦函数。

torch.atan

• 用法：torch.atan(input, out=None) → Tensor
• 作用：返回一个新张量，包含输入 input 张量每个元素的反正切函数。

torch.atan2

• 用法：torch.atan2(input1, input2, out=None) → Tensor
• 作用: 返回一个新张量，包含两个输入张量 input1 和 input2 的反正切函数。

torch.ceil

• 用法: torch.ceil(input, out=None) → Tensor

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

  出。

torch.clamp

• 用法：torch.clamp(input, min, max, out=None) → Tensor
• 作用: 将输入 input 张量每个元素的夹紧到区间 [min,max]，并返回结果到一个新张量。

torch.cos 和 torch.cosh 和 torch.div()

• 用法：torch.cos(input, out=None) → Tensor

• 作用: 返回一个新张量，包含输入 input 张量每个元素的余弦。

• 用法: torch.cosh(input, out=None) → Tensor

• 作用: 返回一个新张量，包含输入 input 张量每个元素的双曲余弦。

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

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

torch.exp

• 用法:torch.exp(tensor, out=None) → Tensor
• 作用: 返回一个新张量，包含输入 input 张量每个元素的指数。

torch.floor

• 用法：torch.floor(input, out=None) → Tensor

• 作用：向下取整。

torch.fmod

• 用法：torch.fmod(input, divisor, out=None) → Tensor
• 作用：其实就是a%b。

torch.frac

• 用法: torch.frac(tensor, out=None) → Tensor
• 作用: 返回每个元素的分数部分。

torch.lerp

• 用法：torch.lerp(start, end, weight, out=None)

• 作用：对两个张量以 start，end 做线性插值， 将结果返回到输出张量。即，outi=starti+weight∗(endi−starti)

  

torch.log

• 用法: torch.log(input, out=None) → Tensor
• 作用: 计算 input 的自然对数。

torch.log1p

• 用法: torch.log1p(input, out=None) → Tensor
• 作用: 计算 input+1 的自然对数 yi=log(xi+1)

torch.mul

• 用法：torch.mul(input, value, out=None)
• 作用：用标量值 value 乘以输入 input 的每个元素，并返回一个新的结果张量。

torch.neg

• 用法: torch.neg(input, out=None) → Tensor
• 作用: 返回一个新张量，包含输入 input 张量按元素取负。

torch.pow

• 用法：torch.pow(input, exponent, out=None)
• 作用：对输入 input 的按元素求 exponent 次幂值，并返回结果张量。

torch.reciprocal

• 用法：torch.reciprocal(input, out=None) → Tensor
• 作用：返回一个新张量，包含输入 input 张量每个元素的倒数，即 1.0/x。

torch.remainder

• 用法：torch.remainder(input, divisor, out=None) → Tensor
• 作用: 返回一个新张量，包含输入 input 张量每个元素的除法余数。 除数与被除数可能同时包含整数或浮点数。余数与除数有相同的符号。

torch.round

• 用法：torch.round(input, out=None) → Tensor
• 作用：返回一个新张量，将输入 input 张量每个元素舍入到最近的整数。

torch.rsqrt

• 用法：torch.rsqrt(input, out=None) → Tensor
• 作用：返回一个新张量，包含输入 input 张量每个元素的平方根倒数。

torch.sigmoid

• 用法：torch.sigmoid(input, out=None) → Tensor
• 作用：返回一个新张量，包含输入 input 张量每个元素的 sigmoid 值。

torch.sign

• 用法：torch.sign(input, out=None) → Tensor
• 作用：符号函数：返回一个新张量，包含输入 input 张量每个元素的正负。

torch.sin 和 torch.sinh

• 用法： torch.sin(input, out=None) → Tensor

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

• 用法: torch.sinh(input, out=None) → Tensor

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

torch.sqrt

• 用法：torch.sqrt(input, out=None) → Tensor
• 作用：返回一个新张量，包含输入 input 张量每个元素的平方根。

torch.tan和torch.tanh

• 用法：torch.tan(input, out=None) → Tensor
• 作用：返回一个新张量，包含输入 input 张量每个元素的正切。
• 用法：torch.tanh(input, out=None) → Tensor
• 作用: 返回一个新张量，包含输入 input 张量每个元素的双曲正切。

torch.trunc

• 用法：torch.trunc(input, out=None) → Tensor
• 作用：返回一个新张量，包含输入 input 张量每个元素的截断值(标量 x 的截断值是最接近其的整数，其比x 更接近零。简而言之，有符号数的小数部分被舍弃)。

torch.cumprod

• 用法：torch.cumprod(input, dim, out=None) → Tensor
• 作用：返回输入沿指定维度的累积积。例如，如果输入是一个 N 元向量，则结果也是一个 N 元向量，第 i 个输出元素值为 yi=x1∗x2∗x3∗…∗xi。

tensor([[[1, 2],
         [3, 4]],

        [[5, 6],
         [7, 8]]])
tensor([[[ 1,  2],
         [ 3,  4]],

        [[ 5, 12],
         [21, 32]]])
tensor([[[ 1,  2],
         [ 3,  8]],

        [[ 5,  6],
         [35, 48]]])
tensor([[[ 1,  2],
         [ 3, 12]],

        [[ 5, 30],
         [ 7, 56]]])

torch.cumsum

• 用法：torch.cumsum(input, dim, out=None) → Tensor
• 作用：返回输入沿指定维度的累积和。例如，如果输入是一个 N 元向量，则结果也是一个 N 元向量，第 i 个输出元素值为 yi=x1+x2+x3+…+xi。

torch.dist

• 用法：torch.dist(input, other, p=2, out=None) → Tensor
• 作用: 返回 (input - other) 的 p 范数 。

torch.mean

• 用法：torch.mean(input) → float
• 作用: 返回输入张量所有元素的均值。

torch.median

• 用法：torch.median(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor)

• 作用: 返回输入张量给定维度每行的中位数，同时返回一个包含中位数的索引的 LongTensor。

  dim 值默认为输入张量的最后一维。 输出形状与输入相同，除了给定维度上为 1.注意: 这个函数还没有在 torch.cuda.Tensor 中定义。

  

torch.mode

• 用法：torch.mode(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor)
• 作用：返回给定维 dim 上，每行的众数值。 同时返回一个 LongTensor，包含众数职的索引。dim 值默认为输入张量的最后一维。

torch.norm

• 用法：torch.norm(input, p=2) → float
• 作用：返回输入张量 input 的 p 范数。

torch.prod

• 用法：torch.prod(input) → float
• 作用：返回输入张量 input 所有元素的积。
• 用法：torch.prod(input, dim, out=None) → Tensor
• 作用：返回输入张量给定维度上每行的积。 输出形状与输入相同，除了给定维度上为 1

torch.std

• 用法：torch.std(input) → float

• 作用：返回输入张量 input 所有元素的标准差。

• 用法：torch.std(input, dim, out=None) → Tensor

• 作用：返回输入张量给定维度上每行的标准差。 输出形状与输入相同，除了给定维度上为 1。

torch.sum

• 用法：torch.sum(input) → float

• 作用：输出形状与输入相同，除了给定维度上为 1.

• 用法：torch.sum(input, dim, out=None) → Tensor

• 作用：返回输入张量给定维度上每行的和。 输出形状与输入相同，除了给定维度上为 1.

torch.var

• 用法：torch.var(input) → float
• 作用：返回输入张量所有元素的方差
• 用法：torch.var(input, dim, out=None) → Tensor
• 作用：返回输入张量给定维度上每行的方差。 输出形状与输入相同，除了给定维度上为 1。

torch.eq

• 用法：torch.eq(input, other, out=None) → Tensor
• 作用：比较元素相等性。第二个参数可为一个数或与第一个参数同类型形状的张量。

torch.equal

• 用法：torch.equal(tensor1, tensor2) → bool
• 做法：如果两个张量有相同的形状和元素值，则返回 True ，否则 False。

torch.ge

• 用法：torch.ge(input, other, out=None) → Tensor
• 作用：逐元素比较 input 和 other，即是否 input>=other。如果两个张量有相同的形状和元素值，则返回 True ，否则 False。 第二个参数可以为一个数或与第一个参数相同形状和类型的张量

torch.gt

• 用法：torch.gt(input, other, out=None) → Tensor

• 作用：逐元素比较 input 和 other ， 即是否 input>other 如果两个张量有相同的形状和元素值，则

  返回 True ，否则 False。 第二个参数可以为一个数或与第一个参数相同形状和类型的张量。

torch.kthvalue

• 用法：torch.kthvalue(input, k, dim=None, out=None) -> (Tensor, LongTensor)

• 作用：取输入张量 input 指定维上第 k 个最小值。如果不指定 dim，则默认为 input 的最后一维。

  返回一个元组 (values,indices)，其中 indices 是原始输入张量 input 中沿 dim 维的第 k 个最小值

  下标。

torch.le

• 用法：torch.le(input, other, out=None) → Tensor

• 作用：逐元素比较 input 和 other ， 即是否 input<=other 第二个参数可以为一个数或与第一个参数

  相同形状和类型的张量。

torch.lt

• 用法：torch.lt(input, other, out=None) → Tensor

• 作用：逐元素比较 input 和 other ， 即是否 input<other 第二个参数可以为一个数或与第一个参数

  相同形状和类型的张量。

torch.max

• 用法：torch.max()

• 作用：返回输入张量所有元素的最大值。

• 用法：torch.max(input, dim, max=None, max_indices=None) -> (Tensor, LongTensor)

• 作用：返回输入张量给定维度上每行的最大值，并同时返回每个最大值的位置索引。输出形状中，将 dim 维设定为 1，其它与输入形状保持一致。

torch.min

• 用法：torch.min(input) → float

• 作用：返回输入张量所有元素的最小值。

• 用法：torch.min(input, dim, min=None, min_indices=None) -> (Tensor, LongTensor)

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

  输出形状中，将 dim 维设定为 1，其它与输入形状保持一致。

torch.ne

• 用法：torch.ne(input, other, out=None) → Tensor

• 作用：逐元素比较 input 和 other ， 即是否 input!=other。 第二个参数可以为一个数或与第一个参

  数相同形状和类型的张量。

torch.sort

• 用法：torch.sort(input, dim=None, descending=False, out=None) -> (Tensor, LongTensor)
• 作用：对输入张量 input 沿着指定维按升序排序。如果不给定 dim，则默认为输入的最后一维。如果指定参数 descending 为 True，则按降序排序。

torch.topk

• 用法：torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor)
• 作用：沿给定 dim 维度返回输入张量 input 中 k 个最大值。 如果不指定 dim，则默认为 input 的最后一维。 如果为 largest 为 False ，则返回最小的 k 个值。

torch.cross

• 用法：torch.cross(input, other, dim=-1, out=None) → Tensor

• 作用：返回沿着维度 dim 上，两个张量 input 和 other 的向量积（叉积）。 input 和 other 必须有相

  同的形状，且指定的 dim 维上 size 必须为 3。如果不指定 dim，则默认为第一个尺度为 3 的维。

  具体计算叉积的公式如下：

  • c_x = a_yb_z - a_zb_y

  • c_y = a_zb_x - a_xb_z

  • c_z = a_xb_y - a_yb_x

torch.diag

• 用法：torch.diag(input, diagonal=0, out=None) → Tensor
• 作用：如果输入是一个向量(1D 张量)，则返回一个以 input 为对角线元素的 2D 方阵 。如果输入是一个矩阵(2D 张量)，则返回一个包含 input 对角线元素的 1D 张量。
  • 参数 diagonal 指定对角线:
    • diagonal = 0, 主对角线。
    • diagonal > 0, 主对角线之上。
    • diagonal < 0, 主对角线之下。

torch.histc

• 用法：torch.histc(input, bins=100, min=0, max=0, out=None) → Tensor
• 作用：计算输入张量的直方图。以 min 和 max 为 range 边界，将其均分成 bins 个直条，然后将排序好的数据划分到各个直条(bins)中。如果 min 和 max 都为 0, 则利用数据中的最大最小值作为边界。

torch.renorm

• 用法：torch.renorm(input, p, dim, maxnorm, out=None) → Tensor
• 作用：返回一个张量，包含规范化后的各个子张量，使得沿着 dim 维划分的各子张量的 p 范数小于 maxnorm。

torch.trace

• 用法：torch.trace(input) → float

• 作用：返回输入 2 维矩阵对角线元素的和(迹)。

torch.dot

torch.dot(tensor1, tensor2) → float:计算两个张量的点乘(内乘),两个张量都为 1-D 向量

torch.inverse

torch.inverse(input, out=None) → Tensor:对方阵输入 input 取逆。

torch.mm

torch.mm(mat1, mat2, out=None) → Tensor

对矩阵 mat1 和 mat2 进行相乘。 如果 mat1 是一个 n×m 张量，mat2 是一个 m×p 张

量，将会输出一个 n×p 张量 out。

参数 ：

• mat1 (Tensor) – 第一个相乘矩阵

• mat2 (Tensor) – 第二个相乘矩阵

• out (Tensor, optional) – 输出张量