特色

PyTorch 60 分钟入门教程:PyTorch 深度学习官方入门中文教程

什么是 PyTorch?

PyTorch 是一个基于 Python 的科学计算包,主要定位两类人群:

  • NumPy 的替代品,可以利用 GPU 的性能进行计算。
  • 深度学习研究平台拥有足够的灵活性和速度
  • 欢迎加入 pytorch china 微信群

开始学习

Tensors (张量)

Tensors 类似于 NumPy 的 ndarrays ,同时  Tensors 可以使用 GPU 进行计算。

from __future__ import print_function
import torch

构造一个5×3矩阵,不初始化。

x = torch.empty(5, 3)
print(x)

输出:

tensor(1.00000e-04 *
       [[-0.0000,  0.0000,  1.5135],
        [ 0.0000,  0.0000,  0.0000],
        [ 0.0000,  0.0000,  0.0000],
        [ 0.0000,  0.0000,  0.0000],
        [ 0.0000,  0.0000,  0.0000]])

 

构造一个随机初始化的矩阵:

x = torch.rand(5, 3)
print(x)

输出:

tensor([[ 0.6291,  0.2581,  0.6414],
        [ 0.9739,  0.8243,  0.2276],
        [ 0.4184,  0.1815,  0.5131],
        [ 0.5533,  0.5440,  0.0718],
        [ 0.2908,  0.1850,  0.5297]])

 

构造一个矩阵全为 0,而且数据类型是 long.

Construct a matrix filled zeros and of dtype long:

x = torch.zeros(5, 3, dtype=torch.long)
print(x)

输出:

tensor([[ 0,  0,  0],
        [ 0,  0,  0],
        [ 0,  0,  0],
        [ 0,  0,  0],
        [ 0,  0,  0]])

构造一个张量,直接使用数据:

x = torch.tensor([5.5, 3])
print(x)

输出:

tensor([ 5.5000,  3.0000])

创建一个 tensor 基于已经存在的 tensor。

x = x.new_ones(5, 3, dtype=torch.double)      
# new_* methods take in sizes
print(x)

x = torch.randn_like(x, dtype=torch.float)    
# override dtype!
print(x)                                      
# result has the same size

输出:

tensor([[ 1.,  1.,  1.],
        [ 1.,  1.,  1.],
        [ 1.,  1.,  1.],
        [ 1.,  1.,  1.],
        [ 1.,  1.,  1.]], dtype=torch.float64)
tensor([[-0.2183,  0.4477, -0.4053],
        [ 1.7353, -0.0048,  1.2177],
        [-1.1111,  1.0878,  0.9722],
        [-0.7771, -0.2174,  0.0412],
        [-2.1750,  1.3609, -0.3322]])

获取它的维度信息:

print(x.size())

输出:

torch.Size([5, 3])

注意

torch.Size  是一个元组,所以它支持左右的元组操作。

操作

在接下来的例子中,我们将会看到加法操作。

加法: 方式 1

y = torch.rand(5, 3)
print(x + y)

Out:

tensor([[-0.1859,  1.3970,  0.5236],
        [ 2.3854,  0.0707,  2.1970],
        [-0.3587,  1.2359,  1.8951],
        [-0.1189, -0.1376,  0.4647],
        [-1.8968,  2.0164,  0.1092]])

加法: 方式2

print(torch.add(x, y))

Out:

tensor([[-0.1859,  1.3970,  0.5236],
        [ 2.3854,  0.0707,  2.1970],
        [-0.3587,  1.2359,  1.8951],
        [-0.1189, -0.1376,  0.4647],
        [-1.8968,  2.0164,  0.1092]])

加法: 提供一个输出 tensor 作为参数

result = torch.empty(5, 3)
torch.add(x, y, out=result)
print(result)

Out:

tensor([[-0.1859,  1.3970,  0.5236],
        [ 2.3854,  0.0707,  2.1970],
        [-0.3587,  1.2359,  1.8951],
        [-0.1189, -0.1376,  0.4647],
        [-1.8968,  2.0164,  0.1092]])

加法: in-place

# adds x to y
y.add_(x)
print(y)

Out:

tensor([[-0.1859,  1.3970,  0.5236],
        [ 2.3854,  0.0707,  2.1970],
        [-0.3587,  1.2359,  1.8951],
        [-0.1189, -0.1376,  0.4647],
        [-1.8968,  2.0164,  0.1092]])

Note

注意

任何使张量会发生变化的操作都有一个前缀 ‘_’。例如:x.copy_(y)x.t_(), 将会改变 x.

你可以使用标准的  NumPy 类似的索引操作

print(x[:, 1])

Out:

tensor([ 0.4477, -0.0048,  1.0878, -0.2174,  1.3609])

改变大小:如果你想改变一个 tensor 的大小或者形状,你可以使用 torch.view:

x = torch.randn(4, 4)
y = x.view(16)
z = x.view(-1, 8)  # the size -1 is inferred from other dimensions
print(x.size(), y.size(), z.size())

Out:

torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])

如果你有一个元素 tensor ,使用 .item() 来获得这个 value 。

x = torch.randn(1)
print(x)
print(x.item())

Out:

tensor([ 0.9422])
0.9422121644020081

AI算法工程师学习路线总结之机器学习篇 | 硬货

AI算法工程师学习路线总结之机器学习篇 | 硬货

【磐创AI导读】本期是磐创AI联合七月在线平台推出的AI算法工程师系列进阶课程的第二部分——机器学习第九期,课程涵盖机器学习算法特征工程BAT工业级机器学习实战项目深度学习算法等内容,带大家由浅到深学习机器学习课程。同样针对已关注磐创AI的老友们,为大家争取到了6个课程免单券,以及大量的课程优惠券,具体参与形式详解文末“粉丝福利”。拉至文末可直接扫码进咨询群领取100G机器学习干货资源

 

1. 课程背景

  • 正在网上看视频的你,是否看了网上很多的视频,却始终迷迷糊糊、不成体系?

  • 正在看书自学的你,是否在学习过程中遇到了很多问题,但始终不得其解,而且还找不到人问,没有人快速给你解决?

  • 正在学校上课的你,是否对每个模型和算法都能说个大概,但却不知道它们在公司里是如何应用的,想一探究竟,却始终得不到答案?

  • 正在读研的你,是否因为导师强塞的方向和巨大的压力无法短期入门精通而焦虑万分?

  • 正在找工作的你,是否投了很多公司的简历(巴不得一上午投完所有招聘的公司),但投了之后,简历始终都是石沉大海、杳无音讯

  • 正在做机器学习工作的你,是否技术上遇到了瓶颈,对模型的选择/调优、特征工程等不够熟练,导致在团队中竞争力不够,从而升职加薪困难?

AI算法工程师学习路线总结之机器学习篇 | 硬货

因为机器学习是一门实战性极强的学科,所以看一个课程是否有真正的工业实战,一看讲师团队是否是公司里多年实际带队做机器学习的,二看教学理念/侧重。

第一方面,本课程的所有讲师均全部来自BAT + Google的一线技术大咖亲自授课,是真正工业人士授课的工业课程,帮助学员实际理解这些机器学习理论模型算法到底是如何应用在工业实践中的。

第二方面,如上所说,网上视频很多,但由于没有个性化的内容、辅导、答疑,导致不少初学者看再多视频,视频看再多次,都是迷迷糊糊、不成体系,故本课程一直维持着讲师助教组长高水准答疑,更首次新增作业和阶段考试,且作业和考试均一对一批改,更针对性的提供面试辅导、推荐就业,助力找/换工作和升职加薪

 

2. 课程介绍

七月在线《机器学习》系列的课程大纲一直在不断优化、内容案例不断升级,特别是课程服务不断提升,第九期在保证“来自真正工业实践,真正工业人士授课的工业课程,且侧重实战项目辅导,六大阶段、层层深入、直通ML的本质及其应用”的基础上,首次新增作业和考试的1v1批改,提供CPU&GPU双云平台和面试辅导,考试优秀者内推BAT、TMD等一线互联网公司

