首页 > 其他分享 >基于PyTorch深度学习实战入门系列-PyTorch基础全

基于PyTorch深度学习实战入门系列-PyTorch基础全

时间:2024-03-24 20:32:33浏览次数:17  
标签:实战 tensor 入门 torch 张量 PyTorch print tensor2 tensor1

Torch的基本使用

  1. 判断GPU是否可用

    torch.cuda.is_available()
    
  2. 张量

    Torch 定义了 10 种张量类型,包括 CPU 和 GPU 形式,如下表所示:

    数据类型dtypeCPU张量GPU张量
    32位浮点数torch.float32、torch.floattorch.FloatTensortorch.cuda.FloatTensor
    64位浮点数torch.float64、torch.doubletorch. DoubleTensortorch.cuda.DoubleTensor
    16位浮点数torch.float16、torch.halftorch.HalfTensortorch.cuda.HalfTensor
    16位浮点数torch.bfloat16torch.BFloat16Tensortorch.cuda.BFloat16Tensor
    32位复数torch.complex32、torch.chalf//
    64位复数torch.complex64、torch.cfloattorch.complex/
    128位复数torch.complex128、torch.cdouble//
    8位整型(无符号)torch.uint8torch.ByteTensortorch.cuda.ByteTensor
    8位整型(有符号)torch.int8torch.CharTensortorch.cuda.CharTensor
    16位整型(有符号)torch.int16、torch.shorttorch.ShortTensortorch.cuda.ShortTensor
    32位整型(有符号)torch.int32、torch.inttorch.IntTensortorch.cuda.IntTensor
    64位整型(有符号)torch.int64、torch.longtorch.LongTensortorch.cuda.LongTensor
    布尔torch.booltorch.BoolTensortorch.cuda.BoolTensor
    量化的8位整型(无符号)torch.quint8torch.ByteTensor/
    量化8位整型(有符号)torch.qint8torch.CharTensor/
    量化的32位整型(有符号)torch.qint32torch.IntTensor/
    量化4位整型(无符号)torch.quint4x2torch.ByteTensor/
    torch.tensor()和torch.Tensor()的区别:

    torch.tensor 是一个工厂函数,它接收多种类型的输入,包括原始数据(如列表、元组或张量)、数据类型和计算设备的指定以及是否需要开启自动求导功能的指示。它的返回值总是新创建的一个张量,即使输入本身就是张量。

    torch.Tensor 是一个类,它用于创建空的张量。它的参数可以是张量的形状(shape)或者是另一个张量。该类的实例化不会改变输入张量的内容,而是返回一个新的张量对象。

    虽然 torch.tensor 和 torch.Tensor 在功能上是相似的,都用于创建PyTorch中的张量,但 torch.Tensor 作为类,提供了更多灵活性,并且在使用时可以避免一些复杂的类型推断问题。

    torch中默认的数据类型为32位浮点型
    tensor1 = torch.Tensor(5)
    tensor1.dtype
    

    输出:

    torch.float32
    
    更改默认数据类型:
    torch.set_default_tensor_type(torch.FloatTensor)
    
    获取默认数据类型:
    torch.get_default_dtype()
    

    输出:

    torch.float32
    
    初始化张量
    通过传入List初始化:
    tensor2 = torch.Tensor([[1, 2], [3, 4]])
    tensor2
    

    输出:

    tensor([[1., 2.],
            [3., 4.]])
    
    通过传入数组初始化:
    array = np.array([[5, 6], [7, 8]])
    tensor3 = torch.Tensor(array)
    tensor3
    

    输出:

    tensor([[5., 6.],
            [7., 8.]])
    
    按类型初始化:
    # 32位浮点数
    tensor1 = torch.FloatTensor([1])
    # 64位浮点数
    tensor2 = torch.DoubleTensor([2])
    # 16位浮点数
    tensor3 = torch.HalfTensor([3])
    # 32位整型
    tensor4 = torch.IntTensor([4])
    # 64位整型
    tensor5 = torch.LongTensor([5])
    # 布尔类型
    tensor6 = torch.BoolTensor([0, 1, 0, 1])
    
    print(f"tensor1:{tensor1}")
    print(f"tensor2:{tensor2}")
    print(f"tensor3:{tensor3}")
    print(f"tensor4:{tensor4}")
    print(f"tensor5:{tensor5}")
    print(f"tensor6:{tensor6}")
    

    输出:

    tensor1:tensor([1.])
    tensor2:tensor([2.], dtype=torch.float64)
    tensor3:tensor([3.], dtype=torch.float16)
    tensor4:tensor([4], dtype=torch.int32)
    tensor5:tensor([5])
    tensor6:tensor([False,  True, False,  True])
    
    构造全 0 全 1 张量并初始化类型:
    # 构造全0张量 并设置类型为torch.float32
    zerotensor = torch.zeros([3, 6], dtype=torch.float32)
    # 构造全1张量 并设置类型为torch.int32
    onetensor = torch.ones([3, 6], dtype=torch.int32)
    
    print(zerotensor)
    print(onetensor)
    

    输出:

    tensor([[0., 0., 0., 0., 0., 0.],
            [0., 0., 0., 0., 0., 0.],
            [0., 0., 0., 0., 0., 0.]])
    tensor([[1, 1, 1, 1, 1, 1],
            [1, 1, 1, 1, 1, 1],
            [1, 1, 1, 1, 1, 1]], dtype=torch.int32)
    
    创建相同大小的全 1 或全 0 张量
    # 创建相同大小全1张量
    tensor1 = torch.Tensor([[1, 2, 3], [4, 5, 6]])
    likeone = torch.ones_like(tensor1)
    # 创建相同大小全0张量
    likezero = torch.zeros_like(tensor1)
    print(tensor1)
    print(likeone)
    print(likezero)
    

    输出:

    tensor([[1., 2., 3.],
            [4., 5., 6.]])
    tensor([[1., 1., 1.],
            [1., 1., 1.]])
    tensor([[0., 0., 0.],
            [0., 0., 0.]])
    
    生成同纬度随机张量
    # 生成同纬度随机张量
    rantensor = torch.rand_like(tensor1)
    print(rantensor)
    

    输出:

    tensor([[0.1340, 0.2402, 0.7677],
            [0.6867, 0.7134, 0.0426]])
    
    使用new_full填充张量
    newfull = tensor1.new_full((3, 3), fill_value=8)
    print(newfull)
    

    输出:

    tensor([[8., 8., 8.],
            [8., 8., 8.],
            [8., 8., 8.]])
    
    使用new_zeros构建全 0 张量
    # 使用new_zeros构建全0张量
    newzeros = tensor1.new_zeros((3, 3))
    print(newzeros)
    

    输出:

    tensor([[0., 0., 0.],
            [0., 0., 0.],
            [0., 0., 0.]])
    
    使用new_ones构建全 1 张量
    # 使用new_ones构建全0张量
    newones = tensor1.new_ones((3, 3))
    print(newones)
    

    输出:

    tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]])
    
    使用new_empty构建全 空 张量
    # 使用new_empty构建全0张量
    newempty = tensor1.new_empty((3, 3))
    print(newempty)
    

    输出:

    tensor([[8., 8., 8.],
            [8., 8., 8.],
            [8., 8., 8.]])
    
    张量的操作:
    张量的类型转换(两种方式):
    tensor1 = torch.Tensor([1, 2, 3])
    print(tensor1.dtype)
    # 转换成整型的第一种方法
    print(tensor1.int().dtype)
    # 转换成整形的第二种方法
    print(tensor1.to(dtype=torch.int32).dtyp
    

    输出:

    torch.float32
    torch.int32
    torch.int32
    
    获取张量的值(只能获取一个数):
    tensor1[0].item()
    
    张量转换成数组:
    array = tensor1.numpy()
    
    数组转换为张量:
    array = np.ones((3, 3))
    tensor1 = torch.as_tensor(array)
    tensor2 = torch.from_numpy(array)
    print(tensor1)
    print(tensor2)
    

    输出:

    tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]], dtype=torch.float64)
    tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]], dtype=torch.float64)
    
    通过指定均值和标准差生成随机数:
    # 通过指定均值和标准差生成随机数
    torch.manual_seed(456)
    # 均值为0  标准差为1
    a = torch.normal(mean=0, std=torch.tensor(1.0))
    print(a)
    
    生成0-1上均匀分布的张量:
    # 生成0-1上均匀分布的张量
    tensor1 = torch.rand(2, 3)
    print(tensor1)
    
    生成相同尺寸的随机数张量:
    # 生成相同尺寸的随机数张量
    tensor1 = torch.rand_like(tensor2)
    print(tensor1)
    
    生成0-50随机排列的张量:
    # 生成0-50随机排列的张量
    tensor1 = torch.randperm(50)
    print(tensor1)
    

    输出:

    tensor([42, 16, 43, 39, 28,  4,  5, 45, 48, 25, 34,  1, 21, 33, 13, 29, 15, 12,
            40,  6, 10, 22, 17,  2, 26, 14, 47, 36,  0, 38, 11, 18, 37, 31,  7, 27,
             3, 41,  9, 49, 23, 30,  8, 19, 44, 24, 35, 20, 32, 46])
    
    张量数据CPU与GPU的转换:
    print(tensor1.cpu())
    print(tensor1.cuda())
    

    输出:

    tensor([1., 2., 3.])
    tensor([1., 2., 3.], device='cuda:0')
    
    判断Tensor是否在CUDA上(True在、False不在):
    # 判断tensor是否在CUDA上
    print(tensor1.is_cuda)
    
    输出Tensor所在位置:
    print(tensor1.device)
    
    生成指定范围指定步长的张量:
    # 生成指定范围指定步长的张量
    tensor1 = torch.arange(start=0, end=100, step=5)
    print(tensor1)
    

    输出:

    tensor([ 0,  5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85,
            90, 95])
    
    使用linspace生成固定数量等间隔的张量:
    # 使用linspace生成固定数量等间隔的张量
    tensor1 = torch.linspace(start=0, end=100, steps=10)
    print(tensor1)
    

    输出:

    tensor([  0.0000,  11.1111,  22.2222,  33.3333,  44.4444,  55.5556,  66.6667,
             77.7778,  88.8889, 100.0000])
    
    生成以对数为间隔的张量:
    # 生成以对数为间隔的张量
    tensor1 = torch.logspace(start=0, end=1, steps=10)
    print(tensor1)
    
    获取张量的维度:

    注:shape 是一个属性,直接访问,也返回一个元组(tuple),包含了 PyTorch 张量 x 的各个维度的尺寸信息。

    ​ size() 是一个函数,调用时不需要加括号,返回一个元组(tuple),包含了 PyTorch 张量 x 的各个维度的尺寸信息。

    print(tensor1.shape)
    print(tensor1.size())
    

    输出:

    torch.Size([3])
    torch.Size([3])
    
    计算张量中元素个数
    tensor1.numel()
    
    使用requires_grad是否需要计算梯度(只有浮点数可以计算梯度)
    tensor1 = torch.tensor((4, 5, 6), dtype=torch.float32, requires_grad=True)
    print(tensor1)
    

    输出:

    tensor([4., 5., 6.], requires_grad=True)
    
    创建具有特定大小的张量
    tensor1 = torch.Tensor(2, 3)
    print(tensor1)
    

    输出:

    tensor([[0.0000, 1.8750, 0.0000],
            [2.0000, 0.0000, 2.1250]])
    
    改变张量形状(reshape):
    # 改变张量形状
    tensor1 = torch.arange(15)
    tensor2 = tensor1.reshape(5, 3)
    tensor3 = torch.reshape(input=tensor1, shape=(3, 5))
    print(tensor1)
    print(tensor2)
    print(tensor3)
    

    输出:

    tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])
    tensor([[ 0,  1,  2],
            [ 3,  4,  5],
            [ 6,  7,  8],
            [ 9, 10, 11],
            [12, 13, 14]])
    tensor([[ 0,  1,  2,  3,  4],
            [ 5,  6,  7,  8,  9],
            [10, 11, 12, 13, 14]])
    
    改变张量形状(resize):
    tensor2 = tensor1.resize(3, 5)
    print(tensor2)
    

    输出:

    tensor([[ 0,  1,  2,  3,  4],
            [ 5,  6,  7,  8,  9],
            [10, 11, 12, 13, 14]])
    
    改变张量形状(resize_):
    tensor1.resize_(3, 5)
    print(tensor1)
    

    输出:

    tensor([[ 0,  1,  2,  3,  4],
            [ 5,  6,  7,  8,  9],
            [10, 11, 12, 13, 14]])
    
    将张量B形状设置和A一样:
    # 将张量B形状设置和A一样
    tensor1 = torch.Tensor([[9, 8, 7], [4, 5, 6]])
    tensor2 = torch.randperm(6)
    print(tensor2)
    tensor2 = tensor2.resize_as(tensor1)
    print(tensor2)
    

    输出:

    tensor([4, 1, 2, 5, 0, 3])
    tensor([[4, 1, 2],
            [5, 0, 3]])
    
    升维:
    # 升维
    print(tensor1.shape)
    tensor1 = torch.unsqueeze(tensor1,dim=0)
    print(tensor1.shape)
    

    输出:

    torch.Size([2, 3])
    torch.Size([1, 2, 3])
    
    降维:
    # 降维
    print(tensor1.shape)
    tensor1 = torch.squeeze(tensor1, dim=0)
    print(tensor1.shape)
    

    输出:

    torch.Size([1, 2, 3])
    torch.Size([2, 3])
    
    使用expand进行张量扩展:
    # 使用expand进行张量扩展
    tensor1 = torch.arange(5)
    tensor2 = tensor1.expand(3, -1)
    print(tensor2)
    

    输出:

    tensor([[0, 1, 2, 3, 4],
            [0, 1, 2, 3, 4],
            [0, 1, 2, 3, 4]])
    
    使用expand_as进行张量扩展:
    tensor3 = torch.arange(10).resize(2, 5)
    tensor2 = tensor1.expand_as(tensor3)
    print(tensor2)
    

    输出:

    tensor([[0, 1, 2, 3, 4],
            [0, 1, 2, 3, 4]])
    
    根据条件筛选:
    # 根据条件筛选
    tensor1 = torch.randperm(12).reshape(3, 4)
    tensor2 = -tensor1
    print(tensor1)
    print(tensor2)
    tensor3 = torch.where(tensor1 > 6, tensor1, tensor2)
    print(tensor3)
    

    输出:

    tensor([[ 6,  4,  8,  2],
            [ 3,  0, 11, 10],
            [ 9,  1,  7,  5]])
    tensor([[ -6,  -4,  -8,  -2],
            [ -3,   0, -11, -10],
            [ -9,  -1,  -7,  -5]])
    tensor([[-6, -4,  8, -2],
            [-3,  0, 11, 10],
            [ 9, -1,  7, -5]])
    
    获取矩阵张量下三角:
    # 获取矩阵下三角
    tensor1 = torch.randperm(16).reshape(4, 4)
    print(torch.tril(tensor1, diagonal=0))
    

    输出:

    tensor([[15,  0,  0,  0],
            [14,  3,  0,  0],
            [12,  0,  1,  0],
            [11, 13,  8,  6]])
    
    获取矩阵张量上三角:
    # 获取矩阵上三角
    tensor1 = torch.randperm(16).reshape(4, 4)
    print(torch.triu(tensor1, diagonal=0))
    

    输出:

    tensor([[11, 13,  3,  7],
            [ 0,  4,  6, 14],
            [ 0,  0,  8,  5],
            [ 0,  0,  0,  2]])
    
    生成对角阵:
    # 生成对角阵
    tensor1 = torch.diag(torch.Tensor([1, 2, 3]))
    print(tensor1)
    

    输出:

    tensor([[1., 0., 0.],
            [0., 2., 0.],
            [0., 0., 3.]])
    
    张量的拼接和拆分
    拼接张量(cat):
    tensor1 = torch.arange(12).reshape(3, 4)
    tensor2 = torch.linspace(0, 50, 12).reshape(3, 4)
    # 0维度拼接张量  列上拼接
    tensor3 = torch.cat((tensor1, tensor2), dim=0)
    # 1维度拼接张量  行上拼接
    tensor4 = torch.cat((tensor1, tensor2), dim=1)
    print(tensor3)
    print(tensor4)
    

    输出:

    tensor([[ 0.0000,  1.0000,  2.0000,  3.0000],
            [ 4.0000,  5.0000,  6.0000,  7.0000],
            [ 8.0000,  9.0000, 10.0000, 11.0000],
            [ 0.0000,  4.5455,  9.0909, 13.6364],
            [18.1818, 22.7273, 27.2727, 31.8182],
            [36.3636, 40.9091, 45.4545, 50.0000]])
    tensor([[ 0.0000,  1.0000,  2.0000,  3.0000,  0.0000,  4.5455,  9.0909, 13.6364],
            [ 4.0000,  5.0000,  6.0000,  7.0000, 18.1818, 22.7273, 27.2727, 31.8182],
            [ 8.0000,  9.0000, 10.0000, 11.0000, 36.3636, 40.9091, 45.4545, 50.0000]])
    
    沿新的维度拼接张量(stack):
    tensor1 = torch.arange(12).reshape(3, 4)
    tensor2 = torch.linspace(0, 50, 12).reshape(3, 4)
    # 0维度拼接张量  列上拼接
    tensor3 = torch.stack((tensor1, tensor2), dim=0)
    # 1维度拼接张量  行上拼接
    tensor4 = torch.stack((tensor1, tensor2), dim=1)
    print(tensor3)
    print(tensor4)
    

    输出:

    tensor([[[ 0.0000,  1.0000,  2.0000,  3.0000],
             [ 4.0000,  5.0000,  6.0000,  7.0000],
             [ 8.0000,  9.0000, 10.0000, 11.0000]],
    
            [[ 0.0000,  4.5455,  9.0909, 13.6364],
             [18.1818, 22.7273, 27.2727, 31.8182],
             [36.3636, 40.9091, 45.4545, 50.0000]]])
    tensor([[[ 0.0000,  1.0000,  2.0000,  3.0000],
             [ 0.0000,  4.5455,  9.0909, 13.6364]],
    
            [[ 4.0000,  5.0000,  6.0000,  7.0000],
             [18.1818, 22.7273, 27.2727, 31.8182]],
    
            [[ 8.0000,  9.0000, 10.0000, 11.0000],
             [36.3636, 40.9091, 45.4545, 50.0000]]])
    
    分割张量(chunk):
    tensor1 = torch.arange(12).reshape(2, 6)
    tensor2 = torch.chunk(tensor1, 2, dim=0)
    tensor3 = torch.chunk(tensor1, 6, dim=1)
    print(tensor1)
    print(tensor2)
    print(tensor3)
    

    输出:

    tensor([[ 0,  1,  2,  3,  4,  5],
            [ 6,  7,  8,  9, 10, 11]])
    (tensor([[0, 1, 2, 3, 4, 5]]), tensor([[ 6,  7,  8,  9, 10, 11]]))
    (tensor([[0],
            [6]]), tensor([[1],
            [7]]), tensor([[2],
            [8]]), tensor([[3],
            [9]]), tensor([[ 4],
            [10]]), tensor([[ 5],
            [11]]))
    
    分割张量指定每个块大小(spilt):
    a, b, c = torch.split(tensor1, [1, 2, 3], dim=1)
    print(a)
    print(b)
    print(c)
    

    输出:

    tensor([[0],
            [6]])
    tensor([[1, 2],
            [7, 8]])
    tensor([[ 3,  4,  5],
            [ 9, 10, 11]])
    

