devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

笔记 | PyTorch安装及入门教程

作者：凡人多烦事01 | 2024-03-05 20:46:16

赞

踩

torch.optim安装

点上方蓝字计算机视觉联盟获取更多干货

在右上方 ··· 设为星标 ★，与你不见不散

  计算机视觉联盟笔记  

作者：王博Kings、Sophia

本文内容概述如何安装PyTorch以及PyTorch的一些简单操作

AI博士PyTorch笔记系列推荐

收藏 | 深度学习之Numpy基础入门教程！

本期笔记目录：

2.1 为何选择PyTorch?

PyTorch主要由4个包组成：

  1. torch:可以将张量转换为torch.cuda.TensorFloat

  2. torch.autograd:自动梯度

  3. torch.nn：具有共享层和损失函数的神经网络库

  4. torch.optim：具有通用的优化算法包（SGD、Adam）

    2.2 安装Anaconda

Anaconda官网地址

https://www.anaconda.com/products/individual

       

       

       

       

这里选择All Users，一步一步操作即可

       

安装成功与否

       

       

       

       

       

2.3 安装Pytorch

由于pytorch有不同的版本，为了方便使用不同的版本，我们新建不同的环境（类比建造房屋，一个房屋放一个版本的pytorch），用来安装现有版本的pytorch

conda create –n pytorch python=3.7

       

选择Y

       

conda info –envs

       

conda activate pytorch

       

安装Pytorch

Pytorch的官方网站：

https://pytorch.org/

       

conda install pytorch torchvision cudatoolkit=10.2 -c pytorch

       

选择y

       

       

       

       

       

       

       

2.4 Numpy 与 Tensor

Numpy会把ndarray 放在CPU中运行加速，而由Torch产生的Tensor会放在GPU中进行加速运算

2.4.1 Tensor概述

从接口的角度划分：

  1. 1. torch.function           torch.sum       torch.add
  2. 2. tensor.function         tensor.view     tensor.add

从修改方式的角度划分：

  1. 1. 不修改自身数据，x.add(y)，x数据不变，返回新的Tensor
  2. 2. 修改自身数据，x.add_(y)，运算结果存在x中，x被修改
  1. import torch
  2. x=torch.tensor([1,2])
  3. y=torch.tensor([3,4])
  4. z=x.add(y)
  5. print(z)
  6. print(x)
  7. x.add_(y)
  8. print(x)

2.4.2 创建Tensor

创建Tensor的常用方法

  1. * Tensor(*size)                          从参数构建，List或者Numpy都行
  2. * eye(row,column)                    指定行数和列数的二维Tensor
  3. * linspace(start,end,steps)        均匀分成
  4. * longspace(start,end,steps)      10^start到10^end，均匀分成
  5. * rand/randn(*size)                     生成[0,1)均与分布，标准正态分布
  6. * ones(*size)                              返回指定shape张量，元素为1
  7. * zeros(*size)                             返回指定shape张量，元素为0
  8. * ones_like(t)
  9. * zeros_like(t)
  10. * arange(start,end,stop)
  11. * from_Numpy(ndarray)
  1. import torch
  2.  
  3. print(torch.Tensor([1,2,3,4,5,6]))
  4. print(torch.Tensor(2,3))
  5. t = torch.Tensor([[1,2,3],[4,5,6]])
  6. print(t)
  7. print(t.size())
  8. t.shape
  9. torch.Tensor(t.size())