3. 课程特色

  • 来自真正工业实践,真正工业人士授课的工业课程,侧重实战项目辅导;

  • 提供CPU和GPU双云平台,作业和考试均1v1批改;(不但提供基于Jupyter Notebook定制的CPU云平台,方便在线实时编译作业;而且还全程提供已提前装好Tensorflow、Caffe、Mxnex等主流DL框架的GPU云实验平台)

  • 组织学员参加数据科学比赛和讨论

  • 提供面试辅导,就业推荐。

AI算法工程师学习路线总结之机器学习篇 | 硬货AI算法工程师学习路线总结之机器学习篇 | 硬货

4. 课程大纲

预习阶段 机器学习中的数学基础

微积分

l 知识点1: 微积分的基本概念

概率论

l 知识点1: 概率论简介

线性代数

l 知识点1: 线性代数基础

凸优化

l 知识点1: 凸优化简介

 

第一阶段 掌握基本模型 打开ML大门

第1课 回归问题与应用

l 知识点1: 线性回归

l 知识点2: logistic回归

l 知识点3: 梯度下降

l 知识点4: 实际工程海量数据下的logistic回归使用

l 实战项目: 分布拟合与回归、用LR分类与概率预测

l 实战项目: 用LR完成Kaggle比赛迈开第一步

第2课 决策树与树集成模型

l 知识点1: 不同类型的分类树模型

l 知识点2: 决策树回归

l 知识点3: 树模型过拟合与优化

l 知识点4: 使用随机森林进行数据分类

l 知识点5: Bagging

l 知识点6: 随机森林

l 实战项目: 信用卡欺诈检测

第3课 SVM

l 知识点1: 线性可分支持向量机、线性支持向量机

l 知识点2: 非线性支持向量机

l 知识点3: SMO

l 实战项目: 使用SVM进行数据分类

第4课 最大熵与EM算法(上)

l 知识点1: 熵、相对熵、信息增益

l 知识点2: 最大熵模型、IIS、GMM

 

第二阶段 重中之重 特征工程

第5课 机器学习中的特征工程处理

l 知识点1: 数据清洗、异常点处理

l 知识点2: 特征抽取、选择与组合策略

l 实战项目: 特征处理与特征选择模板

第6课 多算法组合与模型最优化

l 知识点1: 机器学习问题场景分析、算法选择

l 知识点2: 模型构建、模型性能分析与优化策略

l 实战项目: 构建模型组合策略工具与模板

第三阶段 工业实战 在实战中掌握一切

第7课 sklearn与机器学习实战

l 知识点1: sklearn板块介绍

l 知识点2: sklearn完成数据预处理与特征工程

l 知识点3: 建模流水线搭建

l 实战项目: 经典Titanic案例,商品销量预测案例等

第8课 高级工具xgboost/lightGBM与建模实战

l 知识点1: xgboost使用方法与高级功能

l 知识点2: lightGBM使用方法与高级功能

l 实战项目: Titanic与商品销量预测进阶,Kaggle案例实战

第9课 电商推荐系统

l 知识点1: 推荐系统与评估

l 知识点2: 基于内容的推荐

l 知识点3: 基于近邻的推荐–协同过滤

l 知识点4: 隐语义模型

l 实战项目: 从头手写搭建协同过滤与隐语义模型推荐

l 实战项目: 基于scikit-surprise的推荐系统

第10课 聚类

l 知识点1: K-means/K-Medoid

l 知识点2: 层次聚类

l 知识点3: GMM

实战项目: K-means/GMM代码实现和实际应用分析

第11课 聚类与推荐系统实战

l 实战项目: 基于用户聚类的推荐系统

l 实战项目: 推荐系统比赛案例(数据、代码)

 

第四阶段 高阶知识 深入机器学习

第12课 贝叶斯网络

l 知识点1: 朴素贝叶斯

l 知识点2: 有向分离

l 知识点3: 马尔科夫模型

第13课 隐马尔科夫模型HMM

l 知识点1: 概率计算问题

l 知识点2: 参数学习问题

l 知识点3: 状态预测问题

l 实战项目: 使用HMM进行中文分词

第14课 主题模型

l 知识点1: pLSA

l 知识点2: 共轭先验分布

l 知识点3: LDA

l 实战项目: 使用LDA进行文档分类

 

第五阶段 迈入深度学习 打开DL大门

第15课 神经网络初步

l 知识点1: 全连接神经网络

l 知识点2: 反向传播算法与权重优化

l 知识点3: 训练注意点

l 知识点4: 通用混合神经网络模板

l 实战项目: 手写神经网络解决非线性切分问题

第16课 卷积神经网络与计算机视觉

l 知识点1: 卷积神经网络结构分析

l 知识点2: 过拟合与随机失活

l 知识点3: 卷积神经网络理解

l 知识点4: 典型网络结构详解

l 实战项目: 利用ResNet与inception解决一般图像分类问题套路

第17课 循环神经网络与自然语言处理

l 知识点1: 循环神经网络

l 知识点2: 长时依赖问题与长短时记忆网络

l 知识点3: BPTT算法

l 实战项目: 利用循环神经网络生成文本作诗

第18课 深度学习实践

l知识点1: Caffe应用要点

l 知识点2: TensorFlow/Keras简介

l 实战项目: 用神经网络完成图像分类与特征提取

l 实战项目: 用Keras构建文本情感分析模型

 

5. 讲师团队

AI算法工程师学习路线总结之机器学习篇 | 硬货

寒小阳  著名电商搜索广告负责人

多年实战ML/DL/DM项目经验,专注海量数据上机器学习算法的应用与优化。做过推荐系统、NLP、点击率预测、图像识别等。讲课清晰易懂,擅长用实际数据、代码、案例说话,备受数千名学员好评。

AI算法工程师学习路线总结之机器学习篇 | 硬货

加号 原TypeScore首席数据科学家

曾师从Google DeepMind的领军人物Prof.Nando de Freitas主攻Deep Learning,牛津大学计算机系毕业。UiiTech创始人,原TypeScore首席数据科学家。现就职于伦敦某投资银行的金融创新实验室,专注金融行业的AI架构与大数据产品研发。

AI算法工程师学习路线总结之机器学习篇 | 硬货

张雨石  Google工程师

Google工程师,北航硕士毕业,对深度学习、计算机视觉和自然语言处理有着极大的热忱,CSDN博客上有多篇文章流传甚广。去Google之前,曾先后在腾讯、百度实习。

AI算法工程师学习路线总结之机器学习篇 | 硬货

Johnson  CMU计算机博士

熟练机器学习、统计与凸优化。曾工作于百度、谷歌等公司的AI实验室。更在AAAI/IJCAI/AISTATS等顶级会议上发表过多篇论文。

 

6. 上课方式

  • 七月在线官网课程录播(支持Windows、Mac、Pad等一切平台,无需安州任何额外软件);

  • 支持课程实时答疑、提供PPT、代码等课程资料,视频可反复学习,且有任何疑问可随时在课程群向老师提问

7. 适配岗位

注:薪资数据来源于拉勾网

  • 机器学习工程师

AI算法工程师学习路线总结之机器学习篇 | 硬货

8. 粉丝福利

针对已关注“磐创AI”公众号的粉丝,我们将推出以下四大福利:

福利一我们将送出6张《机器学习 第九期》程免单券,可直接扫描下方课程咨询二维码报名领取,数量有限,先到先得。

福利二关注“磐创AI”公众号,后台回复“0618”,即可免费获得机器学习 第九期课件,满满的都是干货。

