• Chapter2 机器学习回顾与Pytorch的基本操作

    目录

    2.1 机器学习的本质是分类与回归

    2.1.1 分类问题

    2.1.2 回归问题

    2.1.3 构成机器学习的元素

    2.2 Pytorch的基本概念

    2.2.1 张量、变量与nn.module

    2.2.2 张量与机器学习的关系

    2.3 tensor编程基础

    2.3.1 正常定义的tensor(ones、eye、zeros)

    2.3.2 特殊定义的tensor (zeros_like、ones_like)

    2.3.3  特殊定义的tensor (rand（随机）、normal（正态分布）、uniform（均匀分布）、arange（序列）、linspace（等间隔）)

    2.3.4 tensor的属性

    2.3.5 tensor的算术无运算编程（一）

     2.3.6 Pytorch中的inplace操作与广播机制

    2.3.7 Tensor的取整、取余操作

    2.3.8 Tensor的比较运算

    2.3.9 Tensor的三角函数

    2.3.10 Tensor中其他的数学函数

    2.1 机器学习的本质是分类与回归

    2.1.1 分类问题

            分类问题：

             如上图所示是一个分类问题，即给你一张图片让你输出它的类别，对于类别的值我们采用离散的值来描述，我们最终输出的是一个十维的概率分布，概率值指向最大的维度就是我们最终的分类结果。

    2.1.2 回归问题

            回归问题：

             如上图是一个股票价格波动的一个曲线，回归值解决的就是连续值的预测，如果我们机器学习最终的预测模型是一个连续模型，我们将它定义为回归问题。如股票价格的预测、身高的预测、房价的预测等等。

    2.1.3 构成机器学习的元素

            样本、模型、训练、测试、推理。

            拿房价预测做举例：

            样本：样本由属性与标签构成，可以理解为函数形式y=f(x)，x对应属性，y对应标签。在上图房价预测这个问题中，属性指年份、标签指房价指数。

            模型：为了拟合这个属性相对于标签的函数，我们假定拟合模型为y = a*x^{3} + b*x^{2}+cx+d。当然这可能不是最好的，只是一个假定而已。

            训练：在我们本科阶段，解方程是几个未知数对应几元方程，但在机器学习中不同，我们拿（属性，标签）的海量数据对模型参数a,b,c,d进行训练，也就是说（参数数量远小于样本量），最终我们通过本专栏内容训练出了模型参数。（深度学习的模型参数数量远大于样本量）

            测试：我们拿代价函数评判这个函数的好坏。

            推理：对于一个新的没有标签的属性数据，我们要推理它的属性。比如我们通过所给模型来预测2090年的房价指数。

    2.2 Pytorch的基本概念

    2.2.1 张量、变量与nn.module

    Tensor：张量

            我们之前描述物体所用的形式：标量、向量、矩阵只能描述1维、n维、w\times m维的事物，而用这些描述形式最多可以描述w\times m维的事物无法描述高维，而我们用张量可以描述任意维度的事物。可以理解向量是1维张量、矩阵是2维张量。拿房价预测来讲，房价可能受地域、面积、海拔等不同因素影响，用低维张量难以表示。

    Variable：变量

             机器学习人物中用变量表达参数。

    nn.module：解决计算机视觉问题所用的网络结构

    2.2.2 张量与机器学习的关系

            机器学习就是用tensor表达样本，一条语音数据用一个向量进行描述（采样后的波形）、图像灰度图用二阶张量来描述（0-256 h*w矩阵）。

    2.3 tensor编程基础

    2.3.1 正常定义的tensor(ones、eye、zeros)

    1. import torch
    2.  
    3. a = torch.Tensor([[1,2],[3,4]])
    4.  
    5. print(a)
    6. print(a.type())
    7.  
    8. b = torch.Tensor(2,3)
    9. print(b)
    10. print(b.type())
    11.  
    12. c = torch.ones(2,2)
    13. print(c)
    14. print(c.type())
    15.  
    16. d = torch.eye(2,2)
    17. print(d)
    18. print(d.type())
    19.  
    20. e = torch.zeros(2,2)
    21. print(e)
    22. print(e.type())

             可以看出不加声明的话tensor中的元素都是float类型的，如果仅仅对tensor进行声明输出的是内存数据。eye对应单位矩阵，zeros对应零矩阵。

    2.3.2 特殊定义的tensor (zeros_like、ones_like)

    1. import torch
    2.  
    3. a = torch.Tensor([[1,2],[3,4]])
    4.  
    5. print(a)
    6. print(a.type())
    7.  
    8. b = torch.Tensor(2,3)
    9. print(b)
    10. print(b.type())
    11.  
    12. c = torch.ones(2,2)
    13. print(c)
    14. print(c.type())
    15.  
    16. d = torch.eye(2,2)
    17. print(d)
    18. print(d.type())
    19.  
    20. e = torch.zeros(2,2)
    21. print(e)
    22. print(e.type())
    23.  
    24. f = torch.zeros_like(b)
    25. g = torch.ones_like(b)
    26. print(f)
    27. print(g)

             可以看出，用此种方法定义出的tensor保留了原来的格式并赋予了新的赋值方法。

    2.3.3  特殊定义的tensor (rand（随机）、normal（正态分布）、uniform（均匀分布）、arange（序列）、linspace（等间隔）)

    1. import torch
    2.  
    3. a = torch.rand(2,2)
    4. print(a)
    5.  
    6. a = torch.normal(mean = 0.0,std = torch.rand(5))
    7. print(a)
    8.  
    9. a = torch.normal(mean = torch.rand(5),std = torch.rand(5))
    10. print(a)

            生成随机值与生成正态分布值。

            生成正态分布值解释：我们初始化均值mean、方差std为五组不同的数据，即五组不同的正态分布，我们再从这五组不同的正态分布随机生成满足正态分布的五个值。

    1. import torch
    2.  
    3. a = torch.Tensor(2,2).uniform_(-1,1)
    4. print(a)
    5.  
    6. a = torch.arange(0,10,2)
    7. print(a)
    8.  
    9. a = torch.linspace(1,100,3)
    10. print(a)

             都很好理解，不加解释。

    2.3.4 tensor的属性

            每一个tensor有torch.dtype、torch.device、torch.layout三种属性

            torch.dtype标识了数据类型。

            torch.device标识了tensor.Tensor对象在创建之后所存储在的设备名称（CPU、GPU）。

            torch.layout表示tensor.Tensor内存布局的对象（稠密，稀疏）。

            定义稠密张量无须多言是一种缺创建省的方式：

    torch.tensor([1,2,3],dtype=torch.float32,device=torch.device('cpu'))

            定义稀疏张量：torch.sparse_coo_tensor，coo类型表示了非零元素的坐标形式：

            类似于数据结构的稀疏矩阵可以大量节省内存，如下代码的含义是三组坐标的值非零(0,2)(1,0)(1,2)，值为3,4,5，类型为float32，是一个3\times 4的tensor。

    1. import torch
    2.  
    3. i = torch.tensor([[0,1,2],[2,0,2]])
    4. v = torch.tensor([3,4,5])
    5. a = torch.sparse_coo_tensor(i,v,(3,4))
    6.  
    7. print(a)

            稀疏张量转换成稠密张量：

    a = torch.sparse_coo_tensor(i,v,(3,4)).to_dense()

     

    2.3.5 tensor的算术无运算编程（一）

    无 
    1. liuhongwei@liuhongwei-Lenovo-Legion-R9000P2021H:~/桌面/pytorch_code/03$ python3 demo_op.py 
    2. tensor([[0.5891, 0.1490, 0.2156],
    3.         [0.1762, 0.3079, 0.0788]])
    4. tensor([[0.3559, 0.5683, 0.2320],
    5.         [0.1876, 0.4727, 0.2266]])
    6. tensor([[0.9451, 0.7173, 0.4475],
    7.         [0.3638, 0.7806, 0.3054]])
    8. tensor([[0.9451, 0.7173, 0.4475],
    9.         [0.3638, 0.7806, 0.3054]])
    10. tensor([[0.9451, 0.7173, 0.4475],
    11.         [0.3638, 0.7806, 0.3054]])
    12. tensor([[0.5891, 0.1490, 0.2156],
    13.         [0.1762, 0.3079, 0.0788]])
    14. tensor([[0.9451, 0.7173, 0.4475],
    15.         [0.3638, 0.7806, 0.3054]])
    16. tensor([[0.9451, 0.7173, 0.4475],
    17.         [0.3638, 0.7806, 0.3054]])
    18. ==== sub res ====
    19. tensor([[0.5891, 0.1490, 0.2156],
    20.         [0.1762, 0.3079, 0.0788]])
    21. tensor([[0.5891, 0.1490, 0.2156],
    22.         [0.1762, 0.3079, 0.0788]])
    23. tensor([[0.5891, 0.1490, 0.2156],
    24.         [0.1762, 0.3079, 0.0788]])
    25. tensor([[0.5891, 0.1490, 0.2156],
    26.         [0.1762, 0.3079, 0.0788]])
    27. tensor([[0.5891, 0.1490, 0.2156],
    28.         [0.1762, 0.3079, 0.0788]])
    29. ===== mul ====
    30. tensor([[0.2097, 0.0847, 0.0500],
    31.         [0.0331, 0.1455, 0.0179]])
    32. tensor([[0.2097, 0.0847, 0.0500],
    33.         [0.0331, 0.1455, 0.0179]])
    34. tensor([[0.2097, 0.0847, 0.0500],
    35.         [0.0331, 0.1455, 0.0179]])
    36. tensor([[0.5891, 0.1490, 0.2156],
    37.         [0.1762, 0.3079, 0.0788]])
    38. tensor([[0.2097, 0.0847, 0.0500],
    39.         [0.0331, 0.1455, 0.0179]])
    40. tensor([[0.2097, 0.0847, 0.0500],
    41.         [0.0331, 0.1455, 0.0179]])
    42. === div ===
    43. tensor([[0.5891, 0.1490, 0.2156],
    44.         [0.1762, 0.3079, 0.0788]])
    45. tensor([[0.5891, 0.1490, 0.2156],
    46.         [0.1762, 0.3079, 0.0788]])
    47. tensor([[0.5891, 0.1490, 0.2156],
    48.         [0.1762, 0.3079, 0.0788]])
    49. tensor([[0.5891, 0.1490, 0.2156],
    50.         [0.1762, 0.3079, 0.0788]])
    51. tensor([[0.5891, 0.1490, 0.2156],
    52.         [0.1762, 0.3079, 0.0788]])
    53. tensor([[1., 1.],
    54.         [1., 1.]])
    55. tensor([[1., 1.],
    56.         [1., 1.]])
    57. tensor([[1., 1.],
    58.         [1., 1.]])
    59. tensor([[1., 1.],
    60.         [1., 1.]])
    61. tensor([[1., 1.],
    62.         [1., 1.]])
    63. torch.Size([1, 2, 3, 3])
    64. tensor([1, 8])
    65. tensor([1, 8])
    66. tensor([1, 8])
    67. tensor([1, 8])
    68. tensor([1, 8])
    69. torch.FloatTensor
    70. tensor([2.7183, 7.3891])
    71. tensor([2.7183, 7.3891])
    72. tensor([  15.1543, 1618.1781])
    73. tensor([  15.1543, 1618.1781])
    74. tensor([2.3026, 0.6931])
    75. tensor([2.3026, 0.6931])
    76. tensor([ 0.8340, -0.3665])
    77. tensor([ 0.8340, -0.3665])
    78. tensor([3.1623, 1.4142])
    79. tensor([3.1623, 1.4142])
    80. tensor([1.7783, 1.1892])
    81. tensor([1.7783, 1.1892])

     2.3.6 Pytorch中的inplace操作与广播机制

            inplace操作即不允许使用临时变量。也称为原地操作。x = x+y。比如add_、sub_、mul_

            广播机制即张量参数可以自动扩展为相同大小，广播机制要满足两个条件：

            1.每个张量至少有一个维度  2.满足右对齐

    torch.rand(2,1,1)+torch.rand(3)

            所谓右对齐，以这两个张量以右边进行对齐。也即"3与1进行对齐"，3前面没有维度我们进行补1，也即(1,1,3)这个维度，我们从右向左看，满足两个条件（要么相等，要么一个为1）我们认为是右对齐的。（实例中有个1我们认为满足右对齐）

    1. import torch
    2.  
    3. a = torch.rand(2, 2)
    4. b = torch.rand(1, 2)
    5. # a, 2*1
    6. # b, 1*2
    7. # c, 2*2
    8. # 2*4*2*3
    9. c = a + b
    10. print(a)
    11. print(b)
    12. print(c)
    13. print(c.shape)

            我们看到，将第一行进行相加，再把第一行拷贝到第二行进行相加得到结果。

            我们来看一个复杂的例子：

    1. import torch
    2.  
    3. a = torch.rand(2,1,1,3)
    4. b = torch.rand(4,2,3)
    5.  
    6. c = a + b
    7. print(a)
    8. print(b)
    9. print(c)
    10. print(c.shape)

            我们可以预测到我们输出的向量维为(2\times 4 \times 2\times 3)，我们看看结果。

    1. liuhongwei@liuhongwei-Lenovo-Legion-R9000P2021H:~/桌面/pytorch_code/03$ python3  demo_broadcast.py 
    2. tensor([[[[0.3442, 0.7778, 0.3574]]],
    3.  
    4.  
    5.         [[[0.0979, 0.8217, 0.0140]]]])
    6. tensor([[[0.4133, 0.1959, 0.4576],
    7.          [0.4061, 0.8951, 0.3582]],
    8.  
    9.         [[0.7706, 0.4344, 0.5427],
    10.          [0.5669, 0.4276, 0.7704]],
    11.  
    12.         [[0.6270, 0.5850, 0.8272],
    13.          [0.7869, 0.1770, 0.5247]],
    14.  
    15.         [[0.3716, 0.6591, 0.5735],
    16.          [0.9159, 0.4745, 0.2106]]])
    17. tensor([[[[0.7575, 0.9737, 0.8149],
    18.           [0.7503, 1.6729, 0.7155]],
    19.  
    20.          [[1.1148, 1.2122, 0.9000],
    21.           [0.9111, 1.2054, 1.1277]],
    22.  
    23.          [[0.9712, 1.3629, 1.1846],
    24.           [1.1311, 0.9549, 0.8820]],
    25.  
    26.          [[0.7158, 1.4370, 0.9309],
    27.           [1.2601, 1.2524, 0.5680]]],
    28.  
    29.  
    30.         [[[0.5112, 1.0176, 0.4716],
    31.           [0.5040, 1.7168, 0.3722]],
    32.  
    33.          [[0.8685, 1.2561, 0.5567],
    34.           [0.6648, 1.2494, 0.7844]],
    35.  
    36.          [[0.7249, 1.4068, 0.8412],
    37.           [0.8848, 0.9988, 0.5387]],
    38.  
    39.          [[0.4695, 1.4809, 0.5875],
    40.           [1.0138, 1.2963, 0.2246]]]])
    41. torch.Size([2, 4, 2, 3])

    2.3.7 Tensor的取整、取余操作

    我们具体看看代码操作：

    1. import torch
    2.  
    3. a = torch.rand(2, 2)
    4. a = a * 10
    5. print(a)
    6.  
    7. print(torch.floor(a))
    8. print(torch.ceil(a))
    9. print(torch.round(a))
    10. print(torch.trunc(a))
    11. print(torch.frac(a))
    12. print(a % 2)
    13. b = torch.tensor([[2, 3], [4, 5]],
    14.                  dtype=torch.float)
    15. print(torch.fmod(a, b))
    16. print(torch.remainder(a, b))

    2.3.8 Tensor的比较运算

     

    1. import torch
    2.  
    3. a = torch.rand(2, 3)
    4. b = torch.rand(2, 3)
    5.  
    6. print(a)
    7. print(b)
    8.  
    9. print(torch.eq(a, b))             #判断每一个元素是否相等 返回一个2*3张量 元素为true、false
    10. print(torch.equal(a, b))          #如果全相等（shape和元素值）返回true
    11.  
    12. print(torch.ge(a, b))
    13. print(torch.gt(a, b))
    14. print(torch.le(a, b))
    15. print(torch.lt(a, b))
    16. print(torch.ne(a, b))
    17.  
    18. ####
    19.  
    20. a = torch.tensor([[1, 4, 4, 3, 5],
    21.                   [2, 3, 1, 3, 5]])
    22. print(a.shape)                                    #2*5
    23. print(torch.sort(a, dim=1,
    24.                  descending=False))
    25. #输出如下： 
    26. #torch.Size([2, 5])
    27. #values=tensor([[1, 3, 4, 4, 5],
    28. #        [1, 2, 3, 3, 5]]),
    29. #indices=tensor([[0, 3, 1, 2, 4],
    30. #        [2, 0, 1, 3, 4]]))   在原来的tensor中的索引值
    31. #dim是指定轴的意思：如果dim=0则会对1，2   4，3  4，1 3，3 5，5排序  dim=1会对两个序列进行排序
    32.  
    33.  
    34. ##topk
    35. a = torch.tensor([[2, 4, 3, 1, 5],
    36.                   [2, 3, 5, 1, 4]])
    37. print(a.shape)                                        #2*5
    38.  
    39. print(torch.topk(a, k=2, dim=1, largest=False))       #dim=0 指向2的维度  dim=1 指向5的维度 
    40.  
    41. print(torch.kthvalue(a, k=2, dim=0))       #第0维（2）第二小的数
    42. #values=tensor([2, 4, 5, 1, 5]),
    43. #indices=tensor([1, 0, 1, 1, 0]))
    44.  
    45.  
    46. print(torch.kthvalue(a, k=2, dim=1))       #第1维（5）第二个最小值
    47. #values=tensor([2, 2]),
    48. #indices=tensor([0, 0]))
    49.  
    50. a = torch.rand(2, 3)
    51. print(a)
    52. print(a/0)
    53. print(torch.isfinite(a))    ##有界
    54. print(torch.isfinite(a/0))  ##有界
    55. print(torch.isinf(a/0))     ##无界
    56. print(torch.isnan(a))       ##nan
    57.  
    58. import numpy as np
    59. a = torch.tensor([1, 2, np.nan])
    60. print(torch.isnan(a))
    61.  
    62. a = torch.rand(2, 3)
    63. print(a)
    64. print(torch.topk(a, k=2, dim=1, largest=False))
    65. print(torch.topk(a, k=2, dim=1, largest=True))
    66.  
    1. liuhongwei@liuhongwei-Lenovo-Legion-R9000P2021H:~/桌面/pytorch_code/03$ python3 demo_compare.py 
    2. tensor([[0.0923, 0.9738, 0.9263],
    3.         [0.8390, 0.9426, 0.7391]])
    4. tensor([[0.1983, 0.1863, 0.0867],
    5.         [0.7300, 0.9369, 0.6763]])
    6. tensor([[False, False, False],
    7.         [False, False, False]])
    8. False
    9. tensor([[False,  True,  True],
    10.         [ True,  True,  True]])
    11. tensor([[False,  True,  True],
    12.         [ True,  True,  True]])
    13. tensor([[ True, False, False],
    14.         [False, False, False]])
    15. tensor([[ True, False, False],
    16.         [False, False, False]])
    17. tensor([[True, True, True],
    18.         [True, True, True]])
    19. torch.Size([2, 5])
    20. torch.return_types.sort(
    21. values=tensor([[1, 3, 4, 4, 5],
    22.         [1, 2, 3, 3, 5]]),
    23. indices=tensor([[0, 3, 1, 2, 4],
    24.         [2, 0, 1, 3, 4]]))
    25. torch.Size([2, 5])
    26. torch.return_types.topk(
    27. values=tensor([[1, 2],
    28.         [1, 2]]),
    29. indices=tensor([[3, 0],
    30.         [3, 0]]))
    31. torch.return_types.kthvalue(
    32. values=tensor([2, 4, 5, 1, 5]),
    33. indices=tensor([1, 0, 1, 1, 0]))
    34. torch.return_types.kthvalue(
    35. values=tensor([2, 2]),
    36. indices=tensor([0, 0]))
    37. tensor([[0.4250, 0.6952, 0.5542],
    38.         [0.5016, 0.5173, 0.9565]])
    39. tensor([[inf, inf, inf],
    40.         [inf, inf, inf]])
    41. tensor([[True, True, True],
    42.         [True, True, True]])
    43. tensor([[False, False, False],
    44.         [False, False, False]])
    45. tensor([[True, True, True],
    46.         [True, True, True]])
    47. tensor([[False, False, False],
    48.         [False, False, False]])
    49. tensor([False, False,  True])
    50. tensor([[0.7347, 0.2777, 0.1669],
    51.         [0.7062, 0.7895, 0.7085]])
    52. torch.return_types.topk(
    53. values=tensor([[0.1669, 0.2777],
    54.         [0.7062, 0.7085]]),
    55. indices=tensor([[2, 1],
    56.         [0, 2]]))
    57. torch.return_types.topk(
    58. values=tensor([[0.7347, 0.2777],
    59.         [0.7895, 0.7085]]),
    60. indices=tensor([[0, 1],
    61.         [1, 2]]))

             讲解在源码已标识注释。

    2.3.9 Tensor的三角函数

     

    1. import torch
    2. a = torch.zeros(2, 3)
    3. b = torch.cos(a)
    4. print(a)
    5. print(b)

             cos0=1。

    2.3.10 Tensor中其他的数学函数

             最重要的就是绝对值函数、符号函数、sigmoid函数（激活函数）！

  • 相关阅读:
    Java接口自动化框架:maven编译警告解决之-Xlint:unchecked以及使用了未经检查或不安全的操作
    ZooKeeper、CuratorFramework、Watcher、ConnectionStateListener
    【C语言】进阶——文件操作
    如何在排除子目录时挂载 Docker 卷
    sql注入绕过waf
    存档-链表设计JS/TS版
    神经网络重建治疗仪原理,神经网络修复视频教程
    数据校验(初级篇)
    【Python】13.模块
    小米商城侧导航栏的实现
  • 原文地址：https://blog.csdn.net/qq_41694024/article/details/127859357