devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

pytorch 入门基础知识一（Pytorch 01）

作者：很楠不爱3 | 2024-03-18 14:04:16

赞

踩

pytorch 入门基础知识一（Pytorch 01）

一 深度学习基础相关

深度学习三个主要的方向：计算机视觉，自然语言，语音识别。

机器学习核心组件：1 数据集(data)，2 前向传播的model(net)，3 目标函数(loss)， 4 调整模型参数和优化函数的算法(adam)。

数据集：用于模型训练的数据。

模型：用于前向传播计算的model, 其中涉及各种复杂的网络，Alexnet, CNN等都属于这个模块的内容，对于传统模型，常规使用公式计算结果的公式其实就是模型的一种，模型主要作用是通过记录的参数计算想要的目标值。

目标函数：常用的均方误差，平方误差都是，目标函数的一直，用于评估预测值和实际结果的偏差。

优化算法：深度学习常用的梯度下降算法，在训练模型参数时用于减小损失误差。

不管是回归还是分类问题其实都是监督学习的内容，就是在训练模型是有一个目标值，而聚类算法，对抗性网络等属于无监督学习。

强化学习更考虑与环境的互动，在实际环境中根据实际结果做反馈实时修正模型。

PS：机器学习很吃数据，如果数据量不够，可能得考虑传统方法，比如之前遇到的一个项目，训练数据不够，属于前期就介入，根本没太多历史数据，不能够拟合出正确应对实际场景的应用，最后使用传统反馈调整的模式解决了问题，做视觉其实也遇到了这个问题，异常数据太少，而且不是很普遍，还是考虑传统方式处理，起码稳定。

计算机算力确实发生了很大的变化，近两年还是风云突变：

二 pytorch 基础操作

2.1 数据生成 (pytorch叫张量)

  1. import torch
  2. import torchvision
  3.  
  4. x = torch.arange(12)
  5. x   # tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

 查看数据形状：

  1. x.shape
  2.  
  3. # torch.Size([12])

查看张量的总数据量：

x.numel()   # 矩阵元素数量  # 12

调整张量的形状：

  1. X = x.reshape(3, 4)
  2. X
  3. # tensor([[ 0,  1,  2,  3],
  4. #         [ 4,  5,  6,  7],
  5. #         [ 8,  9, 10, 11]])

生成指定形状的数组：

  1. torch.zeros((2, 3, 4))
  2. # tensor([[[0., 0., 0., 0.],
  3. #          [0., 0., 0., 0.],
  4. #          [0., 0., 0., 0.]],
  5.  
  6. #         [[0., 0., 0., 0.],
  7. #          [0., 0., 0., 0.],
  8. #          [0., 0., 0., 0.]]])

指定形状数据为1的张量：

  1. torch.ones((2, 3, 4))
  2. # tensor([[[1., 1., 1., 1.],
  3. #          [1., 1., 1., 1.],
  4. #          [1., 1., 1., 1.]],
  5.  
  6. #         [[1., 1., 1., 1.],
  7. #          [1., 1., 1., 1.],
  8. #          [1., 1., 1., 1.]]])

正太分布的张量：

  1. torch.randn(3, 4)
  2. # tensor([[ 1.2365,  0.2051,  1.0180,  1.2629],
  3. #         [-1.2494, -0.3436, -0.7135, -2.0160],
  4. #         [-1.2806,  1.5036, -0.2523, -0.1456]])

直接将列表转换为tensor张量：

  1. torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
  2. # tensor([[2, 1, 4, 3],
  3. #         [1, 2, 3, 4],
  4. #         [4, 3, 2, 1]])

2.2 pytorch 运算符

可以直接 + - * /：

  1. x = torch.tensor([1.0, 2, 4, 8])
  2. y = torch.tensor([2, 2, 2, 2])
  3. x + y, x - y, x * y, x / y, x ** y # **运算符是求幂运算
  4. # (tensor([ 3.,  4.,  6., 10.]),
  5. #  tensor([-1.,  0.,  2.,  6.]),
  6. #  tensor([ 2.,  4.,  8., 16.]),
  7. #  tensor([0.5000, 1.0000, 2.0000, 4.0000]),
  8. #  tensor([ 1.,  4., 16., 64.]))