福利三扫描下方二维码,备注“磐创粉丝”表明磐创粉丝身份,即可获得课程免费试听的机会,并在报名时享受一定额度的课程优惠券

福利四:七月在线平台2019年VIP会员关注”磐创AI”公众号,后台回复”我是锦鲤“参与抽奖。将在6月25日22:00点进行开奖,抽出一名幸运粉丝,获得价值3299元的七月在线平台VIP会员,可免费畅学七月在线平台的任意课程,并可想用GPU&CPU双云实验平台

另:针对近期迫切期望转岗或就业机器学习工程师的童鞋,推荐强度更大且线上+线下结合的ML集训营9详见:

https://www.julyedu.com/weekend/train9?v=m1)。详情可扫描下方二维码咨询。

10. 报名方式

 

AI算法工程师学习路线总结之机器学习篇 | 硬货

扫描上方二维码,备注“磐创粉丝”,进行咨询与报名

 

AI算法工程师学习路线总结之机器学习篇 | 硬货

扫描上方二维码,进微信咨询群

 

你也许还想

 AI算法工程师学习路线总结之Python篇

   干货|Python进阶系列学习笔记(一)

   干货|Python进阶系列学习笔记(二)

欢迎扫码关注:

AI算法工程师学习路线总结之机器学习篇 | 硬货

AI算法工程师学习路线总结之机器学习篇 | 硬货 点击下方 |  | 了解更多

AI算法工程师学习路线总结之Python篇 | 粉丝福利

AI算法工程师学习路线总结之Python篇 | 粉丝福利

【磐创AI导读】从本周开始,磐创AI将联合七月在线推出AI算法工程师系列进阶课程,课程内容将涵盖Python、机器学习、深度学习、自然语言处理、图像识别等多个方向,手把手带着大家进阶AI算法工程师。本周将推出系列课程的第一阶段《Python基础入门第三期》以及四篇干货Python课程笔记。另针对磐创AI的粉丝,我们将提供10个免费学习的名额,具体参与方式可见文末“粉丝福利”。


1. 课程介绍

该课程是在《Python基础升级版》的基础上,定位为有意向从事数据科学行业却受限于不了解Python语言的同学,而进一步优化后的课程。课程以Python开发环境搭建起步,后渐进至Python基础语法、Python函数基础、面向对象基础、文件操作等方方面面,最后以数据抓取、数学分析、数据处理、可视化以及机器学习任务收尾。使同学们不仅可以夯实Python的基础知识,还能快速过渡至数据科学项目。


2. 所需基础

本课程定位于从零起步学习Python的初学者,只要同学们有电脑操作的基础即可,当然有其它编程语言经验的同学更佳。


3. 课程特色

  • 从零起步:本课程是在之前Python基础升级课程的基础上,对Python部分投入更详尽的讲授,以帮助大家真正从零起步学习Python;

  • 实时答疑:我们建有针对课程的QQ学习交流,讲师助教组长共同答疑,保持着近乎实时的答疑响应率,确保及时解决同学们在学习中遇到的任何问题;

  • 应用外延:为服务于七月在线数据科学与机器学习方向的整体教研方向,本课程增加Pandas数据处理,数据可视化部分;

  • CPU云平台:作业考试实训都基于在线云平台,同学们只需要通过一个链接即可零配置入手Python学习环境。

AI算法工程师学习路线总结之Python篇 | 粉丝福利AI算法工程师学习路线总结之Python篇 | 粉丝福利


4. 九大项目

九大项目:为了让同学们学以致用,更好的巩固学习效果,提高实战技能,特精心设计九大课程。

AI算法工程师学习路线总结之Python篇 | 粉丝福利

5. 讲师团队

AI算法工程师学习路线总结之Python篇 | 粉丝福利

陈老师 量化自动交易技术专家

人大统计系数据挖掘与统计应用硕士,从事数据分析挖掘多年,开发过某金融公司量化自动交易系统。喜爱以数据去理解事物,擅长从零起步,一步步将复杂问题简单通俗阐述,备受广大学员欢迎。

AI算法工程师学习路线总结之Python篇 | 粉丝福利

林老师 原BAT高级技术专家

更早时期先后任职于微软、EMC等,从事过操作系统、数据库和云存储相关产品的研发。擅长Python数据分析、爬虫。曾多次作为面试官参与BAT/EMC校招面试与出题,擅长剖析leetcode经典题型、助人入门、提高。


6. 学习成果

  • 具备Python开发环境的搭建及使用能力;

  • 熟悉数据科学方向Python语言需掌握的知识点;

  • 有能力进行数据爬取,数据处理,数据可视化展示;

  • 完成一个简单的机器学习任务。


7. 适配岗位

注:薪资数据来源于拉勾网

  • 数据分析师

AI算法工程师学习路线总结之Python篇 | 粉丝福利

  • 爬虫工程师

AI算法工程师学习路线总结之Python篇 | 粉丝福利


8. 学员评价

《Python基础入门第三期》课程,自推出以来就受到了学员的认可,好评如潮,真正地做到了“用口碑说话”。


AI算法工程师学习路线总结之Python篇 | 粉丝福利AI算法工程师学习路线总结之Python篇 | 粉丝福利AI算法工程师学习路线总结之Python篇 | 粉丝福利


9. 粉丝福利

针对已关注“磐创AI”公众号的粉丝,我们将推出以下三大福利:

福利一免费学!免费学!免费学!文末参与留言,截止到6月14日18:00点,点赞排名前10位,我们将赠送本门课程的免单学习券;

福利二优惠券!优惠券!优惠券!对于前20位报名的小伙伴,我们将送出5折优惠券,折后价仅需50元!!!对于21-50位报名者,我们送出6.5折优惠券;51-100位,我们送出8折优惠券;100位以后的报名者送出9折优惠券!

福利三锦鲤!锦鲤!锦鲤!七月在线平台2019年VIP会员。关注”磐创AI“公众号,后台回复”七月锦鲤“参与,我们将在6月14日18:00点进行抽奖,抽出一名幸运粉丝,将获得价值3299元的七月在线平台VIP会员,可免费畅学七月在线平台的任意课程,并可想用GPU&CPU双云实验平台。

福利四送课件!送课件!送课件!关注“磐创AI”公众号,后台回复“Python基础入门课件”,即可免费获得课程课件,满满的都是干货。


10. 报名方式


AI算法工程师学习路线总结之Python篇 | 粉丝福利

扫描上方二维码,进行咨询与报名


接下来,将陆续推送四篇Python精品学习笔记,图文并茂(附代码演练)。敬请期待!


AI算法工程师学习路线总结之Python篇 | 粉丝福利 点击下方 |  | 免费试听

史上最全的PyTorch学习资源汇总

PyTorch学习教程、手册

  • PyTorch英文版官方手册:对于英文比较好的同学,非常推荐该PyTorch官方文档,一步步带你从入门到精通。该文档详细的介绍了从基础知识到如何使用PyTorch构建深层神经网络,以及PyTorch语法和一些高质量的案例。
  • PyTorch中文官方文档:阅读上述英文文档比较困难的同学也不要紧,我们为大家准备了比较官方的PyTorch中文文档,文档非常详细的介绍了各个函数,可作为一份PyTorch的速查宝典。
  • 比较偏算法实战的PyTorch代码教程:在github上有很高的star。建议大家在阅读本文档之前,先学习上述两个PyTorch基础教程。
  • 开源书籍:这是一本开源的书籍,目标是帮助那些希望和使用PyTorch进行深度学习开发和研究的朋友快速入门。但本文档不是内容不是很全,还在持续更新中。
  • 简单易上手的PyTorch中文文档:非常适合新手学习。该文档从介绍什么是PyTorch开始,到神经网络、PyTorch的安装,再到图像分类器、数据并行处理,非常详细的介绍了PyTorch的知识体系,适合新手的学习入门。该文档的官网:http://pytorchchina.com 。