标签:实战,tensor,入门,torch,张量,PyTorch,print,tensor2,tensor1
From: https://blog.csdn.net/weixin_44144773/article/details/136994219

相关文章

  • 从零开始的 dbt 入门教程 (dbt cloud 自动化篇)
    一、引在前面的几篇文章中,我们从dbtcore聊到了dbt项目工程化,我相信前几篇文章足够各位数据开发师从零快速入门dbt开发,那么到现在我们更迫切需要解决的是如何让数据更新做到定时化,毕竟作为开发我们肯定没有经历每天定点去手动运行dbt命令,那么今天我们将带领大家快速上手......
  • Python实战:信号处理:signal模块
    1.引言在Unix-like操作系统中,信号是一种异步通知机制,用于在特定事件发生时通知进程。信号可以由内核、其他进程或进程自身发送。Python的signal模块提供了对Unix信号处理的接口,允许Python程序捕获和处理信号。掌握信号处理对于编写健壮、响应性好的Python程序至关重要。2......
  • Python实战:异步I/O:asyncio事件循环
    1.引言在Python中,异步I/O是一种非阻塞的I/O操作方式。与传统的同步I/O操作不同,异步I/O允许程序在等待I/O操作完成的同时执行其他任务。asyncio是Python标准库中用于编写异步代码的库,它提供了一个事件循环来处理异步操作。事件循环是asyncio的核心组件,它负责调度和执行异步......
  • Python实战:深拷贝与浅拷贝
    1.引言在Python中,对象是通过对内存中的数据进行引用来实现的。当我们创建一个对象并将其赋值给另一个变量时,实际上是将这个对象的引用复制给了另一个变量。这意味着,如果原始对象发生改变,引用该对象的变量也会受到影响。为了解决这个问题,Python提供了深拷贝和浅拷贝两种方......
  • Flask项目实战之-注册实现
    注册后端实现 passport/register请求方式:POST传入参数:JSON格式参数参数名类型是否必须参数说明mobilestring是手机号smscodestring是短信验证码passwordstring是密码返回类型:JSON参数名类型是否必须参数说明errnoint是错误码err......
  • java入门基础掌握知识
    Java基础入门Java一门高级编程语言Java是sun公司研发的,现在属于oracle公司Java之父是詹姆斯.高斯林Java主要是来做企业级应用开发的Java的三大技术体系是:技术体系说明JavaSE(JavaStandardEdition):标准版Java技术的核心和基础JavaEE(JavaEnterpri......
  • 阿里云-零基础入门NLP【基于深度学习的文本分类3-BERT】
    文章目录学习过程赛题理解学习目标赛题数据数据标签评测指标解题思路BERT代码学习过程20年当时自身功底是比较零基础(会写些基础的Python[三个科学计算包]数据分析),一开始看这块其实挺懵的,不会就去问百度或其他人,当时遇见困难挺害怕的,但22后面开始力扣题【目前已刷......
  • 【晴问算法】入门篇—日期处理—日期加法
    题目描述给定一个日期DAY和一个正整数n,求日期DAY加上n天后的日期。输入描述第一行为给定的日期DAY(格式为YYYY-MM-DD,范围为1900-01-01<DAY≤2199-12-31),数据保证一定合法;第二行为需要增加的天数n(1≤n≤10000)。输出描述以YYYY-MM-DD的格式输出增加了n天后的日期。样例1......
  • pytorch学习
    x=torch.tensor([1,2])before=id(x)x=x-4before==id(x)返回值是False,说明x=x-4会构造一个新的tensor而若修改为x-=4,则返回值为True,说明会原地修改,更高效对于python的int类型来说:x=10before=id(x)x+=10before==id(x)由于int是一种不......
  • 机器学习算法那些事 | 使用Transformer模型进行时间序列预测实战
    本文来源公众号“机器学习算法那些事”,仅用于学术分享,侵权删,干货满满。原文链接:使用Transformer模型进行时间序列预测实战时间序列预测是一个经久不衰的主题,受自然语言处理领域的成功启发,transformer模型也在时间序列预测有了很大的发展。本文可以作为学习使用Transformer模......