求幂：

  1. torch.exp(x)   # e^x
  2. # tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

张量拼接，通过dim指定行还是列拼接：

  1. X = torch.arange(12, dtype=torch.float32).reshape((3,4))
  2. Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
  3. torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)
  4. # (tensor([[ 0.,  1.,  2.,  3.],
  5. #          [ 4.,  5.,  6.,  7.],
  6. #          [ 8.,  9., 10., 11.],
  7. #          [ 2.,  1.,  4.,  3.],
  8. #          [ 1.,  2.,  3.,  4.],
  9. #          [ 4.,  3.,  2.,  1.]]),
  10. #  tensor([[ 0.,  1.,  2.,  3.,  2.,  1.,  4.,  3.],
  11. #          [ 4.,  5.,  6.,  7.,  1.,  2.,  3.,  4.],
  12. #          [ 8.,  9., 10., 11.,  4.,  3.,  2.,  1.]]))

逻辑运算：

  1. X == Y
  2. # tensor([[False,  True, False,  True],
  3. #         [False, False, False, False],
  4. #         [False, False, False, False]])

所有元素求和：

  1. X.sum()
  2. # tensor(66.)

2.3 广播机制

  1. a = torch.arange(3).reshape((3, 1))
  2. b = torch.arange(2).reshape((1, 2))
  3. a, b
  4. # (tensor([[0],
  5. #          [1],
  6. #          [2]]),
  7. #  tensor([[0, 1]]))

自动广播：

  1. a + b
  2. # tensor([[0, 1],
  3. #         [1, 2],
  4. #         [2, 3]])

2.4 索引和切片

张量切片：

  1. X = torch.arange(12, dtype=torch.float32).reshape((3,4))
  2. X[-1], X[1:3]
  3. # (tensor([ 8.,  9., 10., 11.]),
  4. #  tensor([[ 4.,  5.,  6.,  7.],
  5. #          [ 8.,  9., 10., 11.]]))

指定位置写入数据：

  1. X[1, 2] = 9
  2. X
  3. # tensor([[ 0.,  1.,  2.,  3.],
  4. #         [ 4.,  5.,  9.,  7.],
  5. #         [ 8.,  9., 10., 11.]])

同时写入多个值：

  1. X[0:2, :] = 12
  2. X
  3. # tensor([[12., 12., 12., 12.],
  4. #         [12., 12., 12., 12.],
  5. #         [ 8.,  9., 10., 11.]])

2.5 原地更新参数

查看内存地址：

  1. before = id(Y)
  2. Y = Y + X
  3. id(Y) == before
  4. # False

张量原地更新：

  1. Z = torch.zeros_like(Y)
  2. print('id(Z):', id(Z))
  3. Z[:] = X + Y
  4. print('id(Z):', id(Z))
  5. # id(Z): 2385633027792
  6. # id(Z): 2385633027792

也可以直接写入原地址：

  1. before = id(X)
  2. X += Y
  3. id(X) == before
  4. # True

2.6 转换为python其他数据类型

numpy转换, torch.tensor() :

  1. A = X.numpy()
  2. B = torch.tensor(A)
  3. type(A), type(B)
  4. # (numpy.ndarray, torch.Tensor)

直接转换，a.item() 用于获取张量（Tensor）中单个元素 的值：

  1. a = torch.tensor([3.5])
  2. a, a.item(), float(a), int(a)
  3. # (tensor([3.5000]), 3.5, 3.5, 3)

三 数据预处理

3.1 读取数据集