PyTorch视频教程

  • B站PyTorch视频教程:首推的是B站中近期点击率非常高的一个PyTorch视频教程,虽然视频内容只有八集,但讲的深入浅出,十分精彩。只是没有中文字幕,小伙伴们是该练习一下英文了…
  • 国外视频教程:另外一个国外大佬的视频教程,在YouTube上有很高的点击率,也是纯英文的视频,有没有觉得外国的教学视频不管是多么复杂的问题都能讲的很形象很简单?
  • 莫烦:相信莫烦老师大家应该很熟了,他的Python、深度学习的系列视频在B站和YouTube上均有很高的点击率,该PyTorch视频教程也是去年刚出不久,推荐给新手朋友。
  • 101学院:人工智能101学院的PyTorch系列视频课程,讲的比较详细、覆盖的知识点也比较广,感兴趣的朋友可以试听一下。
  • 七月在线:最后,向大家推荐的是国内领先的人工智能教育平台——七月在线的PyTorch入门与实战系列课。课程虽然是收费课程,但课程包含PyTorch语法、深度学习基础、词向量基础、NLP和CV的项目应用、实战等,理论和实战相结合,确实比其它课程讲的更详细,推荐给大家。

NLP&PyTorch实战

  • Pytorch text:Torchtext是一个非常好用的库,可以帮助我们很好的解决文本的预处理问题。此github存储库包含两部分:
    • torchText.data:文本的通用数据加载器、抽象和迭代器(包括词汇和词向量)
    • torchText.datasets:通用NLP数据集的预训练加载程序 我们只需要通过pip install torchtext安装好torchtext后,便可以开始体验Torchtext 的种种便捷之处。
  • Pytorch-Seq2seq:Seq2seq是一个快速发展的领域,新技术和新框架经常在此发布。这个库是在PyTorch中实现的Seq2seq模型的框架,该框架为Seq2seq模型的训练和预测等都提供了模块化和可扩展的组件,此github项目是一个基础版本,目标是促进这些技术和应用程序的开发。
  • BERT NER:BERT是2018年google 提出来的预训练语言模型,自其诞生后打破了一系列的NLP任务,所以其在nlp的领域一直具有很重要的影响力。该github库是BERT的PyTorch版本,内置了很多强大的预训练模型,使用时非常方便、易上手。
  • Fairseq:Fairseq是一个序列建模工具包,允许研究人员和开发人员为翻译、总结、语言建模和其他文本生成任务训练自定义模型,它还提供了各种Seq2seq模型的参考实现。该github存储库包含有关入门、训练新模型、使用新模型和任务扩展Fairseq的说明,对该模型感兴趣的小伙伴可以点击上方链接学习。
  • Quick-nlp:Quick-nlp是一个深受fast.ai库启发的深入学习Nlp库。它遵循与Fastai相同的API,并对其进行了扩展,允许快速、轻松地运行NLP模型。
  • OpenNMT-py:这是OpenNMT的一个PyTorch实现,一个开放源码的神经网络机器翻译系统。它的设计是为了便于研究,尝试新的想法,以及在翻译,总结,图像到文本,形态学等许多领域中尝试新的想法。一些公司已经证明该代码可以用于实际的工业项目中,更多关于这个github的详细信息请参阅以上链接。

CV&PyTorch实战

  • pytorch vision:Torchvision是独立于pytorch的关于图像操作的一些方便工具库。主要包括:vision.datasets 、vision.models、vision.transforms、vision.utils 几个包,安装和使用都非常简单,感兴趣的小伙伴们可以参考以上链接。
  • OpenFacePytorch:此github库是OpenFace在Pytorch中的实现,代码要求输入的图像要与原始OpenFace相同的方式对齐和裁剪。
  • TorchCV:TorchCV是一个基于PyTorch的计算机视觉深度学习框架,支持大部分视觉任务训练和部署,此github库为大多数基于深度学习的CV问题提供源代码,对CV方向感兴趣的小伙伴还在等什么?
  • Pytorch-cnn-finetune:该github库是利用pytorch对预训练卷积神经网络进行微调,支持的架构和模型包括:ResNet 、DenseNet、Inception v3 、VGG、SqueezeNet 、AlexNet 等。
  • Pt-styletransfer:这个github项目是Pytorch中的神经风格转换,具体有以下几个需要注意的地方:
    • StyleTransferNet作为可由其他脚本导入的类;
    • 支持VGG(这是在PyTorch中提供预训练的VGG模型之前)
    • 可保存用于显示的中间样式和内容目标的功能
    • 可作为图像检查图矩阵的函数
    • 自动样式、内容和产品图像保存
    • 一段时间内损失的Matplotlib图和超参数记录,以跟踪有利的结果
  • Face-alignment:Face-alignment是一个用 pytorch 实现的 2D 和 3D 人脸对齐库,使用世界上最准确的面对齐网络从 Python 检测面部地标,能够在2D和3D坐标中检测点。该github库详细的介绍了使用Face-alignment进行人脸对齐的基本流程,欢迎感兴趣的同学学习。

PyTorch论文推荐

  • Google_evolution:该论文实现了实现了由Esteban Real等人提出的图像分类器大规模演化的结果网络。在实验之前,需要我们安装好PyTorch、 Scikit-learn以及下载好 CIFAR10 dataset数据集
  • PyTorch-value-iteration-networks:该论文基于作者最初的Theano实现和Abhishek Kumar的Tensoflow实现,包含了在PyTorch中实现价值迭代网络(VIN)。Vin在NIPS 2016年获得最佳论文奖。
  • Pytorch Highway:Highway Netowrks是允许信息高速无阻碍的通过各层,它是从Long Short Term Memory(LSTM) recurrent networks中的gate机制受到启发,可以让信息无阻碍的通过许多层,达到训练深层神经网络的效果,使深层神经网络不在仅仅具有浅层神经网络的效果。该论文是Highway network基于Pytorch的实现。
  • Pyscatwave:Cupy/Pythorn的散射实现。散射网络是一种卷积网络,它的滤波器被预先定义为子波,不需要学习,可以用于图像分类等视觉任务。散射变换可以显著降低输入的空间分辨率(例如224×224->14×14),且双关功率损失明显为负。
  • Pytorch_NEG_loss:该论文是Negative Sampling Loss的Pytorch实现。Negative Sampling是一种求解word2vec模型的方法,它摒弃了霍夫曼树,采用了Negative Sampling(负采样)的方法来求解,本论文是对Negative Sampling的loss函数的研究,感兴趣的小伙伴可点击上方论文链接学习。
  • Pytorch_TDNN:该论文是对Time Delayed NN的Pytorch实现。论文详细的讲述了TDNN的原理以及实现过程。

PyTorch书籍推荐

相较于目前Tensorflow类型的书籍已经烂大街的状况,PyTorch类的书籍目前已出版的并没有那么多,笔者给大家推荐我认为还不错的四本PyTorch书籍。

  • 《深度学习入门之PyTorch》,电子工业出版社,作者:廖星宇。这本《深度学习入门之PyTorch》是所有PyTorch书籍中出版的相对较早的一本,作者以自己的小白入门深度学习之路,深入浅出的讲解了PyTorch的语法、原理以及实战等内容,适合新手的入门学习。但不足的是,书中有很多不严谨以及生搬硬套的地方,需要读者好好甄别。 推荐指数:★★★
  • 《PyTorch深度学习》,人民邮电出版社,作者:王海玲、刘江峰。该书是一本英译书籍,原作者是两位印度的大佬,该书除了PyTorch基本语法、函数外,还涵盖了ResNET、Inception、DenseNet等在内的高级神经网络架构以及它们的应用案例。该书适合数据分析师、数据科学家等相对有一些理论基础和实战经验的读者学习,不太建议作为新手的入门选择。 推荐指数:★★★
  • 《深度学习框架PyTorch入门与实践》,电子工业出版社,作者:陈云。这是一本2018年上市的PyTorch书籍,包含理论入门和实战项目两大部分,相较于其它同类型书籍,该书案例非常的翔实,包括:Kaggle竞赛中经典项目、GAN生成动漫头像、AI滤镜、RNN写诗、图像描述任务等。理论+实战的内容设置也更适合深度学习入门者和从业者学习。 推荐指数:★★★★
  • 《PyTorch机器学习从入门到实战》,机械工业出版社,作者:校宝在线、孙琳等。该书同样是一本理论结合实战的Pytorch教程,相较于前一本入门+实战教程,本书的特色在于关于深度学习的理论部分讲的非常详细,后边的实战项目更加的综合。总体而言,本书也是一本适合新手学习的不错的PyTorch入门书籍。 推荐指数:★★★

