深度学习 pytorch的使用（张量1）
一、张量的创建
PyTorch 是一个 Python 深度学习框架，它将数据封装成张量（Tensor）来进行运算。
PyTorch 中的张量就是元素为同一种数据类型的多维矩阵。在 PyTorch 中，
张量以 "类" 的形式封装起来，对张量的一些运算、处理的方法被封装在类中。
一、创建张量的方式
1、torch.tensor 根据指定数量创建张量
2、torch.Tensor 根据形状创建张量，也可以用来创建指定数据的张量
3、torch.IntTensor、torch.DoubleTensor、torch.FloatTensor 创建指定类型的张量
二、创建线性和随机张量
1、torch.arange 和 torch.linspace 创建线性张量
2、torch.random.int_seed 和torch.random.manual_seed 随机种子设置
3、torch.randn 创建随机张量
三、创建01张量
1、torch.ones 和 torch.ones_like 创建全1张量
2、torch.zeros 和 torch.zeros_like 创建全0张量
3、torch.full 和 torch.full_like 创建全为指定值张量
四、张量元素类型装换
1、tensor.type(torch.DoubleTensor)
2、torch.double()
1、基本创建方式
import torch import numpy as np '''一、根据已有数据创建张量''' # 1、创建张量标量 data = torch.tensor(10) print(data) # tensor(10) # 2、numpy 数组，由于data为float64，下面代码也使用该类型 data = np.random.randn(2, 3) # randn(2,3) 从标准正态分布中抽取2x3的随机数 data = torch.tensor(data) # data将引用一个新的PyTorch张量。如果data原本不是张量，这段代码将把它转换为一个张量。 # 需要注意的是，如果data已经是一个张量，这段代码实际上是多余的，因为PyTorch中的张量是不可变的，所以你不能将一个张量赋值给另一个变量。 print(data) # 3、列表，下面代码使用默认元素类型 float32 data = [[10., 20., 30.], [40., 50., 60.]] data = torch.tensor(data) print(data) print('-'*50,'\n') '''二、创建指定形状的张量''' # 1、创建2行3列的张量，默认dtype为float32 data = torch.Tensor(2, 3) print(data) # 2、注意：如果传递列表，则创建包含指定元素的张量 data=torch.Tensor([10]) print(data) data = torch.Tensor([10,20]) print(data) print('-'*50,'\n') '''3、使用具体类型的张量''' # 1、创建2行3列，dtype为int32的张量 data = torch.IntTensor(2,3) print(data) # 2、注意：如果传递的元素类型不正确，则会进行类型转换 data = torch.IntTensor([2.5,3.3]) print(data) # 3、其他的类型 data= torch.ShortTensor() # int16 # data1 = torch.longTensor() # int64 data2 = torch.FloatTensor() # float32 data3 = torch.DoubleTensor() # float64
tensor(10)
tensor([[-1.0923, -0.0842, 1.5959],
[ 0.4562, 1.0242, 0.0691]], dtype=torch.float64)
tensor([[10., 20., 30.],
[40., 50., 60.]])
--------------------------------------------------
tensor([[-1.4189e-09, 1.7614e-42, 0.0000e+00],
[ 0.0000e+00, 0.0000e+00, 0.0000e+00]])
tensor([10.])
tensor([10., 20.])
--------------------------------------------------
tensor([[-1329397088, 1257, 0],
[ 0, 0, 0]], dtype=torch.int32)
tensor([2, 3], dtype=torch.int32)
2、创建线性和随机张量
（1）touch.arange 和 torch.linspace 创建线性张量
（2）torch.random.init_seed 和 torch.random.manual_seed随机种子（3）torch.randn 创建随机张量
torch.random.init_seed 用于初始化随机种子（random seed）的函数。
它通常在程序开始时被调用，以确保随机数生成器（random number generator）
的初始化状态是确定的。这对于可重复性（reproducibility）非常重要，
因为不同的随机数生成器的状态可能会导致不同的随机结果。
torch.random.manual_seed 是一个用于设置当前线程的随机种子（random seed）的函数。
当你使用多个线程或进程进行随机操作时，每个线程或进程都有自己的随机种子，
以确保每个线程或进程生成的随机数是独立的。
import torch """ 1、创建线性空间的张量""" def test01(): # 1、在指定的区间按照步长生成元素[start,end,step] data = torch.arange(0,10,2) print(data) # 2、在指定区间按照元素个数生成 data = torch.linspace(0,11,10) print(data) print('*'*50,'\n') """2、创建随机张量""" def test02(): # 1、创建随机张量 data = torch.randn(2,3) # 创建2行3列张量 print(data) # 2、随机数种子设置 print('随机数种子：',torch.random.initial_seed()) torch.random.manual_seed(100) print('随机数种子:',torch.random.initial_seed()) if __name__ == '__main__': test01() test02()
tensor([0, 2, 4, 6, 8])
tensor([ 0.0000, 1.2222, 2.4444, 3.6667, 4.8889, 6.1111, 7.3333, 8.5556,
9.7778, 11.0000])
**************************************************
tensor([[-0.5833, -0.1628, -0.9776],
[-1.3221, -0.3804, -0.8215]])
随机数种子： 716174647341300
随机数种子: 100
3、创建01张量
（1）torch.ones (生成一个全为1的指定大小和数据类型的张量)和 torch.one_like (生成一个与输入张量形状、数据类型和所在设备都相同，且所有元素都为1的新张量。)
（2）torch.zeros 和 torch.zeros_like 创建全0张量
（3）torch.full 和 torch.full_like 创建全为指定定值张量
import torch # 1.创建全0张量 def test01(): # 1.创建指定形状全0张量 data=torch.zeros(2,3) print(data) # 2.根据张量形状创建全0张量 data = torch.zeros_like(data) print(data) print('-'*50,'\n') # 2.创建全1张量 def test02(): # 1、创建全1张量 data=torch.ones(2,3) print(data) # 2、根据张量形状创建全1张量 data = torch.ones_like(data) print(data) print('-'*50,'\n') # 3、创建全为指定值的张量 def test03(): # 1、创建指定形状的张量 data=torch.full([2,3],10) # 创建一个2x3的张量，其中所有元素的值都为10 print(data) # 2.根据张量形状创建指定值的张量 data = torch.full_like(data,20) # 变量data将引用一个新的张量，该张量与原来的data形状相同，但所有元素的值都为20。 # 如果原来的data是一个可训练的参数（例如在模型中），那么这段代码将不会改变其可训练性。 print(data) if __name__ == '__main__': test01() test02() test03()
tensor([[0., 0., 0.],
[0., 0., 0.]])
tensor([[0., 0., 0.],
[0., 0., 0.]])
--------------------------------------------------
tensor([[1., 1., 1.],
[1., 1., 1.]])
tensor([[1., 1., 1.],
[1., 1., 1.]])
--------------------------------------------------
tensor([[10, 10, 10],
[10, 10, 10]])
tensor([[20, 20, 20],
[20, 20, 20]])
4、张量元素类型转换
（1）tensor.type(torch.DoubleTensor) （2）torch.double()
import torch def test(): data = torch.full([2,3],10) print(data) print(data.dtype) # torch.int64 # 将data元素类型转换为 float64类型 # 第一种方法 data = data.type(torch.DoubleTensor) print(data.dtype) # 转换为其他类型 # data = data.type(torch.ShortTensor) # data = data.type(torch.IntTensor) # data = data.type(torch.LongTensor) # data = data.type(torch.FloatTensor) # 2. 第二种方法 data = data.double() print(data.dtype) # 转换为其他类型 # data = data.short() # data = data.int() # data = data.long() # data = data.float() if __name__ == '__main__': test()
tensor([[10, 10, 10],
[10, 10, 10]])
torch.int64
torch.float64
torch.float64
二、张量数值计算
PyTorch 计算的数据都是以张量形式存在, 我们需要掌握张量各种运算. 并且, 我们可以在 CPU 中运算, 也可以在 GPU 中运算.
1、张量基本运算函数add、sub、mul、div、neg等函数,add_、sub_、mul_、div_、neg_等 inplace函数
2、张量的阿达玛积运算mul和运算符 * 的用法
3、点积运算：
1.运算符@用于进行两个矩阵的点乘运算
2.torch.mn 用于两个矩阵点运算，要求输入的矩阵为2维
3.torch.bmm 用于批量进行矩阵点乘运算，要求输入矩阵为3维
4.torch.matmul 对进行点乘运算的两矩阵形状没有限定
（1）对于输入都是二维的张量相当于mm运算
（2）对于输入都是三维的张量相当于bmm运算
（3）对数输入的shape不同的张量，对应的最后几个维度必须符合矩阵运算规则
4、将变量移动到GPU设备的方法，列如：cuda方法、直接在GPU上创建张量、使用to方法指定设备
1、张量基本运算
基本运算中，包括add、sub、mul、div、neg等函数，以及这些函数的带下划线的版本 add_、sub_、mul_、div_、neg_, 其中带下划线的版本为修改原数据。import torch def test(): # 创建一个2x3的张量，其中所有元素是从0到9的随机整数。 data = torch.randint(0, 10, [2, 3]) print(data) print('-' * 50, '\n') # tensor([[8, 3, 8], # [0, 3, 5]]) # 1.不修改原数据 new_data = data.add(10) # 等价 new_data= data + 10 print(new_data) print('-' * 50) # tensor([[18, 13, 18], # [10, 13, 15]]) # 2.直接修改原数据 # 带下划线的函数为修改原数据本身 data.add_(10) # 等价 data += 10 print(data) print('-' * 50, '\n') # tensor([[18, 18, 14], # [10, 13, 14]]) # 3.其他函数 print(data.sub(100)) # 每个元素减去100。 # tensor([[-86, -88, -85], # [-83, -89, -87]]) print(data.mul(100)) # 每个元素乘100。 # tensor([[1400, 1200, 1500], # [1700, 1100, 1300]]) print(data.div(100)) # 每个元素除以100。 # tensor([[0.1400, 0.1200, 0.1500], # [0.1700, 0.1100, 0.1300]]) print(data.pow(2)) # 每个元素进行平方运算 # data.pow(x)表示将data中的每个元素进行x次幂运算 print(data.neg()) # 每个元素取负值。 # tensor([[-14, -12, -15], # [-17, -11, -13]]) if __name__ == '__main__': test()
2、阿达玛积
阿达玛积指的是矩阵对应位置的元素相乘。import torch def test(): data1 = torch.tensor([[1, 2], [3, 4]]) data2 = torch.tensor([[5, 6], [7, 8]]) # 第一种方式 data = torch.mul(data1, data2) # [[1*5,2*6],[3*7,4*8]] print(data) print('-' * 50) # 第二种方式 data = data1 * data2 print(data) if __name__ == '__main__': test()
tensor([[ 5, 12],
[21, 32]])
--------------------------------------------------
tensor([[ 5, 12],
[21, 32]])
3、点积运算
点积运算要求第一个矩阵shape:(n,m),第二个矩阵shape：(m,p), 两个矩阵点积运算shape为：(n,p)。 1.运算符 @ 用于行进两个矩阵的点乘运算 2.torch.mm 用于批量进行矩阵点乘运算，要求输入的矩阵为2维 3.torch.bmm 用于批量进行矩阵点乘运算，要求输入的矩阵为3维 4.torch.matmul 对进行点乘运算的两矩阵形状没有限定 （1）对于输入都是二维的张量相当于mm运算 （2）对于输入都是三维的张量相当于bmm运算 （3）对数输入的shape不同的张量，对应的最后几个维度必须符合矩阵运算规则
import torch def test(): data1 = torch.tensor([[1, 2], [3, 4], [5, 6]]) data2 = torch.tensor([[5, 6], [7, 8]]) # 用于进行两个矩阵点乘运算, 要求输入的矩阵为2维 data = data1 @ data2 print(data) print('-' * 50, '\n') # 批量进行矩阵点乘运算，要求输入的矩阵为2维 data = torch.mm(data1, data2) print(data) print('-' * 50, '\n') # 对进行点乘运算的两矩阵形状没有限定 data = torch.matmul(data1, data2) print(data) print('-' * 50, '\n') # 2.torch.mm 和 torch.matmull 的区别 def test02(): # matmul 可以两个维度可以不同 # 第一个张量：（3,4,5） # 第二个张量：（6,4） # torch.mm 不可以相乘，而matmul则可以相乘 print(torch.matmul(torch.randn(3, 4, 5), torch.randn(5, 4)).shape) print(torch.matmul(torch.randn(5, 4), torch.randn(3, 4, 5)).shape) print('-' * 50, '\n') # 3.torch.mm 函数的用法 def test03(): # 批量点积运算 # 第一个维度为 batch_size # 矩阵的二三维要满足矩阵乘法规则 data1 = torch.randn(3, 4, 5) data2 = torch.randn(3, 5, 8) data = torch.bmm(data1, data2) print(data) if __name__ == '__main__': test() test02() test03()
tensor([[19, 22],
[43, 50],
[67, 78]])
--------------------------------------------------
tensor([[19, 22],
[43, 50],
[67, 78]])
--------------------------------------------------
tensor([[19, 22],
[43, 50],
[67, 78]])
--------------------------------------------------
torch.Size([3, 4, 4])
torch.Size([3, 5, 5])
--------------------------------------------------
tensor([[[-3.3189, -0.3784, -6.3479, -3.3475, -3.9737, 1.7464, -2.7687,
-0.9181],
[ 0.0657, -0.2776, 2.9985, 1.5493, 1.4645, -0.6488, -0.0580,
2.7036],
[ 3.4215, 2.5035, -2.5772, -2.2317, -0.6113, -2.5934, 1.1607,
-6.8029],
[-1.0585, -1.1550, 0.1955, -0.2993, -0.5298, 1.7574, 1.8202,
-0.3616]],
[[-2.6059, -2.8264, -0.5585, -2.1495, -2.0957, 3.0431, -0.7977,
-1.4202],
[-1.5534, -4.2426, -1.0050, 1.3967, 0.7109, -0.9517, 0.1070,
-0.2648],
[ 0.6576, 1.1402, -3.3091, -2.2596, 0.7378, 0.0913, -0.4637,
0.3685],
[ 0.5477, 7.8370, -3.4599, 0.2049, 1.9473, 3.3985, 0.6210,
2.2007]],
[[-1.0721, -3.0084, 5.7614, -2.1393, 0.1105, -3.4166, -3.6502,
0.4989],
[-3.6817, -3.9418, -4.5009, 1.9726, 2.5341, 2.1373, 0.9370,
1.8017],
[-2.0373, -1.7121, -0.4053, 1.8295, 0.6069, 1.3398, 1.8115,
1.5270],
[-0.5211, -0.8808, -2.2229, -0.6684, 1.0515, 0.3870, -0.3195,
0.1012]]])
4、指定运算设备
PyTorch 默认会将张量创建在 CPU 控制的内存中, 即: 默认的运算设备为 CPU。 我们也可以将张量创建在 GPU 上, 能够利用对于矩阵计算的优势加快模型训练。 将张量移动到 GPU 上有两种方法: 1. 使用 cuda 方法 2. 直接在 GPU上创建张量 3. 使用 to 方法指定设备
import torch """1. 使用 cuda 方法""" data = torch.tensor([10, 20, 30]) print('存储设备:', data.device) ''' # 如果安装的不是 gpu 版本的 PyTorch # 或电脑本身没有 NVIDIA 卡的计算环境 # 下面代码可能会报错 data = data.cuda() print('存储设备:', data.device) # 使用 cpu 函数将张量移动到 cpu 上 data = data.cpu() print('存储设备:', data.device) # 输出结果: # 存储设备: cpu # 存储设备: cuda:0 # 存储设备: cpu print('-'*50,'\n') """2. 直接将张量创建在 GPU 上""" data = torch.tensor([10, 20, 30], device='cuda:0') print('存储设备:', data.device) # 使用 cpu 函数将张量移动到 cpu 上 data = data.cpu() print('存储设备:', data.device) # 输出结果: # 存储设备: cuda:0 # 存储设备: cpu # 3. 使用 to 方法 data = torch.tensor([10, 20, 30]) print('存储设备:', data.device) data = data.to('cuda:0') print('存储设备:', data.device) # 输出结果: # 存储设备: cpu # 存储设备: cuda:0 # 4. 存储在不同设备的张量不能运算 data1 = torch.tensor([10, 20, 30], device='cuda:0') data2 = torch.tensor([10, 20, 30]) print(data1.device, data2.device) # RuntimeError: Expected all tensors to be on the same device, # but found at least two devices, cuda:0 and cpu! data = data1 + data2 print(data)存储设备: cpu
三、张量类型转换
numpy和Tensor互相装换的规则,以及标量张量与数值之前的转换规则
使用numpy函数可以将张量转换为ndarray数组,但是共享内存,可以使用copy函数避免共享# encoding=utf-8 # 张量转换为numpy数组 """ 使用numpy函数可以将张量转换为ndarray数组, 但是共享内存,可以使用copy函数避免共享 """ # 1. 将张量转换为 numpy 数组 import torch def test01(): data_tensor = torch.tensor([2, 3, 4]) # 使用张量对象中的 numpy 函数进行转换 data_numpy = data_tensor.numpy() print(type(data_tensor)) print(type(data_numpy)) # 注意: data_tensor 和 data_numpy 共享内存 # 修改其中的一个，另外一个也会发生改变 # data_tensor[0] = 100 data_numpy[0] = 100 print(data_tensor) print(data_numpy) # 2. 对象拷贝避免共享内存 def test02(): data_tensor = torch.tensor([2, 3, 4]) # 使用张量对象中的 numpy 函数进行转换 data_numpy = data_tensor.numpy() print(type(data_tensor)) print(type(data_numpy)) # 注意: data_tensor 和 data_numpy 共享内存 # 修改其中的一个，另外一个也会发生改变 # data_tensor[0] = 100 data_numpy[0] = 100 print(data_tensor) print(data_numpy) if __name__ == '__main__': test01() test02()
tensor([100, 3, 4])
[100 3 4]
tensor([100, 3, 4])
[100 3 4]
2、 numpy 转换为张量
使用 from_numpy 可以将 ndarray 数组转换为 Tensor，默认共享内存，使用 copy 函数避免共享。 使用 torch.tensor 可以将 ndarray 数组转换为 Tensor，默认不共享内存。
import torch import numpy as np # 1. 使用 from_numpy 函数 def test01(): data_numpy = np.array([2, 3, 4]) # 将 numpy 数组转换为张量类型 # 1. from_numpy # 2. torch.tensor(ndarray) # 浅拷贝 data_tensor = torch.from_numpy(data_numpy) # nunpy 和 tensor 共享内存 # data_numpy[0] = 100 data_tensor[0] = 100 print(data_tensor) print(data_numpy) # 2. 使用 torch.tensor 函数 def test02(): data_numpy = np.array([2, 3, 4]) data_tensor = torch.tensor(data_numpy) # nunpy 和 tensor 不共享内存 # data_numpy[0] = 100 data_tensor[0] = 100 print(data_tensor) print(data_numpy) if __name__ == '__main__': test01() test02()
tensor([100, 3, 4], dtype=torch.int32)
[100 3 4]
tensor([100, 3, 4], dtype=torch.int32)
[2 3 4]
3、标量和数字的转换
对于只有一个元素的张量，使用item方法将改制从张量中提取出来import torch # 当张量只包含一个元素时, 可以通过 item 函数提取出该值 data = torch.tensor([30,]) print(data.item()) data = torch.tensor(30) print(data.item())
30
30
四、张量的拼接
cat 函数可以将张量按照指定的维度拼接起来， stack 函数可以将张量按照指定的维度叠加起来。
1、torch.cat 函数可以将两个张量根据指定的维度拼接起来
import torch data1 = torch.randint(0,10,[3,5,4]) data2 = torch.randint(0,10,[3,5,4]) print(data1) print(data2)tensor([[[7, 2, 8, 2],
[7, 9, 9, 9],
[5, 9, 3, 5],
[1, 7, 9, 4],
[3, 9, 0, 7]],[[6, 8, 2, 6],
[6, 0, 9, 2],
[4, 0, 6, 8],
[3, 9, 9, 8],
[4, 4, 0, 1]],[[9, 6, 4, 3],
[4, 0, 4, 7],
[4, 7, 5, 5],
[2, 0, 5, 4],
[5, 3, 3, 2]]])
tensor([[[2, 9, 9, 0],
[6, 7, 5, 7],
[4, 6, 5, 4],
[7, 2, 5, 1],
[0, 5, 1, 5]],[[1, 8, 9, 5],
[8, 1, 5, 0],
[5, 9, 1, 3],
[4, 2, 1, 0],
[5, 2, 5, 2]],[[5, 2, 6, 0],
[7, 7, 0, 3],
[5, 5, 6, 7],
[3, 6, 4, 7],
[3, 8, 8, 6]]])
# 1.按0维度拼接 new_data = torch.cat([data1,data2],dim=0) # dim=0 :在第0维度（即第一个维度）上连接两个张量 print('\n按0维度拼接\n',new_data) print(new_data.shape) # 形状将为(len(data1) + len(data2), ...)
按0维度拼接
tensor([[[7, 2, 8, 2],
[7, 9, 9, 9],
[5, 9, 3, 5],
[1, 7, 9, 4],
[3, 9, 0, 7]],[[6, 8, 2, 6],
[6, 0, 9, 2],
[4, 0, 6, 8],
[3, 9, 9, 8],
[4, 4, 0, 1]],[[9, 6, 4, 3],
[4, 0, 4, 7],
[4, 7, 5, 5],
[2, 0, 5, 4],
[5, 3, 3, 2]],[[2, 9, 9, 0],
[6, 7, 5, 7],
[4, 6, 5, 4],
[7, 2, 5, 1],
[0, 5, 1, 5]],[[1, 8, 9, 5],
[8, 1, 5, 0],
[5, 9, 1, 3],
[4, 2, 1, 0],
[5, 2, 5, 2]],[[5, 2, 6, 0],
[7, 7, 0, 3],
[5, 5, 6, 7],
[3, 6, 4, 7],
[3, 8, 8, 6]]])
torch.Size([6, 5, 4])
# 按1维度拼接 new_data = torch.cat([data1, data2], dim=1) print('\n按1维度拼接\n',new_data) print(new_data.shape) # 按2维度拼接 new_data = torch.cat([data1, data2], dim=2) print('\n按2维度拼接\n',new_data) print(new_data.shape)按1维度拼接
tensor([[[7, 2, 8, 2],
[7, 9, 9, 9],
[5, 9, 3, 5],
[1, 7, 9, 4],
[3, 9, 0, 7],
[2, 9, 9, 0],
[6, 7, 5, 7],
[4, 6, 5, 4],
[7, 2, 5, 1],
[0, 5, 1, 5]],[[6, 8, 2, 6],
[6, 0, 9, 2],
[4, 0, 6, 8],
[3, 9, 9, 8],
[4, 4, 0, 1],
[1, 8, 9, 5],
[8, 1, 5, 0],
[5, 9, 1, 3],
[4, 2, 1, 0],
[5, 2, 5, 2]],[[9, 6, 4, 3],
[4, 0, 4, 7],
[4, 7, 5, 5],
[2, 0, 5, 4],
[5, 3, 3, 2],
[5, 2, 6, 0],
[7, 7, 0, 3],
[5, 5, 6, 7],
[3, 6, 4, 7],
[3, 8, 8, 6]]])
torch.Size([3, 10, 4])按2维度拼接
tensor([[[7, 2, 8, 2, 2, 9, 9, 0],
[7, 9, 9, 9, 6, 7, 5, 7],
[5, 9, 3, 5, 4, 6, 5, 4],
[1, 7, 9, 4, 7, 2, 5, 1],
[3, 9, 0, 7, 0, 5, 1, 5]],[[6, 8, 2, 6, 1, 8, 9, 5],
[6, 0, 9, 2, 8, 1, 5, 0],
[4, 0, 6, 8, 5, 9, 1, 3],
[3, 9, 9, 8, 4, 2, 1, 0],
[4, 4, 0, 1, 5, 2, 5, 2]],[[9, 6, 4, 3, 5, 2, 6, 0],
[4, 0, 4, 7, 7, 7, 0, 3],
[4, 7, 5, 5, 5, 5, 6, 7],
[2, 0, 5, 4, 3, 6, 4, 7],
[5, 3, 3, 2, 3, 8, 8, 6]]])
torch.Size([3, 5, 8])
2、torch.stack 函数可以将两个张量根据指定的维度叠加起来
import torch def test(): data1 = torch.randint(0,10,[2,3]) data2 = torch.randint(0,10,[2,3]) print(data1) print(data2) new_data0 = torch.stack([data1,data2],dim=0) print('\nnew_data0:\n',new_data0) print(new_data0.shape) new_data1 = torch.stack([data1,data2],dim=1) print('\nnew_data1:\n',new_data1) print(new_data1.shape) new_data2 = torch.stack([data1,data2],dim=2) print('\nnew_data2:\n',new_data2) print(new_data2.shape) if __name__ == '__main__': test()
tensor([[1, 3, 3],
[6, 5, 3]])
tensor([[2, 0, 9],
[8, 0, 3]])
new_data0:
tensor([[[1, 3, 3],
[6, 5, 3]],
[[2, 0, 9],
[8, 0, 3]]])
torch.Size([2, 2, 3])
new_data1:
tensor([[[1, 3, 3],
[2, 0, 9]],
[[6, 5, 3],
[8, 0, 3]]])
torch.Size([2, 2, 3])
new_data2:
tensor([[[1, 2],
[3, 0],
[3, 9]],
[[6, 8],
[5, 0],
[3, 3]]])
torch.Size([2, 3, 2])
下一章深度学习 pytorch的使用（张量2）