创建数据写入 house_tiny.csv 文件：

  1. import os
  2. os.makedirs(os.path.join('..', 'data'), exist_ok=True)
  3. data_file = os.path.join('..', 'data', 'house_tiny.csv')
  4. with open(data_file, 'w') as f:
  5.     f.write('NumRooms,Alley,Price\n') # 列名
  6.     f.write('NA,Pave,127500\n') # 每行表示一个数据样本
  7.     f.write('2,NA,106000\n')
  8.     f.write('4,NA,178100\n')
  9.     f.write('NA,NA,140000\n')

pd.read_csv() 读取数据：

  1. import pandas as pd
  2. data = pd.read_csv(data_file)
  3. print(data)
  4. #    NumRooms Alley   Price
  5. # 0       NaN  Pave  127500
  6. # 1       2.0   NaN  106000
  7. # 2       4.0   NaN  178100
  8. # 3       NaN   NaN  140000

3.2 处理缺失值

第一列均值填充：

  1. inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
  2. # 使用均值填充第一列的缺失值
  3. inputs.iloc[:, 0] = inputs.iloc[:, 0].fillna(inputs.iloc[:, 0].mean())
  4. print(inputs)
  5. #    NumRooms Alley
  6. # 0       3.0  Pave
  7. # 1       2.0   NaN
  8. # 2       4.0   NaN
  9. # 3       3.0   NaN

第二列独热编码：

  1. inputs = pd.get_dummies(inputs, dummy_na=True)
  2. print(inputs)
  3. #    NumRooms  Alley_Pave  Alley_nan
  4. # 0       3.0        True      False
  5. # 1       2.0       False       True
  6. # 2       4.0       False       True
  7. # 3       3.0       False       True

数据格式转换为张量：

  1. import torch
  2. X = torch.tensor(inputs.to_numpy(dtype=float))
  3. y = torch.tensor(outputs.to_numpy(dtype=float))
  4. X, y
  5. # (tensor([[3., 1., 0.],
  6. #          [2., 0., 1.],
  7. #          [4., 0., 1.],
  8. #          [3., 0., 1.]], dtype=torch.float64),
  9. #  tensor([127500., 106000., 178100., 140000.], dtype=torch.float64))

四 线性代数

标量：

  1. import torch
  2. x = torch.tensor(3.0)
  3. y = torch.tensor(2.0)
  4. x + y, x * y, x / y, x**y
  5. # (tensor(5.), tensor(6.), tensor(1.5000), tensor(9.))

向量可以被视为标量值组成的列表：

  1. x = torch.arange(4)
  2. x
  3. # tensor([0, 1, 2, 3])

下标 取元素：

  1. x[3]
  2. # tensor(3)

向量 长度：

  1. len(x)
  2. # 4

张量形状：

  1. x.shape
  2. # torch.Size([4])

4.1 矩阵

向量将标量从零阶推广到一阶，矩阵将向量从一阶推广到二阶。

  1. A = torch.arange(20).reshape(5, 4)
  2. A
  3. # tensor([[ 0,  1,  2,  3],
  4. #         [ 4,  5,  6,  7],
  5. #         [ 8,  9, 10, 11],
  6. #         [12, 13, 14, 15],
  7. #         [16, 17, 18, 19]])

矩阵转置：

  1. A.T
  2. # tensor([[ 0,  4,  8, 12, 16],
  3. #         [ 1,  5,  9, 13, 17],
  4. #         [ 2,  6, 10, 14, 18],
  5. #         [ 3,  7, 11, 15, 19]])