PyTorch 高级教程:基于 BI-LSTM CRF 实现命名实体识别和中文分词

前言:译者实测 PyTorch 代码非常简洁易懂,只需要将中文分词的数据集预处理成作者提到的格式,即可很快的就迁移了这个代码到中文分词中,相关的代码后续将会分享。

Pytorch是一个动态神经网络工具包。 动态工具包的另一个例子是Dynet(我之所以提到这一点,因为与Pytorch和Dynet的工作方式类似。如果你在Dynet中看到一个例子,它可能会帮助你在Pytorch中实现它)。 相反的是静态工具包,包括Theano,Keras,TensorFlow等。核心区别如下:

  • 在静态工具箱中,您可以定义一次计算图,对其进行编译,然后将实例流式传输给它。
  • 在动态工具包中,您可以为每个实例定义计算图。 它永远不会被编译并且是即时执行的。

动态工具包还有一个优点,那就是更容易调试,代码更像主机语言(我的意思是pytorch和dynet看起来更像实际的python代码,而不是keras或theano)。

Bi-LSTM Conditional Random Field (Bi-LSTM CRF)

对于本节,我们将看到用于命名实体识别的Bi-LSTM条件随机场的完整复杂示例。 上面的LSTM标记符通常足以用于词性标注,但是像CRF这样的序列模型对于NER上的强大性能非常重要。 假设熟悉CRF。 虽然这个名字听起来很可怕,但所有模型都是CRF,但是LSTM提供了特征。 这是一个高级模型,比本教程中的任何早期模型复杂得多。

实现细节:

下面的例子在 log 空间中实现了计算微分函数的正向算法,以及要解码的维特比算法。反向传播将自动为我们计算梯度。我们不必用手做任何事。

这个算法用来演示,没有优化。如果您了解正在发生的事情,您可能会很快看到,在转发算法中迭代下一个标记可能是在一个大型操作中完成的。我想用代码来提高可读性。如果你想做相关的改变,你可以用这个标记器来完成真正的任务。

# Author: Robert Guthrie

import torch
import torch.autograd as autograd
import torch.nn as nn
import torch.optim as optim

torch.manual_seed(1)

帮助程序函数,使代码更具可读性。

def argmax(vec):
    # return the argmax as a python int
    _, idx = torch.max(vec, 1)
    return idx.item()


def prepare_sequence(seq, to_ix):
    idxs = [to_ix[w] for w in seq]
    return torch.tensor(idxs, dtype=torch.long)


# Compute log sum exp in a numerically stable way for the forward algorithm
def log_sum_exp(vec):
    max_score = vec[0, argmax(vec)]
    max_score_broadcast = max_score.view(1, -1).expand(1, vec.size()[1])
    return max_score + \
        torch.log(torch.sum(torch.exp(vec - max_score_broadcast)))

创建模型