torch.Tensor与torch.tensor的区别：

  1. torch.Tensor是torch.empty 和 torch.tensor 之间的混合。传入数据时，torch.Tensor使用全局默认dtype(FloatTensor)，而torch.tensor是从数据中推断数据类型

  2. torch.tensor(1)返回的是固定值1；torch.Tensor返回的是大小为1的张量

    1. import torch
    2. t1=torch.Tensor(1)
    3. t2=torch.tensor(1)
    4. print("t1的值{}，t1的数据类型{}".format(t1,t1.type()))
    5. print("t2的值{}，t2的数据类型{}".format(t2,t2.type()))
    6. # 输出
    7. t1的值tensor([0.])，t1的数据类型torch.FloatTensor
    8. t2的值1，t2的数据类型torch.LongTensor
    1. import torch
    2. print(torch.eye(2,2))
    3. print(torch.zeros(2,3))
    4. print(torch.linspace(1,10,4))
    5. print(torch.rand(2,3))
    6. print(torch.randn(2,3))
    7. print(torch.zeros_like(torch.rand(2,3)))
    8. #输出结果
    9. tensor([[1., 0.],
    10.      [0., 1.]])
    11. tensor([[0., 0., 0.],
    12.      [0., 0., 0.]])
    13. tensor([ 1.,  4.,  7., 10.])
    14. tensor([[0.5942, 0.1468, 0.3175],
    15.      [0.2744, 0.9218, 0.7266]])
    16. tensor([[ 1.0187, -0.2809,  1.0421],
    17.      [-0.1697, -0.0604, -1.6645]])
    18. tensor([[0., 0., 0.],
    19.      [0., 0., 0.]])

    2.4.3 修改Tensor形状

常用的tensor修改形状的函数

  1. * size（）                         计算张量属性值，与shape等价
  2. * numel(input)                  计算张量的元素个数
  3. * view(*shape)                  修改张量的shape，共享内存，修改一个同时修改。
  4. * resize()                           类似于view
  5. * item                                返回标量
  6. * unsqueeze                     在指定维度增加一个1
  7. * squeeze                         在指定维度压缩一个1
  1. import torch
  2.  
  3. x = torch.randn(2,3)
  4.  
  5. print(x.size())
  6.  
  7. print("维度：" ,x.dim())
  8.  
  9. print("这里把矩阵变为3x2的矩阵：",x.view(3,2))
  10.  
  11. print("这里把x展为1维向量：", x.view(-1))
  12.  
  13. y=x.view(-1)
  14. z=torch.unsqueeze(y,0)
  15. print("没增加维度前：",y,"  的维度",y.size())
  16. print("增加一个维度:", z)
  17. print("z的维度：", z.size())
  18. print("z的个数：", z.numel())
  19. # 输出结果
  20. torch.Size([2, 3])
  21. 维度：2
  22. 这里把矩阵变为3x2的矩阵：tensor([[ 1.3014,  1.0249],
  23.         [ 0.8903, -0.4908],
  24.         [-0.3393,  0.7987]])
  25. 这里把x展为1维向量：tensor([ 1.3014,  1.0249,  0.8903, -0.4908, -0.3393,  0.7987])
  26. 没增加维度前：tensor([ 1.3014,  1.0249,  0.8903, -0.4908, -0.3393,  0.7987])   的维度 torch.Size([6])
  27. 增加一个维度: tensor([[ 1.3014,  1.0249,  0.8903, -0.4908, -0.3393,  0.7987]])
  28. z的维度：torch.Size([1, 6])
  29. z的个数：6

torch.view 与 torch.reshape 的异同

  1. reshape()可以由torch.reshape()或者torch.Tensor.reshape()调用；而view()只可以由torch.Tensor.view()调用

  2. 新的size必须与原来的size与stride兼容，否则，在view之前必须调用contiguous()方法

  3. 同样返回数据量相同的但形状不同的Tensor，若满足view条件，则不会copy，若不满足，就copy

  4. 只想重塑，就使用torch.reshape，如果考虑内存并共享，就用torch.view

    2.4.4 索引操作