对称矩阵，一个矩阵和它的转置矩阵一样的时候该矩阵为对称矩阵：

  1. B = torch.tensor([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
  2. B
  3. # tensor([[1, 2, 3],
  4. #         [2, 0, 4],
  5. #         [3, 4, 5]])
  1. B == B.T
  2. # tensor([[True, True, True],
  3. #         [True, True, True],
  4. #         [True, True, True]])

4.2 张量

张量是一个更广泛的概念，可以包括标量、向量以及更高维度的数组。

  1. X = torch.arange(24).reshape(2, 3, 4)
  2. X
  3. # tensor([[[ 0,  1,  2,  3],
  4. #          [ 4,  5,  6,  7],
  5. #          [ 8,  9, 10, 11]],
  6.  
  7. #         [[12, 13, 14, 15],
  8. #          [16, 17, 18, 19],
  9. #          [20, 21, 22, 23]]])

4.3 张量算法的基本性质

给定具有相同形 状的任意两个张量，任何按元素二元运算的结果都将是相同形状的张量。例如，将两个相同形状的矩阵相加， 会在这两个矩阵上执行元素加法，张量形状不变。

  1. A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
  2. B = A.clone() # 通过分配新内存，将A的一个副本分配给B
  3. A, A + B
  4. # (tensor([[ 0.,  1.,  2.,  3.],
  5. #          [ 4.,  5.,  6.,  7.],
  6. #          [ 8.,  9., 10., 11.],
  7. #          [12., 13., 14., 15.],
  8. #          [16., 17., 18., 19.]]),
  9. #  tensor([[ 0.,  2.,  4.,  6.],
  10. #          [ 8., 10., 12., 14.],
  11. #          [16., 18., 20., 22.],
  12. #          [24., 26., 28., 30.],
  13. #          [32., 34., 36., 38.]]))
  1. A * B
  2. # tensor([[  0.,   1.,   4.,   9.],
  3. #         [ 16.,  25.,  36.,  49.],
  4. #         [ 64.,  81., 100., 121.],
  5. #         [144., 169., 196., 225.],
  6. #         [256., 289., 324., 361.]])

将张量乘以或加上一个标量不会改变张量的形状，其中张量的每个元素都将与标量相加或相乘，广播机制。

  1. a = 2
  2. X = torch.arange(24).reshape(2, 3, 4)
  3. a + X, (a * X).shape
  4. # (tensor([[[ 2,  3,  4,  5],
  5. #           [ 6,  7,  8,  9],
  6. #           [10, 11, 12, 13]],
  7.  
  8. #          [[14, 15, 16, 17],
  9. #           [18, 19, 20, 21],
  10. #           [22, 23, 24, 25]]]),
  11. #  torch.Size([2, 3, 4]))

4.4 降维

  1. x = torch.arange(4, dtype=torch.float32)
  2. x, x.sum()
  3. # (tensor([0., 1., 2., 3.]), tensor(6.))

 sum() 可以对所有元素求和，算预测结果损失和有用：

  1. A.shape, A.sum()
  2. # (torch.Size([5, 4]), tensor(190.))

axis 指定张量降维维度：

  1. A_sum_axis0 = A.sum(axis=0)
  2. A_sum_axis0, A_sum_axis0.shape
  3. # (tensor([40., 45., 50., 55.]), torch.Size([4]))
  1. A_sum_axis1 = A.sum(axis=1)
  2. A_sum_axis1, A_sum_axis1.shape
  3. # (tensor([ 6., 22., 38., 54., 70.]), torch.Size([5]))
  1. A.sum(axis=[0, 1]) # 结果和A.sum()相同
  2. # tensor(190.)

求所有元素均值：

  1. A.mean(), A.sum() / A.numel()
  2. # (tensor(9.5000), tensor(9.5000))

指定维度均值：

  1. A.mean(axis=0), A.sum(axis=0) / A.shape[0]
  2. # (tensor([ 8.,  9., 10., 11.]), tensor([ 8.,  9., 10., 11.]))

非降维求和：

  1. sum_A = A.sum(axis=1, keepdims=True)
  2. sum_A
  3. # # tensor([[ 6.],
  4. #         [22.],
  5. #         [38.],
  6. #         [54.],
  7. #         [70.]])

 由于sum_A在对每行进行求和后仍保持两个轴，我们可以通过广播将A除以sum_A，求该行每个元素的占比。

  1. A / sum_A
  2. # tensor([[0.0000, 0.1667, 0.3333, 0.5000],
  3. #         [0.1818, 0.2273, 0.2727, 0.3182],
  4. #         [0.2105, 0.2368, 0.2632, 0.2895],
  5. #         [0.2222, 0.2407, 0.2593, 0.2778],
  6. #         [0.2286, 0.2429, 0.2571, 0.2714]])

沿某个轴计算A元素的累积总和，比如axis=0（按行计算），可以调用cumsum函数。

  1. print(A)
  2. A.cumsum(axis=0)
  3. # tensor([[ 0.,  1.,  2.,  3.],
  4. #         [ 4.,  5.,  6.,  7.],
  5. #         [ 8.,  9., 10., 11.],
  6. #         [12., 13., 14., 15.],
  7. #         [16., 17., 18., 19.]])
  8. # tensor([[ 0.,  1.,  2.,  3.],
  9. #         [ 4.,  6.,  8., 10.],
  10. #         [12., 15., 18., 21.],
  11. #         [24., 28., 32., 36.],
  12. #         [40., 45., 50., 55.]])

4.5 点积

深度学习中线性模型在 前向传播中使用的就是点积：

  1. x = torch.arange(4, dtype=torch.float32)
  2. y = torch.ones(4, dtype = torch.float32)
  3. x, y, torch.dot(x, y)
  4. # (tensor([0., 1., 2., 3.]), tensor([1., 1., 1., 1.]), tensor(6.))

可以通过执行按元素乘法，然后进行求和来表示两个向量的点积：

  1. torch.sum(x * y)
  2. # tensor(6.)

矩阵向量积，结果是一个新的向量，A的列维数（沿轴1的长度）必须与x的维数（其长度）相同：

  1. print(A)
  2. print(x)
  3. A.shape, x.shape, torch.mv(A, x)
  4. # tensor([[ 0.,  1.,  2.,  3.],
  5. #         [ 4.,  5.,  6.,  7.],
  6. #         [ 8.,  9., 10., 11.],
  7. #         [12., 13., 14., 15.],
  8. #         [16., 17., 18., 19.]])
  9. # tensor([0., 1., 2., 3.])
  10. # (torch.Size([5, 4]), torch.Size([4]), tensor([ 14.,  38.,  62.,  86., 110.]))

矩阵-矩阵乘法，torch.mm 用于计算两个矩阵的乘积：

  1. B = torch.ones(4, 3)
  2. A, B, torch.mm(A, B)
  3. # (tensor([[ 0.,  1.,  2.,  3.],
  4. #          [ 4.,  5.,  6.,  7.],
  5. #          [ 8.,  9., 10., 11.],
  6. #          [12., 13., 14., 15.],
  7. #          [16., 17., 18., 19.]]),
  8. #  tensor([[1., 1., 1.],
  9. #          [1., 1., 1.],
  10. #          [1., 1., 1.],
  11. #          [1., 1., 1.]]),
  12. #  tensor([[ 6.,  6.,  6.],
  13. #          [22., 22., 22.],
  14. #          [38., 38., 38.],
  15. #          [54., 54., 54.],
  16. #          [70., 70., 70.]]))

4.6 范数

欧几里得距离是一个L2范数，向量元素平方和的平方根：

  1. u = torch.tensor([3.0, -4.0])
  2. torch.norm(u)
  3. # tensor(5.)

L1范数，我们将元素绝对值求和 组合起来：

  1. torch.abs(u).sum()
  2. # tensor(7.)

Frobenius范数 满足向量范数的所有性质，它就像是 矩阵形向量的L2范数。

  1. n = torch.ones((4, 9))
  2. n, torch.norm(n)
  3. # (tensor([[1., 1., 1., 1., 1., 1., 1., 1., 1.],
  4. #          [1., 1., 1., 1., 1., 1., 1., 1., 1.],
  5. #          [1., 1., 1., 1., 1., 1., 1., 1., 1.],
  6. #          [1., 1., 1., 1., 1., 1., 1., 1., 1.]]),
  7. #  tensor(6.))

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/263568
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号