class BiLSTM_CRF(nn.Module):

    def __init__(self, vocab_size, tag_to_ix, embedding_dim, hidden_dim):
        super(BiLSTM_CRF, self).__init__()
        self.embedding_dim = embedding_dim
        self.hidden_dim = hidden_dim
        self.vocab_size = vocab_size
        self.tag_to_ix = tag_to_ix
        self.tagset_size = len(tag_to_ix)

        self.word_embeds = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim // 2,
                            num_layers=1, bidirectional=True)

        # Maps the output of the LSTM into tag space.
        self.hidden2tag = nn.Linear(hidden_dim, self.tagset_size)

        # Matrix of transition parameters.  Entry i,j is the score of
        # transitioning *to* i *from* j.
        self.transitions = nn.Parameter(
            torch.randn(self.tagset_size, self.tagset_size))

        # These two statements enforce the constraint that we never transfer
        # to the start tag and we never transfer from the stop tag
        self.transitions.data[tag_to_ix[START_TAG], :] = -10000
        self.transitions.data[:, tag_to_ix[STOP_TAG]] = -10000

        self.hidden = self.init_hidden()

    def init_hidden(self):
        return (torch.randn(2, 1, self.hidden_dim // 2),
                torch.randn(2, 1, self.hidden_dim // 2))

    def _forward_alg(self, feats):
        # Do the forward algorithm to compute the partition function
        init_alphas = torch.full((1, self.tagset_size), -10000.)
        # START_TAG has all of the score.
        init_alphas[0][self.tag_to_ix[START_TAG]] = 0.

        # Wrap in a variable so that we will get automatic backprop
        forward_var = init_alphas

        # Iterate through the sentence
        for feat in feats:
            alphas_t = []  # The forward tensors at this timestep
            for next_tag in range(self.tagset_size):
                # broadcast the emission score: it is the same regardless of
                # the previous tag
                emit_score = feat[next_tag].view(
                    1, -1).expand(1, self.tagset_size)
                # the ith entry of trans_score is the score of transitioning to
                # next_tag from i
                trans_score = self.transitions[next_tag].view(1, -1)
                # The ith entry of next_tag_var is the value for the
                # edge (i -> next_tag) before we do log-sum-exp
                next_tag_var = forward_var + trans_score + emit_score
                # The forward variable for this tag is log-sum-exp of all the
                # scores.
                alphas_t.append(log_sum_exp(next_tag_var).view(1))
            forward_var = torch.cat(alphas_t).view(1, -1)
        terminal_var = forward_var + self.transitions[self.tag_to_ix[STOP_TAG]]
        alpha = log_sum_exp(terminal_var)
        return alpha

    def _get_lstm_features(self, sentence):
        self.hidden = self.init_hidden()
        embeds = self.word_embeds(sentence).view(len(sentence), 1, -1)
        lstm_out, self.hidden = self.lstm(embeds, self.hidden)
        lstm_out = lstm_out.view(len(sentence), self.hidden_dim)
        lstm_feats = self.hidden2tag(lstm_out)
        return lstm_feats

    def _score_sentence(self, feats, tags):
        # Gives the score of a provided tag sequence
        score = torch.zeros(1)
        tags = torch.cat([torch.tensor([self.tag_to_ix[START_TAG]], dtype=torch.long), tags])
        for i, feat in enumerate(feats):
            score = score + \
                self.transitions[tags[i + 1], tags[i]] + feat[tags[i + 1]]
        score = score + self.transitions[self.tag_to_ix[STOP_TAG], tags[-1]]
        return score

    def _viterbi_decode(self, feats):
        backpointers = []

        # Initialize the viterbi variables in log space
        init_vvars = torch.full((1, self.tagset_size), -10000.)
        init_vvars[0][self.tag_to_ix[START_TAG]] = 0

        # forward_var at step i holds the viterbi variables for step i-1
        forward_var = init_vvars
        for feat in feats:
            bptrs_t = []  # holds the backpointers for this step
            viterbivars_t = []  # holds the viterbi variables for this step

            for next_tag in range(self.tagset_size):
                # next_tag_var[i] holds the viterbi variable for tag i at the
                # previous step, plus the score of transitioning
                # from tag i to next_tag.
                # We don't include the emission scores here because the max
                # does not depend on them (we add them in below)
                next_tag_var = forward_var + self.transitions[next_tag]
                best_tag_id = argmax(next_tag_var)
                bptrs_t.append(best_tag_id)
                viterbivars_t.append(next_tag_var[0][best_tag_id].view(1))
            # Now add in the emission scores, and assign forward_var to the set
            # of viterbi variables we just computed
            forward_var = (torch.cat(viterbivars_t) + feat).view(1, -1)
            backpointers.append(bptrs_t)

        # Transition to STOP_TAG
        terminal_var = forward_var + self.transitions[self.tag_to_ix[STOP_TAG]]
        best_tag_id = argmax(terminal_var)
        path_score = terminal_var[0][best_tag_id]

        # Follow the back pointers to decode the best path.
        best_path = [best_tag_id]
        for bptrs_t in reversed(backpointers):
            best_tag_id = bptrs_t[best_tag_id]
            best_path.append(best_tag_id)
        # Pop off the start tag (we dont want to return that to the caller)
        start = best_path.pop()
        assert start == self.tag_to_ix[START_TAG]  # Sanity check
        best_path.reverse()
        return path_score, best_path

    def neg_log_likelihood(self, sentence, tags):
        feats = self._get_lstm_features(sentence)
        forward_score = self._forward_alg(feats)
        gold_score = self._score_sentence(feats, tags)
        return forward_score - gold_score

    def forward(self, sentence):  # dont confuse this with _forward_alg above.
        # Get the emission scores from the BiLSTM
        lstm_feats = self._get_lstm_features(sentence)

        # Find the best path, given the features.
        score, tag_seq = self._viterbi_decode(lstm_feats)
        return score, tag_seq

 

开始训练

START_TAG = "<START>"
STOP_TAG = "<STOP>"
EMBEDDING_DIM = 5
HIDDEN_DIM = 4

# Make up some training data
training_data = [(
    "the wall street journal reported today that apple corporation made money".split(),
    "B I I I O O O B I O O".split()
), (
    "georgia tech is a university in georgia".split(),
    "B I O O O O B".split()
)]

word_to_ix = {}
for sentence, tags in training_data:
    for word in sentence:
        if word not in word_to_ix:
            word_to_ix[word] = len(word_to_ix)

tag_to_ix = {"B": 0, "I": 1, "O": 2, START_TAG: 3, STOP_TAG: 4}

model = BiLSTM_CRF(len(word_to_ix), tag_to_ix, EMBEDDING_DIM, HIDDEN_DIM)
optimizer = optim.SGD(model.parameters(), lr=0.01, weight_decay=1e-4)

# Check predictions before training
with torch.no_grad():
    precheck_sent = prepare_sequence(training_data[0][0], word_to_ix)
    precheck_tags = torch.tensor([tag_to_ix[t] for t in training_data[0][1]], dtype=torch.long)
    print(model(precheck_sent))

# Make sure prepare_sequence from earlier in the LSTM section is loaded
for epoch in range(
        300):  # again, normally you would NOT do 300 epochs, it is toy data
    for sentence, tags in training_data:
        # Step 1. Remember that Pytorch accumulates gradients.
        # We need to clear them out before each instance
        model.zero_grad()

        # Step 2. Get our inputs ready for the network, that is,
        # turn them into Tensors of word indices.
        sentence_in = prepare_sequence(sentence, word_to_ix)
        targets = torch.tensor([tag_to_ix[t] for t in tags], dtype=torch.long)

        # Step 3. Run our forward pass.
        loss = model.neg_log_likelihood(sentence_in, targets)

        # Step 4. Compute the loss, gradients, and update the parameters by
        # calling optimizer.step()
        loss.backward()
        optimizer.step()

# Check predictions after training
with torch.no_grad():
    precheck_sent = prepare_sequence(training_data[0][0], word_to_ix)
    print(model(precheck_sent))
# We got it!

输出

(tensor(2.6907), [1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1])
(tensor(20.4906), [0, 1, 1, 1, 2, 2, 2, 0, 1, 2, 2])

 

我们没有必要在进行解码时创建计算图,因为我们不会从维特比路径得分反向传播。 因为无论如何我们都有它,尝试训练标记器,其中损失函数是维特比路径得分和测试标准路径得分之间的差异。 应该清楚的是,当预测的标签序列是正确的标签序列时,该功能是非负的和0。 这基本上是结构感知器。

由于已经实现了 Viterbi 和score_sentence ,因此这种修改应该很短。 这是取决于训练实例的计算图形的示例。 虽然我没有尝试在静态工具包中实现它,但我想它可能但不那么直截了当。

拿起一些真实数据并进行比较!

原文链接:https://pytorch.org/tutorials/beginner/nlp/advanced_tutorial.html#advanced-making-dynamic-decisions-and-the-bi-lstm-crf

PyText:一个基于 PyTorch 的自然语言处理框架

概述

PyText 是一个基于 PyTorch 实现的 NLP 框架。PyText 解决了实现快速实验和在规模部署服务模型的冲突。它通过为模型组件提供简单和可扩展的接口和抽象,以及使用通过 PyTorch 优化的 Caffe2 执行引擎可以导出用于推断的模型的能力,来实现这一点。我们使用 Facebook 中的 PyText 来快速迭代新的建模思想,然后无缝地将它们弹性发布。

PyText 核心特性:

各种生产就绪模型的 NLP/NLU 任务:

文本分类器

Yoon Kim (2014): Convolutional Neural Networks for Sentence Classification
Lin et al. (2017): A Structured Self-attentive Sentence Embedding

序列标记符

Lample et al. (2016): Neural Architectures for Named Entity Recognition

联合意图时隙模型

Zhang et al. (2016): A Joint Model of Intent Determination and Slot Filling for Spoken Language Understanding

上下文意图槽模型

支持建立在 PyTorch 1.0 上新的 C10d 后端分布式训练

可扩展组件,允许轻松创建新模型和任务

参考实现和论文的预训练模型:Gupta et al. (2018): Semantic Parsing for Task Oriented Dialog using Hierarchical Representations

增强培训支持

安装 PyText

要开始使用云虚拟机,请查看我们的指南:https://pytext-pytext.readthedocs-hosted.com/en/latest/installation.html#cloud-vm-setup

我们建议使用 virtualenv:

$ python3 -m venv pytext_venv
$ source pytext_venv/bin/activate
(pytext_venv) $ pip install pytext-nlp

详细说明和更多的安装选项可以在我们的文档(https://pytext-pytext.readthedocs-hosted.com/en/latest/installation.html)中找到。如果在安装过程中遇到缺少依赖项的问题,请参考OS(https://pytext-pytext.readthedocs-hosted.com/en/latest/installation.html#os-dependencies)依赖项。

训练第一个文本分类器

对于第一个例子,我们将使用基于 CNN 的文本分类器,我们将使用 tests/data/train_data_tiny.tsv。可以通过克隆存储库或通过从GitHub手动下载文件来获得数据和配置文件。

(venv)$pytext.

PyTorch 60 分钟入门教程:神经网络

神经网络

神经网络可以通过 torch.nn 包来构建。

现在对于自动梯度(autograd)有一些了解,神经网络是基于自动梯度 (autograd)来定义一些模型。一个 nn.Module 包括层和一个方法 forward(input) 它会返回输出(output)。

例如,看一下数字图片识别的网络:

这是一个简单的前馈神经网络,它接收输入,让输入一个接着一个的通过一些层,最后给出输出。

一个典型的神经网络训练过程包括以下几点:

1.定义一个包含可训练参数的神经网络

2.迭代整个输入

3.通过神经网络处理输入

4.计算损失(loss)

5.反向传播梯度到神经网络的参数

6.更新网络的参数,典型的用一个简单的更新方法:weight = weight  learning_rate *gradient

定义神经网络

import torch
import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        # 1 input image channel, 6 output channels, 5x5 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        size = x.size()[1:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features


net = Net()
print(net)

输出:

Net(
  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear(in_features=400, out_features=120, bias=True)
  (fc2): Linear(in_features=120, out_features=84, bias=True)
  (fc3): Linear(in_features=84, out_features=10, bias=True)
)

你刚定义了一个前馈函数,然后反向传播函数被自动通过 autograd 定义了。你可以使用任何张量操作在前馈函数上。

一个模型可训练的参数可以通过调用 net.parameters() 返回:

params = list(net.parameters())
print(len(params))
print(params[0].size())  # conv1's .weight

输出:

10
torch.Size([6, 1, 5, 5])

让我们尝试随机生成一个 32×32 的输入。注意:期望的输入维度是 32×32 。为了使用这个网络在 MNIST 数据及上,你需要把数据集中的图片维度修改为 32×32。

input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)

输出:

tensor([[-0.0233,  0.0159, -0.0249,  0.1413,  0.0663,  0.0297, -0.0940, -0.0135,
          0.1003, -0.0559]], grad_fn=<AddmmBackward>)

把所有参数梯度缓存器置零,用随机的梯度来反向传播

net.zero_grad()
out.backward(torch.randn(1, 10))

在继续之前,让我们复习一下所有见过的类。

torch.Tensor – A multi-dimensional array with support for autograd operations like backward(). Also holds the gradient w.r.t. the tensor.
nn.Module – Neural network module. Convenient way of encapsulating parameters, with helpers for moving them to GPU, exporting, loading, etc.
nn.Parameter – A kind of Tensor, that is automatically registered as a parameter when assigned as an attribute to a Module.
autograd.Function – Implements forward and backward definitions of an autograd operation. Every Tensor operation, creates at least a single Function node, that connects to functions that created a Tensor and encodes its history.

在此,我们完成了:

1.定义一个神经网络

2.处理输入以及调用反向传播

还剩下:

1.计算损失值

2.更新网络中的权重

损失函数

一个损失函数需要一对输入:模型输出和目标,然后计算一个值来评估输出距离目标有多远。

有一些不同的损失函数在 nn 包中。一个简单的损失函数就是 nn.MSELoss ,这计算了均方误差。

例如:

output = net(input)
target = torch.randn(10)  # a dummy target, for example
target = target.view(1, -1)  # make it the same shape as output
criterion = nn.MSELoss()

loss = criterion(output, target)
print(loss)

输出:

tensor(1.3389, grad_fn=<MseLossBackward>)

现在,如果你跟随损失到反向传播路径,可以使用它的 .grad_fn 属性,你将会看到一个这样的计算图:

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
      -> view -> linear -> relu -> linear -> relu -> linear
      -> MSELoss
      -> loss

所以,当我们调用 loss.backward(),整个图都会微分,而且所有的在图中的requires_grad=True 的张量将会让他们的 grad 张量累计梯度。

为了演示,我们将跟随以下步骤来反向传播。

print(loss.grad_fn)  # MSELoss
print(loss.grad_fn.next_functions[0][0])  # Linear
print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU

输出:

<MseLossBackward object at 0x7fab77615278>
<AddmmBackward object at 0x7fab77615940>
<AccumulateGrad object at 0x7fab77615940>

反向传播

为了实现反向传播损失,我们所有需要做的事情仅仅是使用 loss.backward()。你需要清空现存的梯度,要不然帝都将会和现存的梯度累计到一起。

现在我们调用 loss.backward() ,然后看一下 con1 的偏置项在反向传播之前和之后的变化。

net.zero_grad()     # zeroes the gradient buffers of all parameters

print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)

loss.backward()

print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)

输出:

conv1.bias.grad before backward
tensor([0., 0., 0., 0., 0., 0.])
conv1.bias.grad after backward
tensor([-0.0054,  0.0011,  0.0012,  0.0148, -0.0186,  0.0087])

现在我们看到了,如何使用损失函数。

唯一剩下的事情就是更新神经网络的参数。

更新神经网络参数:

最简单的更新规则就是随机梯度下降。

weight = weight - learning_rate * gradient

我们可以使用 python 来实现这个规则:

learning_rate = 0.01
for f in net.parameters():
    f.data.sub_(f.grad.data * learning_rate)

尽管如此,如果你是用神经网络,你想使用不同的更新规则,类似于 SGD, Nesterov-SGD, Adam, RMSProp, 等。为了让这可行,我们建立了一个小包:torch.optim 实现了所有的方法。使用它非常的简单。

import torch.optim as optim

# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)

# in your training loop:
optimizer.zero_grad()   # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # Does the update

下载 Python 源代码:

neural_networks_tutorial.py

下载 Jupyter 源代码:

neural_networks_tutorial.ipynb

PyTorch 60 分钟入门教程:PyTorch 训练分类器

你已经了解了如何定义神经网络,计算损失值和网络里权重的更新。

现在你也许会想应该怎么处理数据?

通常来说,当你处理图像,文本,语音或者视频数据时,你可以使用标准 python 包将数据加载成 numpy 数组格式,然后将这个数组转换成 torch.*Tensor

  • 对于图像,可以用 Pillow,OpenCV
  • 对于语音,可以用 scipy,librosa
  • 对于文本,可以直接用 Python 或 Cython 基础数据加载模块,或者用 NLTK 和 SpaCy

特别是对于视觉,我们已经创建了一个叫做 totchvision 的包,该包含有支持加载类似Imagenet,CIFAR10,MNIST 等公共数据集的数据加载模块 torchvision.datasets 和支持加载图像数据数据转换模块 torch.utils.data.DataLoader。

这提供了极大的便利,并且避免了编写“样板代码”。

对于本教程,我们将使用CIFAR10数据集,它包含十个类别:‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’。CIFAR-10 中的图像尺寸为3*32*32,也就是RGB的3层颜色通道,每层通道内的尺寸为32*32。

训练一个图像分类器

我们将按次序的做如下几步:

  1. 使用torchvision加载并且归一化CIFAR10的训练和测试数据集
  2. 定义一个卷积神经网络
  3. 定义一个损失函数
  4. 在训练样本数据上训练网络
  5. 在测试样本数据上测试网络

加载并归一化 CIFAR10
使用 torchvision ,用它来加载 CIFAR10 数据非常简单。

import torch
import torchvision
import torchvision.transforms as transforms

torchvision 数据集的输出是范围在[0,1]之间的 PILImage,我们将他们转换成归一化范围为[-1,1]之间的张量 Tensors。

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

输出:

Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz
Files already downloaded and verified

让我们来展示其中的一些训练图片。

import matplotlib.pyplot as plt
import numpy as np

# functions to show an image


def imshow(img):
    img = img / 2 + 0.5     # unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()


# get some random training images
dataiter = iter(trainloader)
images, labels = dataiter.next()

# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

 

输出:

cat plane  ship  frog
定义一个卷积神经网络
在这之前先 从神经网络章节 复制神经网络,并修改它为3通道的图片(在此之前它被定义为1通道)
import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x


net = Net()

 

定义一个损失函数和优化器
让我们使用分类交叉熵Cross-Entropy 作损失函数,动量SGD做优化器。
import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
训练网络
这里事情开始变得有趣,我们只需要在数据迭代器上循环传给网络和优化器 输入就可以。
for epoch in range(2):  # loop over the dataset multiple times

    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs
        inputs, labels = data

        # zero the parameter gradients
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # print statistics
        running_loss += loss.item()
        if i % 2000 == 1999:    # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')
 输出:
[1,  2000] loss: 2.187
[1,  4000] loss: 1.852
[1,  6000] loss: 1.672
[1,  8000] loss: 1.566
[1, 10000] loss: 1.490
[1, 12000] loss: 1.461
[2,  2000] loss: 1.389
[2,  4000] loss: 1.364
[2,  6000] loss: 1.343
[2,  8000] loss: 1.318
[2, 10000] loss: 1.282
[2, 12000] loss: 1.286
Finished Training

在测试集上测试网络
我们已经通过训练数据集对网络进行了2次训练,但是我们需要检查网络是否已经学到了东西。

我们将用神经网络的输出作为预测的类标来检查网络的预测性能,用样本的真实类标来校对。如果预测是正确的,我们将样本添加到正确预测的列表里。

好的,第一步,让我们从测试集中显示一张图像来熟悉它。

输出:

GroundTruth:    cat  ship  ship plane

现在让我们看看 神经网络认为这些样本应该预测成什么:

outputs = net(images)

输出是预测与十个类的近似程度,与某一个类的近似程度越高,网络就越认为图像是属于这一类别。所以让我们打印其中最相似类别类标:

_, predicted = torch.max(outputs, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
                              for j in range(4)))