常用选择操作的函数

  1. * index_select(input,dim,index)   在指定维度上选择列或者行
  2. * nonzero(input)                          获取非0元素的下标
  3. * masked_select(input,mask)     使用二元值进行选择
  4. * gather(input,dim,index)        指定维度选择数据，输出形状与index一致
  5. * scatter_(input,dim,index,src)    gather的反操作，根据指定索引补充数据
  1. import torch# 设置一个随机种子torch.manual_seed(100)# print(torch.manual_seed(100))x = torch.randn(2,3)
  2. print(x)# 索引获取第一行所有数据x[0,:]
  3. print(x[0,:])# 获取最后一列的数据x[:,-1]
  4. print(x[:,-1])# 生成是否大于0的张量mask=x>0print(mask)# 获取大于0的值torch.masked_select(x,mask)
  5. print(torch.masked_select(x,mask))# 获取非0下标，即行、列的索引torch.nonzero(mask)
  6. print(torch.nonzero(mask))# 获取指定索引对应的值，输出根据以下规则得到# out[i][j] = input[index[i][j][j]]  # 如果 if dim == 0# out[i][j] = input[i][index[i][j]]  # 如果 if dim == 1index = torch.LongTensor([[0,1,1]])
  7. print(index)
  8. torch.gather(x,0,index)
  9. index=torch.LongTensor([[0,1,1],[1,1,1]])
  10. a = torch.gather(x,1,index)
  11. print("a: ",a)# 把a的值返回到2x3的0矩阵中z = torch.zeros(2,3)
  12. z.scatter_(1,index,a)# 输出结果tensor([[ 0.3607, -0.2859, -0.3938],
  13.         [ 0.2429, -1.3833, -2.3134]])
  14. tensor([ 0.3607, -0.2859, -0.3938])
  15. tensor([-0.3938, -2.3134])
  16. tensor([[ True, False, False],
  17.         [ True, False, False]])
  18. tensor([0.3607, 0.2429])
  19. tensor([[0, 0],
  20.         [1, 0]])
  21. tensor([[0, 1, 1]])
  22. a:  tensor([[ 0.3607, -0.2859, -0.2859],
  23.         [-1.3833, -1.3833, -1.3833]])
  24. Out[25]:
  25. tensor([[ 0.3607, -0.2859,  0.0000],
  26.         [ 0.0000, -1.3833,  0.0000]])

2.4.5 广播机制

  1. import torch
  2. import numpy as np
  3. A = np.arange(0,40,10).reshape(4,1)
  4. B = np.arange(0,3)
  5. A1 = torch.from_numpy(A)   #形状4x1
  6. B1 = torch.from_numpy(B)   #形状3
  7. #自动广播
  8. C=A1+B1
  9. #也可以根据广播机制手动配置
  10. # B1要与A1看齐，变成（1,3）
  11. B2=B1.unsqueeze(0)
  12. A2=A1.expand(4,3)
  13. B3=B2.expand(4,3)
  14. C1=A2+B3
  15. print("A1:",A1)
  16. print("B1:",B1)
  17. print("C:",C)
  18. print("B2:",B2)
  19. print("A2:",A2)
  20. print("B3:",B3)
  21. print("C1:",C1)
  22. # 输出结果
  23. A1: tensor([[ 0],
  24.         [10],
  25.         [20],
  26.         [30]], dtype=torch.int32)
  27. B1: tensor([0, 1, 2], dtype=torch.int32)
  28. C: tensor([[ 0,  1,  2],
  29.         [10, 11, 12],
  30.         [20, 21, 22],
  31.         [30, 31, 32]], dtype=torch.int32)
  32. B2: tensor([[0, 1, 2]], dtype=torch.int32)
  33. A2: tensor([[ 0,  0,  0],
  34.         [10, 10, 10],
  35.         [20, 20, 20],
  36.         [30, 30, 30]], dtype=torch.int32)
  37. B3: tensor([[0, 1, 2],
  38.         [0, 1, 2],
  39.         [0, 1, 2],
  40.         [0, 1, 2]], dtype=torch.int32)
  41. C1: tensor([[ 0,  1,  2],
  42.         [10, 11, 12],
  43.         [20, 21, 22],
  44.         [30, 31, 32]], dtype=torch.int32)

2.4.6 逐元素操作

常见的逐元素操作

  1. * abs   add                                     绝对值，加法
  2. * addcdiv(t,v,t1,t2)                        t1与t2按元素除后，乘v加t
  3. * addcmul(t,v,t1,t2)                       t1与t2按元素乘后，乘v加t
  4. * ceil   floor                                  向上取整；向下取整
  5. * clamp(t, min , max)                    将张量元素限制在指定区间
  6. * exp   log   pow                            指数，对数，幂
  7. * mul(  或  *  )   neg                       逐元素乘法，取反
  8. * sigmoid   tanh    softmax            激活函数
  9. * sign   sqrt                                   取符号，开根号
  1. import torch
  2. t = torch.randn(1,3)
  3. t1 = torch.randn(3,1)
  4. t2 = torch.randn(1,3)
  5. # t+0.1*(t1/t2)
  6. a = torch.addcdiv(t, 0.1, t1, t2)
  7. #计算sigmoid
  8. b = torch.sigmoid(t)
  9. # 将t限制在【0,1】之间
  10. c = torch.clamp(t,0,1)
  11. #t+2进行直接运算
  12. t.add_(2)
  13. print("t: ",t)
  14. print("t1: ",t1)
  15. print("t2: ",t2)
  16. print("a: ",a)
  17. print("b: ",b)
  18. print("c: ",c)
  19. # 结果
  20. t:  tensor([[1.7266, 2.0815, 3.4672]])
  21. t1:  tensor([[0.2309],
  22.         [0.3393],
  23.         [1.3639]])
  24. t2:  tensor([[-0.5414, -1.4628, -0.4191]])
  25. a:  tensor([[-0.3161,  0.0657,  1.4121],
  26.         [-0.3361,  0.0583,  1.3863],
  27.         [-0.5254, -0.0117,  1.1418]])
  28. b:  tensor([[0.4321, 0.5204, 0.8126]])
  29. c:  tensor([[0.0000, 0.0815, 1.0000]])

