深度学习 pytorch的使用（张量1）-Toy模板网

这篇具有很好参考价值的文章主要介绍了深度学习 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]])
--------------------------------------------------

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()

<class 'torch.Tensor'>
<class 'numpy.ndarray'>
tensor([100, 3, 4])
[100 3 4]
<class 'torch.Tensor'>
<class 'numpy.ndarray'>
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）文章来源地址https://www.toymoban.com/news/detail-815622.html

到了这里，关于深度学习 pytorch的使用（张量1）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！