深度学习 pytorch的使用(张量1)

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

<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模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包