2.4.7 归并操作

常用的归并操作

  1. * cumprod(t,axis)        在指定维度上对t进行累积
  2. * cumsum                    对指定维度进行累加
  3. * dist（a,b,p=2）         返回a,b之间的p阶范数
  4. * mean   ;  median       平均值，中位数
  5. * std   var                    标准差       方差
  6. * norm(t,p=2)               返回t的p阶范数
  7. * prod(t)   sum(t)           返回所有元素的积，和
  1. import torch
  2. a=torch.linspace(0,10,6)
  3. #使用view变为2x3矩阵
  4. a=a.view((2,3))
  5. print("a: ",a)
  6. # 沿着y轴方向累加，dim=0
  7. b=a.sum(dim=0)
  8. print("b: ",b)
  9. # 沿着y轴方向累加，dim=0,并保留含1的维度
  10. b=a.sum(dim=0,keepdim=True)
  11. print("b: ",b)
  12. # 结果
  13. a:  tensor([[ 0.,  2.,  4.],
  14.         [ 6.,  8., 10.]])
  15. b:  tensor([ 6., 10., 14.])
  16. b:  tensor([[ 6., 10., 14.]])

2.4.8 比较操作

常用的比较函数

  1. * eq                                    是否相等
  2. * equal                               是否相同的shape和值
  3. * ge  /  le  /  gt  /  lt             大于、小于、大于等于、小于等于
  4. * max  /  min  (t,axis)         返回最值，指定axis返回下标
  5. * topk(t,k,axis)                   在指定维度上取最高的k个值
  1. import torch
  2. x=torch.linspace(0,10,6).view(2,3)
  3. print(torch.max(x))
  4. print(torch.max(x,dim=0))
  5. print(torch.topk(x,1,dim=0))
  6. # 结果
  7. tensor([[ 0.,  2.,  4.],
  8.         [ 6.,  8., 10.]])
  9. tensor(10.)
  10. torch.return_types.max(
  11. values=tensor([ 6.,  8., 10.]),
  12. indices=tensor([1, 1, 1]))
  13. torch.return_types.topk(
  14. values=tensor([[ 6.,  8., 10.]]),
  15. indices=tensor([[1, 1, 1]]))

2.4.9 矩阵操作

常用的矩阵函数

  1. * dot(t1,t2)                                                       计算内积
  2. * mm(mat1,mat2)    bmm(batch1,batch2)       计算矩阵乘积，3D矩阵
  3. * mv(t1,v1)                                                      计算矩阵与向量乘法
  4. * t                                                                    转置
  5. * svd(t)                                                             计算SVD
  1. import torch
  2. a=torch.tensor([2,3])
  3. b=torch.tensor([3,4])
  4. print(torch.dot(a,b))
  5. x=torch.randint(10,(2,3))
  6. print(x)
  7. y=torch.randint(6,(3,4))
  8. print(y)
  9. print(torch.mm(x,y))
  10. x=torch.randint(10,(2,2,3))
  11. print(x)
  12. y=torch.randint(6,(2,3,4))
  13. print(y)
  14. print(torch.bmm(x,y))
  15. #结果
  16. tensor(18)
  17. tensor([[1, 1, 1],
  18.         [3, 1, 9]])
  19. tensor([[1, 4, 4, 5],
  20.         [1, 5, 2, 4],
  21.         [2, 0, 3, 3]])
  22. tensor([[ 4,  9,  9, 12],
  23.         [22, 17, 41, 46]])
  24. tensor([[[0, 9, 3],
  25.          [7, 1, 4]],
  26.         [[9, 6, 3],
  27.          [2, 0, 1]]])
  28. tensor([[[0, 5, 1, 3],
  29.          [2, 4, 3, 1],
  30.          [5, 2, 1, 1]],
  31.         [[4, 3, 0, 0],
  32.          [4, 5, 0, 4],
  33.          [0, 0, 3, 3]]])
  34. tensor([[[33, 42, 30, 12],
  35.          [22, 47, 14, 26]],
  36.         [[60, 57,  9, 33],
  37.          [ 8,  6,  3,  3]]])