输出:

Predicted:    cat  ship   car  ship

结果看起开非常好,让我们看看网络在整个数据集上的表现。

correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (
    100 * correct / total))

输出:

Accuracy of the network on the 10000 test images: 54 %

这看起来比随机预测要好,随机预测的准确率为10%(随机预测出为10类中的哪一类)。看来网络学到了东西。

class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs, 1)
        c = (predicted == labels).squeeze()
        for i in range(4):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += 1


for i in range(10):
    print('Accuracy of %5s : %2d %%' % (
        classes[i], 100 * class_correct[i] / class_total[i]))

输出:

Accuracy of plane : 57 %
Accuracy of   car : 73 %
Accuracy of  bird : 49 %
Accuracy of   cat : 54 %
Accuracy of  deer : 18 %
Accuracy of   dog : 20 %
Accuracy of  frog : 58 %
Accuracy of horse : 74 %
Accuracy of  ship : 70 %
Accuracy of truck : 66 %

所以接下来呢?

我们怎么在GPU上跑这些神经网络?

在GPU上训练
就像你怎么把一个张量转移到GPU上一样,你要将神经网络转到GPU上。
如果CUDA可以用,让我们首先定义下我们的设备为第一个可见的cuda设备。

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# Assume that we are on a CUDA machine, then this should print a CUDA device:

