可以把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]=10t.data[1][0]=20print(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 2torch.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形状，填充数值2torch.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函数直接转化为arraynp.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 torcht2 = torch.arange(1, 10).reshape(3, 3)t2t2[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]) # 需要tensortorch.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 npx = 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 npb=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各元素是否不相同，等效!=