2.4.10 PyTorch与Numpy比较

PyTorch与Numpy函数对照表


np.ndarry([3.2,4.3],dtype=np.float16)torch.tensor([3.2,4.3], dtype=torch.float16

x.copy()x.clone()

np.dottorch.mm

x.ndimx.dim

x.sizex.nelement()

x.reshapex.reshape,x.view

x.flattenx.view(-1)

np.floor(x)torch.floor(x), x.floor()

np.lessx.lt

np.random.seedtorch.manual_seed

2.5 Tensor与Autograd

2.5.1 自动求导的要点

  1. 创建叶子节点的Tensor，使用requires_grad指定是否需要对其进行操作

  2. 可以利用requiresgrad()方法修改Tensor的requires_grad属性。可以调用  .detach()或者 with torch.no_grad()

  3. 自动赋予grad_fn属性，表示梯度函数。

  4. 执行backward()函数后，保存到grad属性中了。计算完成，非叶子节点梯度会自动释放

  5. backward()函数接收参数，维度相同。

  6. 反向传播的中间缓存会被清空，如果需要多次反向传播，需指定backward中的retain_graph=True  多次反向传播时，梯度累加

  7. 非叶子节点的梯度backward 调用后即被清空

  8. 用 torch.no_grad()包裹代码块形式阻止autograd去追踪那些标记为.requesgrad=True的张量历史记录

    2.5.2 计算图

表达式z=wx+b

可以写成：y=wx    z=y+b

x,w,b为变量；y,z是计算得到的变量，不是叶子节点

根据链式法则计算的

  • z对x求导为w

  • z对w求导为x

  • z对b求导为1

    2.5.3 标量反向传播

主要步骤如下：

  1. 定义叶子节点及算子节点

  2. 查看叶子节点、非叶子节点的其他属性

  3. 自动求导，实现梯度方向传播，也就是梯度的反向传播

分步进行展示

（1）定义叶子节点及算子节点

  1. import torch
  2. # 定义输入张量x
  3. x=torch.Tensor([2])
  4. # 初始化权重参数w,偏移量b，并设置require_grad属性为True
  5. w=torch.randn(1,requires_grad=True)
  6. b=torch.randn(1,requires_grad=True)
  7. # 实现前向传播
  8. y=torch.mul(w,x)   # 等价于w*x
  9. z=torch.add(y,b)   # 等价于y+b
  10. # 查看x,w,b叶子节点的requires_grad属性
  11. print("x,w,b叶子节点的requires_grad属性分别为：{}，{}，{}".format(x.requires_grad,w.requires_grad,b.requires_grad))

运行结果：

x,w,b叶子节点的requires_grad属性分别为：False，True，True

（2）查看叶子节点、非叶子节点的其他属性

  1. # 查看非叶子节点的requires_grad属性
  2. print("y, z的requires_grad属性分别为：{}，{}".format(y.requires_grad,z.requires_grad))
  3. # 查看各节点是否为叶子节点
  4. print("x, w, b, y, z是否为叶子节点：{}，{}，{}，{}，{}".format(x.is_leaf,w.is_leaf,b.is_leaf,y.is_leaf,z.is_leaf))
  5. # 查看叶子节点的grad_fn属性
  6. print("x, w, b的 grad_fn属性：{}，{}，{}".format(x.grad_fn,w.grad_fn,b.grad_fn))
  7. # 查看非叶子节点的grad_fn属性
  8. print("y, z是否为叶子节点：{}，{}".format(y.grad_fn,z.grad_fn))

运行结果：

  1. y, z的requires_grad属性分别为：True，True
  2. x, w, b, y, z是否为叶子节点：True，True，True，False，False
  3. x, w, b的 grad_fn属性：None，None，None
  4. y, z是否为叶子节点：<MulBackward0 object at 0x00000295C920E948>，<AddBackward0 object at 0x00000295C920EA48>

（3）自动求导，实现梯度方向传播，也就是梯度的反向传播

  1. # 基于张量z进行求导，执行backward后计算图会自动清空
  2. z.backward()
  3. # 如果需要多次使用backward，需要修改参数为retain_graph=True，此时梯度累加
  4. # z.backward(retain_graph=True)
  5. # 查看叶子节点的梯度，x是叶子节点但是无需求导，故梯度为None
  6. print("参数w, b，x的梯度分别为：{},{},{}".format(w.grad,b.grad,x.grad))
  7. # 非叶子节点的梯度，执行backward后会自动清空
  8. print("非叶子节点y, z的梯度分别为：{},{}".format(y.grad,z.grad))

运行结果：

  1. 参数w, b，x的梯度分别为：tensor([2.]),tensor([1.]),None
  2. 非叶子节点y, z的梯度分别为：None,None

2.5.4 非标量的反向传播

张量对张量的求导转换成标量对张量的求导

backward函数的格式

backward(gradient=None, retain_graph=None, create_graph=False)

举例：

  1. # (1)定义叶子节点及计算节点
  2. import torch
  3. # 定义叶子节点张量x，形状为1x2
  4. x = torch.tensor([[2, 3]], dtype=torch.float, requires_grad=True)
  5. # 初始化雅可比矩阵
  6. J = torch.zeros(2,2)
  7. # 初始化目标张量，形状1x2
  8. y = torch.zeros(1,2)
  9. # 定义y与x之间的映射关系
  10. # y1=x1**2 + 3*x2, y2=x2**2 + 2*x1
  11. y[0, 0] = x[0, 0]**2+3*x[0, 1]
  12. y[0, 1] = x[0, 1]**2+2*x[0, 0]
  13. # 首先让v=(1,0)得到y1对x的梯度
  14. # 然后让v=(0,1)得到y2对x的梯度
  15. # 需要重复使用backward(),所以设置参数retain_graph=True
  16. # 生成y1对x的梯度
  17. y.backward(torch.Tensor([[1,0]]),retain_graph=True)
  18. J[0]=x.grad
  19. # 梯度是累加的，所以需要对x的梯度清零
  20. x.grad = torch.zeros_like(x.grad)
  21. # 生成y2对x的梯度
  22. y.backward(torch.Tensor([[0,1]]))
  23. J[1]=x.grad
  24. # 显示雅克比矩阵的值
  25. print(J)

运行结果：

  1. tensor([[4., 3.],
  2.         [2., 6.]])

2.6 使用Numpy实现机器学习

给出一个数组x，基于表达式y=3x^2+2，加上一些噪声数据到达另一组数据y

构建一个机器学学模型，学习y=wx^2+b中的2个参数，w和b，利用x，y数据为训练数据

  1. ## （1）导入所需要的库
  2. # -*- coding : utf-8 -*-
  3. import numpy as np
  4. %matplotlib inline
  5. from matplotlib import pyplot as plt
  6. ## （2）生成随机数据x及目标y
  7. # 设置随机种子，生成同一份数据，方便多种方法比较
  8. np.random.seed(100)
  9. x = np.linspace(-1,1,100).reshape(100,1)
  10. y = 3*np.power(x,2) + 2 + 0.2*np.random.rand(x.size).reshape(100,1)
  11. ## (3)查看x,y数据分布情况
  12. plt.scatter(x,y)
  13. plt.show()
  14. ## (4)初始化权重参数
  15. w1 = np.random.rand(1,1)
  16. b1 = np.random.rand(1,1)
  17. ## （5）训练模型
  18. lr =0.001  # 学习率
  19. for i in range(800):
  20.     # 前向传播
  21.     y_pred = np.power(x,2)*w1+b1
  22.     # 定义损失函数
  23.     loss = 0.5 * (y_pred - y) **2
  24.     loss = loss.sum
  25.     # 计算梯度
  26.     grad_w = np.sum((y_pred - y)*np.power(x,2))
  27.     grad_b = np.sum(y_pred - y)
  28.     # 使用梯度下降法，使得loss最小
  29.     w1 -= lr * grad_w
  30.     b1 -= lr * grad_b
  31. ## 可视化结果
  32. plt.plot(x, y_pred, 'r-', label='predict')
  33. plt.scatter(x,y,color='blue',marker='o',label='true')
  34. plt.xlim(-1,1)
  35. plt.ylim(2,6)
  36. plt.legend()
  37. plt.show()
  38. print(w1,b1)

       

2.7 使用Tensor及Autograd实现机器学习

  1. # （1） 导入所需要的库
  2. import torch as t
  3. %matplotlib inline
  4. from matplotlib import pyplot as plt
  5. # (2)生成训练数据，并可视化数据分布情况
  6. t.manual_seed(100)
  7. dtype=t.float
  8. # 生成x坐标数据，x为tensor，需要把x的形状转换为100x1
  9. x = t.unsqueeze(t.linspace(-1,1,100),dim=1)
  10. # 生成y坐标数据，y为tensor，形状为100x1，加上一些噪声
  11. y = 3*x.pow(2)+ 2 + 0.2*t.rand(x.size())
  12.  
  13. # 画图，将tensor数据转换为numpy数据
  14. plt.scatter(x.numpy(),y.numpy())
  15. plt.show()
  16. # (3)初始化权重
  17. # 随机初始化参数，w,b需要学习，所以设定requires_grad=True
  18. w = t.randn(1,1,dtype=dtype,requires_grad=True)
  19. b = t.zeros(1,1,dtype=dtype,requires_grad=True)
  20. # (4)训练模型
  21. lr = 0.001 # 学习率
  22. for ii in range(800):
  23.     # 前向传播，定义损失函数
  24.     y_pred = x.pow(2).mm(w) + b
  25.     loss = 0.5 * (y_pred - y) **2
  26.     loss = loss.sum()
  27.  
  28.     # 自动计算梯度
  29.     loss.backward()
  30.  
  31.     # 手动更新参数，使用torch.no_grad(),使上下文切断自动求导计算
  32.     with t.no_grad():
  33.         w -= lr * w.grad
  34.         b -= lr * b.grad
  35.  
  36.     # 梯度清零
  37.         w.grad.zero_()
  38.         b.grad.zero_()
  39.  
  40. # (5)可视化训练结果
  41. plt.plot(x.numpy(), y_pred.detach().numpy(), 'r-', label='predict')
  42. plt.scatter(x.numpy(),y.numpy(),color='blue',marker='o',label='true')
  43. plt.xlim(-1,1)
  44. plt.ylim(2,6)
  45. plt.legend()
  46. plt.show()
  47. print(w,b)

       

end

这是我的私人微信，还有少量坑位，可与相关学者研究人员交流学习 

目前开设有人工智能、机器学习、计算机视觉、自动驾驶（含SLAM）、Python、求职面经、综合交流群扫描添加CV联盟微信拉你进群，备注：CV联盟

王博的公众号，欢迎关注，干货多多

王博的系列手推笔记（附高清PDF下载）：

博士笔记 | 周志华《机器学习》手推笔记第一章思维导图

博士笔记 | 周志华《机器学习》手推笔记第二章“模型评估与选择”

博士笔记 | 周志华《机器学习》手推笔记第三章“线性模型”

博士笔记 | 周志华《机器学习》手推笔记第四章“决策树”

博士笔记 | 周志华《机器学习》手推笔记第五章“神经网络”

博士笔记 | 周志华《机器学习》手推笔记第六章支持向量机（上）

博士笔记 | 周志华《机器学习》手推笔记第六章支持向量机（下）

博士笔记 | 周志华《机器学习》手推笔记第七章贝叶斯分类（上）

博士笔记 | 周志华《机器学习》手推笔记第七章贝叶斯分类（下）

博士笔记 | 周志华《机器学习》手推笔记第八章（上）

博士笔记 | 周志华《机器学习》手推笔记第八章（下）

博士笔记 | 周志华《机器学习》手推笔记第九章

点个在看支持一下吧

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

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

  

闽ICP备14008679号