print(device)

输出:

cuda:0

本节剩余部分都会假定设备就是台CUDA设备。

接着这些方法会递归地遍历所有模块,并将它们的参数和缓冲器转换为CUDA张量。

net.to(device)

记住你也必须在每一个步骤向GPU发送输入和目标:

inputs, labels = inputs.to(device), labels.to(device)

为什么没有注意到与CPU相比巨大的加速?因为你的网络非常小。

 

练习:尝试增加你的网络宽度(首个 nn.Conv2d 参数设定为 2,第二个nn.Conv2d参数设定为1–它们需要有相同的个数),看看会得到怎么的速度提升。

目标:

  • 深度理解了PyTorch的张量和神经网络
  • 训练了一个小的神经网络来分类图像

在多个GPU上训练

如果你想要来看到大规模加速,使用你的所有GPU,请查看:数据并行性(https://pytorch.org/tutorials/beginner/blitz/data_parallel_tutorial.html)。PyTorch 60 分钟入门教程:数据并行处理

PyTorch 60 分钟入门教程:数据并行处理

下载 Python 源代码:

cifar10_tutorial.py

下载 Jupyter 源代码:

cifar10_tutorial.ipynb

PyTorch 60 分钟入门教程:自动微分

autograd 包是 PyTorch 中所有神经网络的核心。首先让我们简要地介绍它,然后我们将会去训练我们的第一个神经网络。该 autograd 软件包为 Tensors 上的所有操作提供自动微分。它是一个由运行定义的框架,这意味着以代码运行方式定义你的后向传播,并且每次迭代都可以不同。我们从 tensor 和 gradients 来举一些例子。

1、TENSOR

torch.Tensor 是包的核心类。如果将其属性 .requires_grad 设置为 True,则会开始跟踪针对 tensor 的所有操作。完成计算后,您可以调用 .backward() 来自动计算所有梯度。该张量的梯度将累积到 .grad 属性中。

要停止 tensor 历史记录的跟踪,您可以调用 .detach(),它将其与计算历史记录分离,并防止将来的计算被跟踪。

要停止跟踪历史记录(和使用内存),您还可以将代码块使用 with torch.no_grad(): 包装起来。在评估模型时,这是特别有用,因为模型在训练阶段具有 requires_grad = True 的可训练参数有利于调参,但在评估阶段我们不需要梯度。

还有一个类对于 autograd 实现非常重要那就是 Function。Tensor 和 Function 互相连接并构建一个非循环图,它保存整个完整的计算过程的历史信息。每个张量都有一个 .grad_fn 属性保存着创建了张量的 Function 的引用,(如果用户自己创建张量,则g rad_fn 是 None )。

如果你想计算导数,你可以调用 Tensor.backward()。如果 Tensor 是标量(即它包含一个元素数据),则不需要指定任何参数backward(),但是如果它有更多元素,则需要指定一个gradient 参数来指定张量的形状。

import torch

创建一个张量,设置 requires_grad=True 来跟踪与它相关的计算

x = torch.ones(2, 2, requires_grad=True)
print(x)

输出:

tensor([[1., 1.],
        [1., 1.]], requires_grad=True)

针对张量做一个操作

y = x + 2
print(y)

输出:

tensor([[3., 3.],
        [3., 3.]], grad_fn=<AddBackward0>)

y 作为操作的结果被创建,所以它有 grad_fn

print(y.grad_fn)

输出:

<AddBackward0 object at 0x7fe1db427470>

针对 y 做更多的操作:

z = y * y * 3
out = z.mean()

print(z, out)

输出:

tensor([[27., 27.],
        [27., 27.]], grad_fn=<MulBackward0>) tensor(27., grad_fn=<MeanBackward0>)

.requires_grad_( ... ) 会改变张量的 requires_grad 标记。输入的标记默认为  False ,如果没有提供相应的参数。

a = torch.randn(2, 2)
a = ((a * 3) / (a - 1))
print(a.requires_grad)
a.requires_grad_(True)
print(a.requires_grad)
b = (a * a).sum()
print(b.grad_fn)

输出:

False
True
<SumBackward0 object at 0x7fe1db427dd8>

梯度:

我们现在后向传播,因为输出包含了一个标量,out.backward() 等同于out.backward(torch.tensor(1.))

out.backward()

打印梯度  d(out)/dx

print(x.grad)
 输出:
tensor([[4.5000, 4.5000],
        [4.5000, 4.5000]])

 

原理解释:

现在让我们看一个雅可比向量积的例子:

x = torch.randn(3, requires_grad=True)

y = x * 2
while y.data.norm() < 1000:
    y = y * 2

print(y)

输出:

tensor([ -444.6791,   762.9810, -1690.0941], grad_fn=<MulBackward0>)

 

现在在这种情况下,y 不再是一个标量。torch.autograd 不能够直接计算整个雅可比,但是如果我们只想要雅可比向量积,只需要简单的传递向量给 backward 作为参数。

v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float)
y.backward(v)

print(x.grad)

输出:

tensor([1.0240e+02, 1.0240e+03, 1.0240e-01])

 

你可以通过将代码包裹在 with torch.no_grad(),来停止对从跟踪历史中 的 .requires_grad=True 的张量自动求导。

print(x.requires_grad)
print((x ** 2).requires_grad)

with torch.no_grad():
    print((x ** 2).requires_grad)

输出:

True
True
False

稍后可以阅读:

autograd 和 Function 的文档在: https://pytorch.org/docs/autograd

下载 Python 源代码:

autograd_tutorial.py

下载 Jupyter 源代码:

autograd_tutorial.ipynb