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,则仍然可以广播

    • 在这里插入图片描述

    • 在理解相同维度、不同形状的张量广播之后,对于不同维度的张量之间的广播其实就会容易很多,因为对于不同维度的张量,我们首先可以将低维的张量升维,然后依据相同维度不同形状的张量广播规则进行广播。而低维向量的升维也非常简单,只需将更高维度方向的形状填充为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各元素是否不相同,等效!=

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/103091.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

AWS SAP-C02教程2--存储资源

存储资源在架构设计中是一个少不了的环节,而在AWS中有不同类型的存储资源,对应会有不同用途不同价格,SAP考试中考察各种存储是少不了,以下是涉及到的存储 目录 1 非结构化存储1.1 EBS(块存储)1.1.1 基本限制1.1.2 类型1.1.3 RAID 配置选项1.1.4 Snapshot1.2 Local Insta…

python opencv 深度学习 指纹识别算法实现 计算机竞赛

1 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; python opencv 深度学习 指纹识别算法实现 &#x1f947;学长这里给一个题目综合评分(每项满分5分) 难度系数&#xff1a;3分工作量&#xff1a;4分创新点&#xff1a;4分 该项目较为新颖…

ABAP 采购组 条目 Z001 不存在T161内-请检查输入

背景&#xff1a;在ALV报表更改PR采购组 做法&#xff1a;ALV报表取出PR相关数据&#xff0c;直接将采购组列设置为可编辑&#xff0c;然后设置按钮更改逻辑。 操作&#xff1a;将采购组值更新&#xff08;从原来500改为600&#xff09;&#xff0c;然后点更改功能按钮&#xf…

Apache Ranger:(一)安装部署

1.Ranger简介 Apache Ranger提供一个集中式安全管理框架, 并解决授权和审计。它可以对Hadoop生态的组件如HDFS、Yarn、Hive、Hbase等进行细粒度的数据访问控制。通过操作Ranger控制台,管理员可以轻松的通过配置策略来控制用户访问权限。 说白了就是管理大多数框架的授权问题。 …

JVM 入门

文章目录 JVMJVM 垮平台执行其他语言的代码JDK、JRE、JVM各种 Java 虚拟机查看我们本地的虚拟机版本HotSpot 的整体架构 JVM JVM &#xff08;Java Virtual Machine&#xff09;&#xff0c;Java 虚拟机&#xff0c;我们的 Java 代码需编译为 .class 字节码文件&#xff0c;经…

Excel 快速分析

文章目录 格式化图表汇总计数 表超级表 迷你图 快捷键: Ctrl Q 先选中数据, 再按快捷键或快速分析按钮. 格式化 查看规则: 前提是先在表中添加某种规则, 再全选该表, 这样在查看规则时才会显示出这个规则. 图表 汇总 计数 表 超级表 迷你图

经典面试题第十更---instanceof与typeof

前言&#xff1a; &#x1f921; 作者简介&#xff1a;我是Morning&#xff0c;计算机的打工人&#xff0c;想要翻身做主人 &#x1f648; &#x1f648; &#x1f648; &#x1f3e0; 个人主页&#xff1a; Morning的主页 &#x1f4d5;系列专栏&#xff1a; 前端…

Android Studio新建项目教程

Android Studio新建项目教程 一、创建新项目 二、选择空白页项目类型 配置然后finish 等待项目完成初试化 等待初始化结束&#xff0c;创建完成 三、运行创建的APP

JS+Jquery用法

1. 当存在多个select时&#xff0c;想要获取每一个select的选中的值(使用变量赋值的方法). var Metric "";$(#Metric).change(function () {Metric $(this).children("option:selected").val();console.log("Metric:" Metric);}); 2. 在页面…

VScode远程root权限调试

尝试诸多办法无法解决的情况下&#xff0c;允许远程登陆用户直接以root身份登录 编辑sshd_config文件 sudo vim /etc/ssh/sshd_config 激活配置 注释掉PermitRootLogin without-password&#xff0c;即#PermitRootLogin without-password 增加一行&#xff1a;PermitRootLo…

