pytorch的基本运算,是不是共享了内存,有没有维度变化

  • 可以把PyTorch简单看成是Python的深度学习第三方库,在PyTorch中定义了适用于深度学习的基本数据结构——张量,以及张量的各类计算。其实也就相当于NumPy中定义的Array和对应的科学计算方法,正是这些基本数据类型和对应的方法函数,为我们进一步在PyTorch上进行深度学习建模提供了基本对象和基本工具。因此,在正式使用PyTorch进行深度学习建模之前,我们需要熟练掌握PyTorch中张量的基本操作方法。张量作为数组的衍生概念,其本身的定义和使用方法和NumPy中的Array非常类似,甚至,在复现一些简单的神经网络算法场景中,我们可以直接使用NumPy中的Array来进行操作。

  • 张量的最基本创建方法和NumPy中创建Array的格式一致,都是创建函数(序列)的格式:张量创建函数:torch.tensor()

    • t = torch.tensor([[0,1], [2,3]]) # 通过列表创建张量
      # 通过元组创建张量
      # torch.tensor((1, 2))
      # 通过数组创建张量
      # a = np.array((1, 2))
      # t = torch.tensor(a)
      # 整数型的数组默认创建int32(整型)类型,而张量则默认创建int64(长整型)类型。
      # 创建浮点型数组时,张量默认是float32(单精度浮点型),而Array则是默认float64(双精度浮点型)。
      print(t,t.data)
      print(id(t),id(t.data))
      ## 输出 ##
      tensor([[0, 1],
              [2, 3]]) tensor([[0, 1],
              [2, 3]])
      2036011697072 2036018540848
      
    • 两者返回不同的id,但是共享同一个内存

    • t[0][0]=10
      t.data[1][0]=20
      print(t,t.data)
      print(id(t),id(t.data))
      ## 输出 ##
      tensor([[10,  1],
              [20,  3]]) tensor([[10,  1],
              [20,  3]])
      2036011697072 2036019332576
      
    • 属性 grad(导数), grad-fn(张量所在的导数函数), requires_grad(是否执行可导的判定)。调用backward计算导数,导数是累加的,如果每次单独计算,需要清空梯度 optimiter.zero_grad()

    • 属性 is_leaf, retain_grad。判定该元素在计算图中是否为叶子节点,当为叶子节点时,它的属性requires_grad为False。当requires_grad为True,但是用户构建的Tensor,表示该张量不是计算结果,而是用户构建的初始化张量。在用backward后,仅只有 leaf tensor 才会有 grad 属性。如果不是 leaf tensor 需要retain_grad 函数开启grad。

    • 属性ndim和dim函数,查看tensor的维度;属性shape和size(),tensor的形状

    • t=torch.cat([t,t],0)
      print(t.ndim,len(t),t.dim())
      print(t.shape,t.size())
      ## 输出 ##
      2 8 2
      torch.Size([8, 2]) torch.Size([8, 2])
      
    • 和数组不同,对于张量而言,数值型和布尔型张量就是最常用的两种张量类型,相关类型总结如下。

      • 数据类型 dtype
        32bit浮点数 torch.float32或torch.float
        64bit浮点数 torch.float64或torch.double
        16bit浮点数 torch.float16或torch.half
        8bit无符号整数 torch.unit8
        8bit有符号整数 torch.int8
        16bit有符号整数 torch.int16或torch.short
        32bit有符号整数 torch.int32或torch.int
        64bit有符号整数 torch.int64或torch.long
        布尔型 torch.bool
        复数型 torch.complex64
    • 创建int16整型张量; torch.tensor([1.1, 2.7], dtype = torch.int16)

    • 在PyTorch中也支持复数类型对象创建; a = torch.tensor(1 + 2j) # 1是实部、2是虚部; tensor(1.+2.j)

    • 和NumPy中array相同,当张量各元素属于不同类型时,系统会自动进行隐式转化。在使用方法进行类型转化时,方法名称则是double。(虽然torch.float和double都表示双精度浮点型。)

  • flatten拉平:将任意维度张量转化为一维张量,按行排列,拉平。注:如果将零维张量使用flatten,则会将其转化为一维张量。

  • reshape方法:任意变形;注意,reshape过程中维度的变化:reshape转化后的维度由该方法输入的参数“个数”决定。

  • 在很多数值科学计算的过程中,都会创建一些特殊取值的张量,用于模拟特殊取值的矩阵,如全0矩阵、对角矩阵等。因此,PyTorch中也存在很多创建特殊张量的函数。

    • torch.zeros([2, 3])            # 创建全是0的,两行、三列的张量(矩阵)
      torch.ones([2, 3]) # 注:由于zeros就已经确定了张量元素取值,因此该函数传入的参数实际上是决定了张量的形状
      
    • 单位矩阵

    • torch.eye(5)
      ## 
      tensor([[1., 0., 0., 0., 0.],
              [0., 1., 0., 0., 0.],
              [0., 0., 1., 0., 0.],
              [0., 0., 0., 1., 0.],
              [0., 0., 0., 0., 1.]])
      
    • 在PyTorch中,需要利用一维张量去创建对角矩阵。

    • t1 = torch.tensor([1, 2])
      torch.diag(t1) # 不能使用list直接创建对角矩阵,diag(): argument 'input' (position 1) must be Tensor, not list
      ## 
      tensor([[1, 0],
              [0, 2]])
      
    • rand:服从0-1均匀分布的张量

    • torch.randn(2, 3)
      torch.normal(2, 3, size = (2, 2))  # 均值为2,标准差为3的张量;normal:服从指定正态分布的张量
      torch.randint(1, 10, [2, 4]) # 在1-10之间随机抽取整数,组成两行四列的矩阵,randint:整数随机采样结果
      
    • arange/linspace:生成数列

    • torch.arange(5)  # 和range相同;tensor([0, 1, 2, 3, 4])
      torch.arange(1, 5, 0.5)  # 从1到5(左闭右开),每隔0.5取值一个
      torch.linspace(1, 5, 3)  # 从1到5(左右都包含),等距取三个数;tensor([1., 3., 5.])
      
    • empty:生成未初始化的指定形状矩阵

    • torch.empty(2, 3)
      ##
      tensor([[6.8664e-44, 6.8664e-44, 1.1771e-43],
              [6.7262e-44, 7.0065e-44, 8.1275e-44]])
      torch.full([2, 4], 2)   
      tensor([[2, 2, 2, 2],
              [2, 2, 2, 2]])
      
    • 还能根据指定对象的形状进行数值填充,只需要在上述函数后面加上_like即可。

    • torch.full_like(t1, 2)             # 根据t1形状,填充数值2
      torch.randint_like(t2, 1, 10) # 根据t1形状,填充数值1-10,不包括10的整数
      t1 = torch.tensor([1, 2])
      torch.randn_like(t1)  # t1是整数,而转化后将变为浮点数,此时代码将报错,"normal_kernel_cpu" not implemented for 'Long'
      
    • 张量、数组和列表是较为相似的三种类型对象,在实际操作过程中,经常会涉及三种对象的相互转化。在此前张量的创建过程中,我们看到torch.tensor函数可以直接将数组或者列表转化为张量,而我们也可以将张量转化为数组或者列表。

    • t1 = torch.tensor([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])
      t1.numpy() # array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10], dtype=int64)
      import numpy as np
      # 当然,也可以通过np.array函数直接转化为array
      np.array(t1) # array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10], dtype=int64)
      t1# tensor([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])
      # .tolist方法:张量转化为列表
      t1.tolist() # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
      
    • list函数:张量转化为列表

    • [tensor(1),
       tensor(2),
       tensor(3),
       tensor(4),
       tensor(5),
       tensor(6),
       tensor(7),
       tensor(8),
       tensor(9),
       tensor(10)] # 需要注意的是,此时转化的列表是由一个个零维张量构成的列表,而非张量的数值组成的列表。
      
    • 在很多情况下,我们需要将最终计算的结果张量转化为单独的数值进行输出,此时需要使用.item()方法来执行。

    • Python中其他对象类型一样,等号赋值操作实际上是浅拷贝,需要进行深拷贝,则需要使用clone方法

  • 张量作为有序的序列,也是具备数值索引的功能,并且基本索引方法和Python原生的列表、NumPy中的数组基本一致,当然,所有不同的是,PyTorch中还定义了一种采用函数来进行索引的方式。张量也是有序序列,我们可以根据每个元素在系统内的顺序“编号”,来找出特定的元素,也就是索引。张量索引出来的结果还是零维张量, 而不是单独的数。要转化成单独的数,需要使用item()方法。在张量的索引中,step位必须大于0

  • 二维张量的索引逻辑和一维张量的索引逻辑基本相同,二维张量可以视为两个一维张量组合而成,而在实际的索引过程中,需要用逗号进行分隔,分别表示对哪个一维张量进行索引、以及具体的一维张量的索引。对二维张量来说,基本可以视为是对矩阵的索引,并且行、列的索引遵照相同的索引规范,并用逗号进行分隔

    • import torch
      t2 = torch.arange(1, 10).reshape(3, 3)
      t2
      t2[0, 1]   # 表示索引第一行、第二个(第二列的)元素 tensor(2)
      t2[0][1]# 表示索引第一行、第二个(第二列的)元素 tensor(2)
      t2[0, ::2]# 表示索引第一行、每隔两个元素取一个 tensor([1, 3])
      t2[0, [0, 2]] # 索引结果同上
      t2[::2, ::2] # 表示每隔两行取一行、并且每一行中每隔两个元素取一个
      tensor([[1, 3],
              [7, 9]])
      
  • 在二维张量索引的基础上,三维张量拥有三个索引的维度。我们将三维张量视作矩阵组成的序列,则在实际索引过程中拥有三个维度,分别是索引矩阵、索引矩阵的行、索引矩阵的列

    • t3 = torch.arange(1, 28).reshape(3, 3, 3)
      t3
      ##
      tensor([[[ 1,  2,  3],
               [ 4,  5,  6],
               [ 7,  8,  9]],
              [[10, 11, 12],
               [13, 14, 15],
               [16, 17, 18]],
              [[19, 20, 21],
               [22, 23, 24],
               [25, 26, 27]]])
      t3[1, ::2, ::2]      # 索引第二个矩阵,行和列都是每隔两个取一个
      tensor([[10, 12],
              [16, 18]])
      t3[:: 2, :: 2, :: 2]      # 每隔两个取一个矩阵,对于每个矩阵来说,行和列都是每隔两个取一个
      tensor([[[ 1,  3],
               [ 7,  9]],
              [[19, 21],
               [25, 27]]])
      
  • 在PyTorch中,我们还可以使用index_select函数,通过指定index来对张量进行索引。在index_select函数中,第二个参数实际上代表的是索引的维度。对于t1这个一维向量来说,由于只有一个维度,因此第二个参数取值为0,就代表在第一个维度上进行索引。

    • t1 = torch.arange(10) 
      indices = torch.tensor([1, 2]) # 需要tensor
      torch.index_select(t1, 0, indices)
      ## tensor([1, 2])
      t2 = torch.arange(12).reshape(4, 3)
      ##
      tensor([[ 0,  1,  2],
              [ 3,  4,  5],
              [ 6,  7,  8],
              [ 9, 10, 11]])
      torch.index_select(t2, 0, indices)   
      ##
      tensor([[3, 4, 5],
              [6, 7, 8]])
      
  • 在正式介绍张量的切分方法之前,需要首先介绍PyTorch中的.view()方法。该方法会返回一个类似视图的结果,该结果和原张量对象共享一块数据存储空间,并且通过.view()方法,还可以改变对象结构,生成一个不同结构,但共享一个存储空间的张量。当然,共享一个存储空间,也就代表二者是“浅拷贝”的关系,修改其中一个,另一个也会同步进行更改。“视图”的作用就是节省空间,而值得注意的是,在接下来介绍的很多切分张量的方法中,返回结果都是“视图”,而不是新生成一个对象

  • chunk函数能够按照某维度,对张量进行均匀切分,并且返回结果是原张量的视图。

    • t2 = torch.arange(12).reshape(4, 3)
      tc = torch.chunk(t2, 4, dim=0)           # 在第零个维度上(按行),进行四等分
      ##  返回类型是元组
      (tensor([[0, 1, 2]]),
       tensor([[3, 4, 5]]),
       tensor([[6, 7, 8]]),
       tensor([[ 9, 10, 11]]))# chunk返回结果是一个视图,不是新生成了一个对象
       # 修改tc中的值,原张量也会对应发生变化
      
    • 当原张量不能均分时,chunk不会报错,但会返回其他均分的结果

    • torch.chunk(t2, 3, dim=0)            # 次一级均分结果
      ## 
      (tensor([[0, 1, 2],
               [3, 4, 5]]),
       tensor([[ 6,  7,  8],
               [ 9, 10, 11]]))
      
  • split既能进行均分,也能进行自定义切分。当然,需要注意的是,和chunk函数一样,split返回结果也是view

    • t2 = torch.arange(12).reshape(4, 3)
      torch.split(t2, 2, 0) # 第二个参数只输入一个数值时表示均分,第三个参数表示切分的维度
      torch.split(t2, [1, 3], 0)# 第二个参数输入一个序列时,表示按照序列数值进行切分,也就是1/3分
      ## 
      (tensor([[0, 1, 2]]),
       tensor([[ 3,  4,  5],
               [ 6,  7,  8],
               [ 9, 10, 11]]))
      torch.split(t2, [1, 1, 2], 0) 
      ##
      (tensor([[0, 1, 2]]),
       tensor([[3, 4, 5]]),
       tensor([[ 6,  7,  8],
               [ 9, 10, 11]]))
      
    • 注意,当第二个参数位输入一个序列时,序列的各数值的和必须等于对应维度下形状分量的取值。例如,上述代码中,是按照第一个维度进行切分,而t2总共有4行,因此序列的求和必须等于4,也就是1+3=4,而序列中每个分量的取值,则代表切块大小。tensor的split方法和array的split方法有很大的区别,array的split方法是根据索引进行切分。

    • import numpy as np
      x = np.array([0,1,2,3,4,5,6,7,8])
      print (np.split(x,[3,5,6,9]))
      ## [array([0, 1, 2]), array([3, 4]), array([5]), array([6, 7, 8]), array([], dtype=int32)]
      
  • 张量的合并操作类似与列表的追加元素,可以拼接、也可以堆叠。PyTorch中,可以使用cat函数实现张量的拼接。

    • a = torch.zeros(2, 3)
      b = torch.ones(2, 3)
      c = torch.full((3, 3),2)
      torch.cat([a, b])    # 按照行进行拼接,dim默认取值为0
      ##
      tensor([[0., 0., 0.],
              [0., 0., 0.],
              [1., 1., 1.],
              [1., 1., 1.]])
      torch.cat([a, b], 1)               # 按照列进行拼接
      tensor([[0., 0., 0., 1., 1., 1.],
              [0., 0., 0., 1., 1., 1.]])
      torch.cat([a, c], 1)               # 形状不匹配时将报错
      # Sizes of tensors must match except in dimension 1. Expected size 2 but got size 3 for tensor number 1 in the list.
      
    • 拼接的本质是实现元素的堆积,也就是构成a、b两个二维张量的各一维张量的堆积,最终还是构成二维向量。

  • 堆叠函数:stack;和拼接不同,堆叠不是将元素拆分重装,而是简单的将各参与堆叠的对象分装到一个更高维度的张量里。

    • torch.stack([a, b])                 # 堆叠之后,生成一个三维张量
      tensor([[[0., 0., 0.],
               [0., 0., 0.]],
              [[1., 1., 1.],
               [1., 1., 1.]]])
      torch.stack([a, b]).shape # torch.Size([2, 2, 3])
      torch.stack([a, c])               # 维度不匹配时也会报错
      # stack expects each tensor to be equal size, but got [2, 3] at entry 0 and [3, 3] at entry 1
      
  • 通过reshape方法,能够灵活调整张量的形状。而在实际操作张量进行计算时,往往需要另外进行降维和升维的操作,当我们需要除去不必要的维度时,可以使用squeeze函数,而需要手动升维时,则可采用unsqueeze函数

    • t = torch.zeros(1, 1, 3, 1) #t张量解释:一个包含一个三维的四维张量,三维张量只包含一个三行一列的二维张量。
      ##
      tensor([[[[0.],
                [0.],
                [0.]]]])
      torch.squeeze(t) # tensor([0., 0., 0.])
      torch.squeeze(t).shape # torch.Size([3])
      t1 = torch.zeros(1, 1, 3, 2, 1, 2)
      ##
      tensor([[[0., 0.],
               [0., 0.]],
              [[0., 0.],
               [0., 0.]],
              [[0., 0.],
               [0., 0.]]])
      torch.squeeze(t1).shape # torch.Size([3, 2, 2])
      
    • 简单理解,squeeze就相当于提出了shape返回结果中的1。unsqeeze函数:手动升维

    • torch.unsqueeze(t, dim = 0)              # 在第1个维度索引上升高1个维度
      torch.unsqueeze(t, dim = 2).shape         # 在第3个维度索引上升高1个维度
      torch.unsqueeze(t, dim = 4).shape          # 在第5个维度索引上升高1个维度
      
    • 注意理解维度和shape返回结果一一对应的关系,shape返回的序列有几个元素,张量就有多少维度。

  • 作为PyTorch中执行深度学习的基本数据类型,张量(Tensor)也拥有非常多的数学运算函数和方法,以及对应的一系列计算规则。在PyTorch中,能够作用与Tensor的运算,被统一称作为算子。并且相比于NumPy,PyTorch给出了更加规范的算子(运算)的分类,从而方便用户在不同场景下调用不同类型的算子(运算)。PyToch总共为Tensor设计了六大类数学运算,分别是:

    • 逐点运算(Pointwise Ops):指的是针对Tensor中每个元素执行的相同运算操作;

    • 规约运算(Reduction Ops):指的是对于某一张量进行操作得出某种总结值;

    • 比较运算(Comparison Ops):指的是对多个张量进行比较运算的相关方法;

    • 谱运算(Spectral Ops):指的是涉及信号处理傅里叶变化的操作;

    • BLAS和LAPACK运算:指的是基础线性代数程序集(Basic Linear Algeria Subprograms)和线性代数包(Linear Algeria Package)中定义的、主要用于线性代数科学计算的函数和方法;

    • 其他运算(Other Ops):其他未被归类的数学运算。

    • t1 = torch.arange(3)
      t = t1+t1 # tensor([0, 2, 4])
      a=[2,3,4]+[1,2,3] # [2, 3, 4, 1, 2, 3]
      import numpy as np
      b=np.arange(3)+np.arange(3) # array([0, 2, 4])
      
    • 广播的特性是在不同形状的张量进行计算时,一个或多个张量通过隐式转化,转化成相同形状的两个张量,从而完成计算的特性。但并非任何两个不同形状的张量都可以通过广播特性进行计算,因此,我们需要了解广播的基本规则及其核心依据。标量可以和任意形状的张量进行计算,计算过程就是标量和张量的每一个元素进行计算。

    • t1 + 1 # 1是标量,可以看成是零维 tensor([1, 2, 3])
      t1 + torch.tensor(1) #tensor([1, 2, 3])
      
    • 相同维度、不同形状的张量之间计算;两个张量的形状上有两个分量不同时,只要不同的分量仍然有一个取值为1,则仍然可以广播

    • pytorch的基本运算,是不是共享了内存,有没有维度变化_第1张图片

    • 在理解相同维度、不同形状的张量广播之后,对于不同维度的张量之间的广播其实就会容易很多,因为对于不同维度的张量,我们首先可以将低维的张量升维,然后依据相同维度不同形状的张量广播规则进行广播。而低维向量的升维也非常简单,只需将更高维度方向的形状填充为1即可

  • 逐点运算主要包括数学基本运算、数值调整运算和数据科学运算三块,相关函数如下:

    • 函数 描述
      torch.add(t1,t2 ) t1、t2两个张量逐个元素相加,等效于t1+t2
      torch.subtract(t1,t2) t1、t2两个张量逐个元素相减,等效于t1-t2
      torch.multiply(t1,t2) t1、t2两个张量逐个元素相乘,等效于t1*t2
      torch.divide(t1,t2) t1、t2两个张量逐个元素相除,等效于t1/t2
    • 函数 描述
      torch.abs(t) 返回绝对值
      torch.ceil(t) 向上取整
      torch.floor(t) 向下取整
      torch.round(t) 四舍五入取整
      torch.neg(t) 返回相反的数
    • 虽然此类型函数是数值调整函数,但并不会对原对象进行调整,而是输出新的结果。而若要对原对象本身进行修改,则可考虑使用方法_()的表达形式,对对象本身进行修改。此时方法就是上述同名函数。

    • 数学运算函数 数学公式 描述
      幂运算
      torch.exp(t) $ y_{i} = e^{x_{i}} $ 返回以e为底、t中元素为幂的张量
      torch.expm1(t) $ y_{i} = e^{x_{i}} $ - 1 对张量中的所有元素计算exp(x) - 1
      torch.exp2(t) $ y_{i} = 2^{x_{i}} $ 逐个元素计算2的t次方。
      torch.pow(t,n) $\text{out}_i = x_i ^ \text{exponent} $ 返回t的n次幂
      torch.sqrt(t) $ \text{out}{i} = \sqrt{\text{input}{i}} $ 返回t的平方根
      torch.square(t) $ \text{out}_i = x_i ^ \text{2} $ 返回输入的元素平方。
      对数运算
      torch.log10(t) $ y_{i} = \log_{10} (x_{i}) $ 返回以10为底的t的对数
      torch.log(t) $ y_{i} = \log_{e} (x_{i}) $ 返回以e为底的t的对数
      torch.log2(t) $ y_{i} = \log_{2} (x_{i}) $ 返回以2为底的t的对数
      torch.log1p(t) $ y_i = \log_{e} (x_i $ + 1) 返回一个加自然对数的输入数组。
      三角函数运算
      torch.sin(t) 三角正弦。
      torch.cos(t) 元素余弦。
      torch.tan(t) 逐元素计算切线。
    • 在数值科学计算中,expm1函数和log1p函数是一对对应的函数关系,后面再介绍log1p的时候会讲解这对函数的实际作用。开根号也就相当于0.5次幂

    • log1p是进行$ y_i = \log_{e} (x_i $ + 1)计算,而expm则是进行$ y_{i} = e^{x_{i}} $ - 1计算,二者互为逆运算。

  • 需要注意的是,虽然Python是动态编译的编程语言,但在PyTorch中,由于会涉及GPU计算,因此很多时候元素类型不会在实际执行函数计算时进行调整。此处的科学运算大多数都要求对象类型是浮点型,我们需要提前进行类型转化

  • 而log1p的实际应用场景有两个,其一是进行数据分布转化操作,另一种则是防止极小的数在进行对数运算时丢失有效位数。

    • 大多数的数理统计分析,在建模过程中,都对数据的分布有较为严格的要求,但真实的数据往往不能满足特定的分布,因此很多时候我们会先对其进行一定程度上的数值转化,而log运算就是常用的将偏态分布的数据转化为高斯分布所使用的函数,并且在此过程中,log1p的效果往往会好于log的效果

    • 另一种使用场景,当处理的数据数值非常小时,使用对数运算往往会因为精度不够而使得计算无法进行(log0没有数学意义),此时使用log1p则可很好的避免这种情况

    • m = torch.tensor(-2.6529) * 1e-20 # tensor(-2.6529e-20)
      # 转化为一个趋近于1的数再运算
      torch.log1p(m) 	# tensor(-2.6529e-20)
      # 此时直接使用log无法执行运算
      torch.log(m) # tensor(nan)
      # 无法运算就无法还原
      torch.exp(torch.log(m)) # tensor(nan)
      # 无损还原
      torch.expm1(torch.log1p(m)) # tensor(-2.6529e-20)
      
    • 在很多场景中,由于计算精度问题导致无法计算,并进一步导致数据信息损失,将会是非常致命的,典型场景如PCA主成分分析,相关问题会在算法讲解中进一步讨论

  • 在PyTorch中,sort排序函数将同时返回排序结果和对应的索引值的排列。

    • t = torch.tensor([1.0, 3.0, 2.0])
      # 升序排列
      torch.sort(t)
      ##
      torch.return_types.sort(
      values=tensor([1., 2., 3.]),
      indices=tensor([0, 2, 1]))
      # 降序排列
      torch.sort(t, descending=True)
      ##
      torch.return_types.sort(
      values=tensor([3., 2., 1.]),
      indices=tensor([1, 2, 0]))
      
  • 规约运算指的是针对某张量进行某种总结,最后得出一个具体总结值的函数。此类函数主要包含了数据科学领域内的诸多统计分析函数,如均值、极值、方差、中位数函数等等。

    • 函数 描述
      torch.mean(t) 返回张量均值
      torch.var(t) 返回张量方差
      torch.std(t) 返回张量标准差
      torch.var_mean(t) 返回张量方差和均值
      torch.std_mean(t) 返回张量标准差和均值
      torch.max(t) 返回张量最大值
      torch.argmax(t) 返回张量最大值索引
      torch.min(t) 返回张量最小值
      torch.argmin(t) 返回张量最小值索引
      torch.median(t) 返回张量中位数
      torch.sum(t) 返回张量求和结果
      torch.logsumexp(t) 返回张量各元素求和结果,适用于数据量较小的情况
      torch.prod(t) 返回张量累乘结果
      torch.dist(t1, t2) 计算两个张量的闵式距离,可使用不同范式; torch.dist(t1, t2, 2)
      torch.topk(t) 返回t中最大的k个值对应的指标; torch.topk(t, 2)
  • dist函数可计算闵式距离(闵可夫斯基距离),通过输入不同的p值,可以计算多种类型的距离,如欧式距离、街道距离等。闵可夫斯基距离公式如下: $ D(x,y) = (\sum{n}_{u=1}|x_u-y_u|{p})^{1/p}$

  • 由于规约运算是一个序列返回一个结果,因此若是针对高维张量,则可指定某维度进行计算。

    • # 创建一个3*3的二维向量
      t2 = torch.arange(12).float().reshape(3, 4)
      # 按照第一个维度求和(每次计算三个)、按列求和
      torch.sum(t2, dim = 0) # tensor([12., 15., 18., 21.])
      # 按照第二个维度求和(每次计算四个)、按行求和
      torch.sum(t2, dim = 1) # tensor([ 6., 22., 38.])
      
      
  • 比较运算是一类较为简单的运算类型,和Python原生大的布尔运算类似,常用于不同张量之间的逻辑运算,最终返回逻辑运算结果(逻辑类型张量)。基本比较运算函数如下所示:

    • 函数 描述
      torch.eq(t1, t2) 比较t1、t2各元素是否相等,等效==
      torch.equal(t1, t2) 判断两个张量是否是相同的张量
      torch.gt(t1, t2) 比较t1各元素是否大于t2各元素,等效>
      torch.lt(t1, t2) 比较t1各元素是否小于t2各元素,等效<
      torch.ge(t1, t2) 比较t1各元素是否大于或等于t2各元素,等效>=
      torch.le(t1, t2) 比较t1各元素是否小于等于t2各元素,等效<=
      torch.ne(t1, t2) 比较t1、t2各元素是否不相同,等效!=

你可能感兴趣的:(pytorch,pytorch,人工智能,python)