总结 | 深度学习之Pytorch入门教程

目录

一、整体学习的建议

    1.1 如何成为Pytorch大神?

1.2 如何读Github代码?

1.3 代码能力太弱怎么办?

二、Pytorch与TensorFlow概述

   2.1 什么是Pytorch?

2.1.1 Pytorch两个核心模块

2.1.2 Pytorch可视化:Visdom

2.1.3 Pytorch的优缺点

2.2 什么是TensorFlow

2.2.1 TensorFlow两个核心模块

2.2.2 TensorFlow可视化:TensorBoard

2.2.3 TensorFlow的优缺点

2.3 Pytorch和TensorFlow对比

三、Pytorch的一些简单命令

四、实现两层神经网络

4.1 如何用numpy实现两层神经网络

4.2 如何用torch实现两层神经网络

4.3 简单的autograd

如何使用autograd简化上面的两层神经网络?

最后pytorch的简单代码

五、Pytorch常用库

5.1 Pytorch:nn

5.2 Pytorch:optim

5.3 Pytorch:nn Module


 (本文笔记pdf版本可在【人工智能算法与Python大数据】后台回复8003 获取

一、整体学习的建议

    1.1 如何成为Pytorch大神?

  • 打好深度学习基础

  • 学习Pytorch的官方tutorial

  • 打开Github,多看看教程

  • 使用 https://discuss.pytorch.org, 阅读文档

  • 跑代码,项目,论文代码

  • 复现,实现模型,自己创造

    1.2 如何读Github代码?

  1. 首先读简单的代码,比如三四个文件

  2. 然后十个文件

  3. 然后多个文件夹

  4. 整体套路是一样的

    1.3 代码能力太弱怎么办?

  • 最简单的办法就行训练

  • 抄代码,抄个100行,然后再写,再抄

  • 刚开始会不理解,后面要思考为什么这么写

  • 写代码的时候不要反复重复!Repeat no!

    二、Pytorch与TensorFlow概述

   2.1 什么是Pytorch?

  • Facebook开源,2017年,论文《PyTorch 中的自动微分》,地址:https://openreview.net/pdf?id=BJJsrmfCZ

  • 类似于Numpy,可以使用GPU,运行在CUDA上

  • PyTorch框架和Python语言的整合更加紧密

  • Pytorch动态图内置,可以定义深度学习模型,可灵活的进行训练和应用

  • 分布式训练并行化时,利用Python对异步执行的本地支持

    2.1.1 Pytorch两个核心模块

  1. 计算图,按照需求动态构建,图会随着执行过程而改变

  2. Autograd,执行动态图的自动微分

    2.1.2 Pytorch可视化:Visdom

  • 管理整体环境

  • 处理回调

  • 绘制图表细节

    2.1.3 Pytorch的优缺点

优点:

  • 类似Python的代码

  • 动态图

  • 轻松编辑

  • 良好的文档和社区支持

  • 开源

  • 很多项目都在使用

缺点:

  • 可视化需要第三方

  • 生产部署需要使用API服务器

    2.2 什么是TensorFlow

  • 谷歌开源,2015年,论文《TensorFlow:异构分布式系统上的大规模机器学习》,地址:http://download.tensorflow.org/paper/whitepaper2015.pdf

  • 使用GPU增强训练,使用的是内置的GPU进行加速

  • 分布式训练并行化时,必须手动编写代码,并微调每个操作

  • 使用TensorFlow Fold库实现动态图

  • 可实现并行化或依赖驱动式调度,训练更快更有效率

    2.2.1 TensorFlow两个核心模块

  1. 一个用于定义计算图以及在各种不同硬件上执行这些图的运行时间的软件库

  2. 一个计算图,计算图是以静态方式定义。与外部通信通过tf.Sessionobject和tf.Placeholder

    2.2.2 TensorFlow可视化:TensorBoard

  • 分析程序

  • 展示数据(图像,文本,音频)

  • 可视化计算图的操作和层数信息

  • 跟踪和实时可视化损失和准确度等相关指标

  • 查看权重、偏差、张量等随时间变化的直方图

    2.2.3 TensorFlow的优缺点

优点:

  • 简单的内置高级API

  • 使用TensorBoard可视化训练

  • 通过TensorFlow serving容易实现生产部署

  • 很容易的移动平台支持

  • 开源

  • 良好的文档和社区支持

缺点:

  • 静态图

  • 调试方法

  • 难以快速修改

    2.3 Pytorch和TensorFlow对比

1.学术界PyTorch已经全面超越TensorFlow,上手快,容易实现,验证想法

2.工业界TensorFlow仍然广泛应用,GPU部署方便

三、Pytorch的一些简单命令

第一步,导入torch:

import torch

构造一个未被初始化的3x5的矩阵

x = torch.empty(3,5)
x

生成一个随机初始化的3x5矩阵

x = torch.rand(3,5)
x

生成一个全部为0的矩阵

x = torch.zeros(3,5)
x
x.dtype
torch.float32

生成一个全部为0的矩阵,long的矩阵

x = torch.zeros(3,5,dtype = torch.long)
x
x.dtype
torch.int64
# 或者 x = torch.zeros(3,5).long()

直接通过数据构建tensor

x = torch.tensor([1.2,4])
x
tensor([1.2000,4.0000])

也可以通过已有tensor构建一个新的tensor

x = x.new_ones(3,5)
# 或者改变类型 x = x.new_ones(3,5,dtype=torch.double)

构建一个和上一个形状相同的tensor

x = torch.randn_like(x, dtype=torch.float)
x

得到tensor的形状

x.shape
torch.Size([3,5])

加法准则:

x + y
torch.add(x,y)
result = torch.empty(3,5)
torch.add(x,y, out = result)
result
# 效果与下面类似 result = x + y

in-place加法

注意,任何in-place的运算都会以结尾,比如x.copy(y) ,   x.t_()  ,这些都会改变x

y.add_(x)
y
# 注意,这里加了下划线,就把y直接进行更改了,效果等价于 y=y+x

类似于Numpy的索引在Pytorch 的 tensor上面都可以使用,类比matlab

x[1:,1:]

Resizing,想要resize、reshape一个tensor,可以使用torch.view

x = torch.randn(4,4)
y = x.view(16)
y = x.view(2,8)
# 也可以用-1代表其中一个,它会自动计算 y = x.view(2,-1)和 x.view(2,8)功能类似

dir(x)可以看看x包含哪些功能

data
grad

怎么使用?

x.data
x.grad
x.item 把tensor变成数字

Numpy和tensor之间的相互转换

a = tensor([1,1,1,1,1])
b = a.numpy()
b
array([1.,1.,1.,1.,1.], dtype=float32)

注意,这里a和b是共享空间的,其中一个变,整体都会变
把Numpy array 转换成 Torch Tensor

import numpy as np
a = np.ones(5)
b = torch.from_numpy(a)
b

如果我们有GPU,可以转换为 CUDA Tensors

if torch.cuda.is_available()    device = torch.device("cuda")    y = torch.ones_like(x, device=device)    x = x.to(device)    z = x + y    # 注意,这里是GPU的    print(z)    # 转换成CPU进行输出的话    print(z.to("cpu", torch.double))

注意,如果是GPU的tensor,是没办法直接用.data这类操作,必须先转换再操作

y.cpu().data.numpy()

numpy是CPU的库,并没有GPU的库,所以如果想使用numpy,但是你默认GPU产生的是tensor

四、实现两层神经网络

4.1 如何用numpy实现两层神经网络

一个全连接ReLU神经网络,一个隐藏层,没有bias。用来从x预测y,使用L2 Loss。

# 定义一些基本的信息,64个输入,每个输入是1000维,hidden是100维,输出是10维 N, D_in, H, D_out = 64, 1000, 100, 10 # 随机创建一些训练数据 # x是64个1000维,x是64x1000矩阵 # y是64个10维,y是64x10矩阵 x = np.random.randn(N, D_in)y = np.random.randn(N, D_out)# 随机初始化权重 # w1是1000个100维,w1是1000x100矩阵 # w2是100个10维,w2是100x10矩阵 w1 = np.random.randn(D_in, H)w2 = np.random.randn(H, D_out)learning_rate = 1e-6  for t in range(500):     # 前向传播,h是64x1000x1000x100=64x100     # h_relu是看哪个激活了,还是64x100     # y_pred是64x100x100x10=64x10     h = x.dot(w1) # N * H     h_relu = np.maximum(h, 0) # N * H     y_pred = h_relu.dot(w2) # N * D_out     # compute loss     loss = np.square(y_pred - y).sum()     print(it, loss)     # Backward pass     # 计算梯度,链式法则,挨个求导相乘     grad_y_pred = 2.0 * (y_pred - y)     grad_w2 = h_relu.T.dot(grad_y_pred)     grad_h_relu = grad_y_pred.dot(w2.T)     grad_h = grad_h_relu.copy()     grad_h[h<0] = 0      grad_w1 = x.T.dot(grad_h)     # 更新w1和w2的权重     w1 -=learning_rate * grad_w1     w2 -=learning_rate * grad_w2

4.2 如何用torch实现两层神经网络

这里将numpy修改为pytorch做这件事

pytorch用的是tensors

# 定义一些基本的信息,64个输入,每个输入是1000维,hidden是100维,输出是10维 N, D_in, H, D_out = 64, 1000, 100, 10 # 随机创建一些训练数据 # x是64个1000维,x是64x1000矩阵 # y是64个10维,y是64x10矩阵 # np.random要改为torch x = torch.randn(N, D_in)y = torch.randn(N, D_out)# 随机初始化权重 # w1是1000个100维,w1是1000x100矩阵 # w2是100个10维,w2是100x10矩阵 w1 = torch.randn(D_in, H)w2 = torch.randn(H, D_out)learning_rate = 1e-6  for t in range(500):     # 前向传播,h是64x1000x1000x100=64x100     # h_relu是看哪个激活了,还是64x100     # y_pred是64x100x100x10=64x10     # .dot改为mm     h = x.mm(w1) # N * H     # maximum改为clamp,夹住     h_relu = h.clamp(min=0) # N * H     y_pred = h_relu.mm(w2) # N * D_out     # compute loss     # 求平方在这里也要改     # loss = np.square(y_pred - y).sum()     loss = (y_pred - y).pow(2).sum().item()     print(it, loss)     # Backward pass     # 计算梯度,链式法则,挨个求导相乘     grad_y_pred = 2.0 * (y_pred - y)     grad_w2 = h_relu.t().mm(grad_y_pred)     grad_h_relu = grad_y_pred.mm(w2.t())     grad_h = grad_h_relu.clone()     grad_h[h<0] = 0      grad_w1 = x.t().mm(grad_h)     # 更新w1和w2的权重     w1 -=learning_rate * grad_w1     w2 -=learning_rate * grad_w2

4.3 简单的autograd

x = torch.tensor(1., requires_grad=True)w = torch.tensor(2., requires_grad=True)b = torch.tensor(3., requires_grad=True)y = w*x + b  # y = 2*1 + 3y.backward()# dy/dw=xprint(w.grad)print(x.grad)print(b.grad)# 结果tensor(1.)tensor(2.)tensor(1 . )

如何使用autograd简化上面的两层神经网络?

# 定义一些基本的信息,64个输入,每个输入是1000维,hidden是100维,输出是10维 N, D_in, H, D_out = 64, 1000, 100, 10 # 随机创建一些训练数据 # x是64个1000维,x是64x1000矩阵 # y是64个10维,y是64x10矩阵 # np.random要改为torch x = torch.randn(N, D_in)y = torch.randn(N, D_out)# 随机初始化权重 # w1是1000个100维,w1是1000x100矩阵 # w2是100个10维,w2是100x10矩阵 w1 = torch.randn(D_in, H, requires_grad=True)w2 = torch.randn(H, D_out, requires_grad=True)learning_rate = 1e-6  for t in range(500):     # 前向传播,h是64x1000x1000x100=64x100     # h_relu是看哪个激活了,还是64x100     # y_pred是64x100x100x10=64x10     # .dot改为mm     # h = x.mm(w1) # N * H     # h_relu = h.clamp(min=0) # N * H     # y_pred = h_relu.mm(w2) # N * D_out     # 把上面三行合并为1行     y_pred =x.mm(w1).clamp(min=0).mm(w2)     # compute loss     # 求平方在这里也要改     loss = (y_pred - y).pow(2).sum()  # 这是计算图     print(it, loss.item())     # Backward pass     # 计算梯度,链式法则,挨个求导相乘     # grad_y_pred = 2.0 * (y_pred - y)     # grad_w2 = h_relu.t().mm(grad_y_pred)     # grad_h_relu = grad_y_pred.mm(w2.t())     # grad_h = grad_h_relu.clone()     # grad_h[h<0] = 0     # grad_w1 = x.t().mm(grad_h)     # 这些求梯度的全部不要     loss.backward()     # 更新w1和w2的权重     # 为了减少内存,取消计算图的储存     with torch.no_grad():         w1 -=learning_rate * w1.grad         w2 -=learning_rate * w2.grad         # 每次清零         w1.grad.zero_()         w2.grad.zero_()

最后pytorch的简单代码

# 定义一些基本的信息,64个输入,每个输入是1000维,hidden是100维,输出是10维 N, D_in, H, D_out = 64, 1000, 100, 10 x = torch.randn(N, D_in)y = torch.randn(N, D_out)w1 = torch.randn(D_in, H, requires_grad=True)w2 = torch.randn(H, D_out, requires_grad=True)learning_rate = 1e-6  for t in range(500):     y_pred =x.mm(w1).clamp(min=0).mm(w2)     loss = (y_pred - y).pow(2).sum()  # 这是计算图     print(it, loss.item())     loss.backward()     # 更新w1和w2的权重     with torch.no_grad():         w1 -=learning_rate * w1.grad         w2 -=learning_rate * w2.grad         # 每次清零         w1.grad.zero_()         w2.grad.zero_()

五、Pytorch常用库

5.1 Pytorch:nn

使用pytorch:nn库来构建网络

使用Pytorch autograd 来构建计算图和计算梯度

import torch.nn as nn# 定义一些基本的信息,64个输入,每个输入是1000维,hidden是100维,输出是10维 N, D_in, H, D_out = 64, 1000, 100, 10 x = torch.randn(N, D_in)y = torch.randn(N, D_out)# 不用这么繁琐顶定义这个w1,w2 # w1 = torch.randn(D_in, H, requires_grad=True) # w2 = torch.randn(H, D_out, requires_grad=True) model = torch.nn.Sequential(    torch.nn.Linear(D_in,H),  #w_1 * x +b_1    torch.nn.ReLU();    torch.nn.Linear(H, D_out))# model = model.cuda() loss_fn = nn.MSELoss(reduction='sum')learning_rate = 1e-6  for t in range(500):     # y_pred =x.mm(w1).clamp(min=0).mm(w2)     y_pred = model(x)  # model.forward()     loss = loss_fn(y_pred,y)     print(it, loss.item())     model.zero_grad     loss.backward()     # 更新w1和w2的权重     with torch.no_grad():         for param in model.parameters():             param -= learning_rate * param.grad

 

初始化数据,可能影响训练效果 ,这里可对weight进行初始化

modelmodel[0].weight可能初始化问题会影响训练效果可在model和loss_fn中间加:torch.nn.init.normal_(model[0].weight) #第一层 torch.nn.init.normal_(model[2].weight) #第二层

5.2 Pytorch:optim

不用手动更新模型的weights,而是使用optim这个包来帮助我们更新参数

optim这个包提供了各种不同的模型优化方法,包括SGD+momentum,RMSProp,Adam等等

import torch.nn as nn# 定义一些基本的信息,64个输入,每个输入是1000维,hidden是100维,输出是10维 N, D_in, H, D_out = 64, 1000, 100, 10 x = torch.randn(N, D_in)y = torch.randn(N, D_out)# 不用这么繁琐顶定义这个w1,w2 # w1 = torch.randn(D_in, H, requires_grad=True) # w2 = torch.randn(H, D_out, requires_grad=True) model = torch.nn.Sequential(    torch.nn.Linear(D_in,H),  #w_1 * x +b_1    torch.nn.ReLU();    torch.nn.Linear(H, D_out))# model = model.cuda() loss_fn = nn.MSELoss(reduction='sum')learning_rate = 1e-4 optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)# 或者优化方法 # learning_rate = 1e-6 # optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) learning_rate = 1e-6  for t in range(500):     y_pred = model(x)  # model.forward()     loss = loss_fn(y_pred,y)     print(it, loss.item())     # 求导之前把数据清空     optimizer.zero_grad()     loss.backward()     # 更新w1和w2的权重     optimizer.step()

5.3 Pytorch:nn Module

import torch.nn as nn定义一些基本的信息,64个输入,每个输入是1000维,hidden是100维,输出是10维N, Din, H, D_out = 64, 1000, 100, 10x = torch.randn(N, D_in)y = torch.randn(N, D_out)class TwoLayerNet(torch.nn.Module):   def _init(self, Din, H, D_out):       super(TwoLayerNet, self)._init()    # 定义模型框架    self.linear1 = torch.nn.Linear(D_in, H, bias=False)    self.linear2 = torch.nn.Linear(H, D_out, bias=False)def forward(self, x)     # 定义前向传播    y_pred = self.linear2(self.linear1(x).clamp(min=0))    return y_pred         model = TwoLayerNet(D_in, H, D_out))loss_fn = nn.MSELoss(reduction=’sum’)learning_rate = 1e-4optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)learning_rate = 1e-6for t in range(500): y_pred = model(x)  # model.forward() loss = loss_fn(y_pred,y) print(it, loss.item()) # 求导之前把数据清空 optimizer.zero_grad() loss.backward() # 更新w1和w2的权重 optimizer.step()
【课程介绍】       Pytorch项目实战 垃圾分类 课程从实战的角度出发,基于真实数据集与实际业务需求,结合当下最新话题-垃圾分类问题为实际业务出发点,介绍最前沿的深度学习解决方案。     从0到1讲解如何场景业务分析、进行数据处理,模型训练与调优,最后进行测试与结果展示分析。全程实战操作,以最接地气的方式详解每一步流程与解决方案。     课程结合当下深度学习热门领域,尤其是基于facebook 开源分类神器ResNext101网络架构,对网络架构进行调整,以计算机视觉为核心讲解各大网络的应用于实战方法,适合快速入门与进阶提升。 【课程要求】 (1)开发环境:python版本:Python3.7+; torch 版本:1.2.0+; torchvision版本:0.4.0+ (2)开发工具:Pycharm; (3)学员基础:需要一定的Python基础,及深度学习基础; (4)学员收货:掌握最新科技图像分类关键技术; (5)学员资料:内含完整程序源码和数据集; (6)课程亮点:专题技术,完整案例,全程实战操作,徒手撸代码 【课程特色】 阵容强大 讲师一直从事与一线项目开发,高级算法专家,一直从事于图像、NLP、个性化推荐系统热门技术领域。 仅跟前沿 基于当前热门讨论话题:垃圾分类,课程采用学术届和工业届最新前沿技术知识要点。 实战为先 根据实际深度学习工业场景-垃圾分类,从产品需求、产品设计和方案设计、产品技术功能实现、模型上线部署。精心设计工业实战项目 保障效果 项目实战方向包含了学术届和工业届最前沿技术要点 项目包装简历优化 课程内垃圾分类图像实战项目完成后可以直接优化到简历中 【课程思维导图】 【课程实战案例】
©️2020 CSDN 皮肤主题: 酷酷鲨 设计师:CSDN官方博客 返回首页
实付 9.90元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值