Linux 文件系统

目录 磁盘文件管理 认识磁盘 抽象认识磁盘 磁盘划分 inode vs 文件名 软硬链接 磁盘文件管理 前面我们说了关于 Linux 文件系统中 “已打开的文件” &#xff0c;但是在系统中可不光只有已打开的文件&#xff0c;实际上&#xff0c;系统中还存在很多没有打开的文件。 既…

Redis cluster 集群

redis集群redis集群是一个提供在多个redis节点间共享数据的程序集&#xff0c;redis集群可以支持多个master Redis集群支持多个master,每个master又可以挂载多个slave 读写分离、支持数据的高可用、支持海量数据的读写存储操作由于Cluster自动Sentinel的故障转移机制&#xff…

mac上安装mysql

下载地址&#xff1a;https://downloads.mysql.com/archives/community/ 可以选择dmg安装包&#xff0c;也可以选择tar包。 1、dmg安装包&#xff1a; 1.1&#xff09;安装&#xff1a; 类似windows的exe&#xff0c;直接next即可。 注意&#xff1a;安装完成之后会弹出一个…

C# 超详细的WebService创建、发布与调用(VS2022)

本文章是以vs2022来创建的&#xff0c;对内容进行了补充和丰富。如果想看2019的&#xff0c;可以参考。Visual Studio 2019创建 WebServiceCSDN 1.编写接口 打开VS2022,新建项目&#xff0c;这里我选择的是 “ASP.NET Web应用程序(.NET Framework)”。 在这里有一个注意点&a…

机器学习网络模型绘图模板

一 前言 本期为读者推荐一款名为ML Visuals的机器学习画图PPT模板&#xff0c;ML Visuals 专为解决神经网络画图问题设计&#xff0c;通过提供免费的专业的、科学的和充分的视觉和图形来帮助机器学习社区改善科学传播。目前&#xff0c;ML Visuals 包含了超过100多个的自定义图…

【NLTK系列01】:nltk库介绍

一、说明 NLTK是个啥&#xff1f;它是个复杂的应用库&#xff0c;可以实现基本预料库操作&#xff0c;比如&#xff0c;、将文章分词成独立token&#xff0c;等操作。从词统计、标记化、词干提取、词性标记&#xff0c;停用词收集&#xff0c;包括语义索引和依赖关系解析等。 …

LeetCode【128】最长连续序列

题目&#xff1a; 分析&#xff1a; 1、最长连续序列的长度为 y-x1&#xff0c;如1-4&#xff1a;4-11 4 2、不要被这里的On误导&#xff0c;不敢使用双层循环 3、只要找到最小的数值&#xff0c;并由此开始计算&#xff0c;不产生重复计算&#xff0c;则为On 代码&#xf…

Docker简单案例

我们安装完Docker之后就可以练习了. 镜像 案例1-拉取、查看镜像 1&#xff09;首先去镜像仓库搜索nginx镜像&#xff0c;比如 : Docker Hub Container Image Library | App Containerization 搜索我们想要拉取的镜像 , 例如: nginx 复制命令&#xff1a; docker pull nginx …

找单身狗2

一个数组中只有两个数字是出现一次&#xff0c;其他所有数字都出现了两次。编写一个函数找出这两个只出现一次的数字。 例如&#xff1a;有数组的元素是&#xff1a;1,2,3,4,5,1,2,3,4,6&#xff0c;只有5和6只出现1次&#xff0c;要找出5和6。 这里我们不妨回忆一下之前找单身…

centos7下安装elasticsearch7.8.1并配置远程连接

1、下载安装包 sudo wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-7.8.1-linux-x86_64.tar.gz 2、解压 sudo tar -zxvf elasticsearch-7.8.1-linux-x86_64.tar.gz 3、添加用户并设置密码 sudo useradd es sudo passwd es # 设置密码 Lida15…