Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
OpenDocCN
Ailearning
提交
045dee58
A
Ailearning
项目概览
OpenDocCN
/
Ailearning
大约 1 年 前同步成功
通知
12
Star
36240
Fork
11272
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
A
Ailearning
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
045dee58
编写于
10月 19, 2020
作者:
W
wizardforcel
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
2020-10-19 21:48:57
上级
74f7d35a
变更
20
显示空白变更内容
内联
并排
Showing
20 changed file
with
73 addition
and
73 deletion
+73
-73
docs/pytorch/03.md
docs/pytorch/03.md
+1
-1
docs/pytorch/05.md
docs/pytorch/05.md
+3
-3
docs/pytorch/06.md
docs/pytorch/06.md
+4
-4
docs/pytorch/07.md
docs/pytorch/07.md
+3
-3
docs/pytorch/09.md
docs/pytorch/09.md
+4
-4
docs/pytorch/10.md
docs/pytorch/10.md
+4
-4
docs/pytorch/11.md
docs/pytorch/11.md
+3
-3
docs/pytorch/12.md
docs/pytorch/12.md
+4
-4
docs/pytorch/13.md
docs/pytorch/13.md
+2
-2
docs/pytorch/14.md
docs/pytorch/14.md
+4
-4
docs/pytorch/16.md
docs/pytorch/16.md
+5
-5
docs/pytorch/17.md
docs/pytorch/17.md
+5
-5
docs/pytorch/18.md
docs/pytorch/18.md
+4
-4
docs/pytorch/19.md
docs/pytorch/19.md
+4
-4
docs/pytorch/20.md
docs/pytorch/20.md
+5
-5
docs/pytorch/21.md
docs/pytorch/21.md
+6
-6
docs/pytorch/23.md
docs/pytorch/23.md
+1
-1
docs/pytorch/24.md
docs/pytorch/24.md
+3
-3
docs/pytorch/25.md
docs/pytorch/25.md
+4
-4
docs/pytorch/26.md
docs/pytorch/26.md
+4
-4
未找到文件。
docs/pytorch/03.md
浏览文件 @
045dee58
...
...
@@ -14,7 +14,7 @@ PyTorch 安装起来很简单, [它自家网页](https://www.pytorchtutorial.co
然后根据上面的提示, 我只需要在我的 Terminal 当中输入以下指令就好了:
```
```
py
$
pip
install
http
:
//
download
.
pytorch
.
org
/
whl
/
torch
-
0.1
.
11.
post5
-
cp35
-
cp35m
-
macosx_10_7_x86_64
.
whl
$
pip
install
torchvision
```
...
...
docs/pytorch/05.md
浏览文件 @
045dee58
...
...
@@ -6,7 +6,7 @@ Torch 自称为神经网络界的 Numpy, 因为他能将 torch 产生的 tensor
当然, 我们对 Numpy 还是爱不释手的, 因为我们太习惯 numpy 的形式了. 不过 torch 看出来我们的喜爱, 他把 torch 做的和 numpy 能很好的兼容. 比如这样就能自由地转换 numpy array 和 torch tensor 了:
```
```
py
import
torch
import
numpy
as
np
...
...
@@ -24,7 +24,7 @@ print(
其实 torch 中 tensor 的运算和 numpy array 的如出一辙, 我们就以对比的形式来看. 如果想了解 torch 中其它更多有用的运算符,
[
API就是你要去的地方
](
https://www.pytorchtutorial.com/goto/http://pytorch.org/docs/torch.html#math-operations
)
.
```
```
py
# abs 绝对值计算
data
=
[
-
1
,
-
2
,
1
,
2
]
tensor
=
torch
.
FloatTensor
(
data
)
# 转换成32位浮点 tensor
...
...
@@ -51,7 +51,7 @@ print(
除了简单的计算, 矩阵运算才是神经网络中最重要的部分. 所以我们展示下矩阵的乘法. 注意一下包含了一个 numpy 中可行, 但是 torch 中不可行的方式.
```
```
py
# matrix multiplication 矩阵点乘
data
=
[[
1
,
2
],
[
3
,
4
]]
tensor
=
torch
.
FloatTensor
(
data
)
# 转换成32位浮点 tensor
...
...
docs/pytorch/06.md
浏览文件 @
045dee58
...
...
@@ -6,7 +6,7 @@
我们定义一个 Variable:
```
```
py
import
torch
from
torch.autograd
import
Variable
# torch 中 Variable 模块
...
...
@@ -35,7 +35,7 @@ Variable containing:
我们再对比一下 tensor 的计算和 variable 的计算.
\’
```
```
py
t_out
=
torch
.
mean
(
tensor
*
tensor
)
# x^2
v_out
=
torch
.
mean
(
variable
*
variable
)
# x^2
print
(
t_out
)
...
...
@@ -46,7 +46,7 @@ print(v_out) # 7.5
v_out = torch.mean(variable
*
variable) 就是在计算图中添加的一个计算步骤, 计算误差反向传递的时候有他一份功劳, 我们就来举个例子:
```
```
py
v_out
.
backward
()
# 模拟 v_out 的误差反向传递
# 下面两步看不懂没关系, 只要知道 Variable 是计算图的一部分, 可以用来传递误差就好.
...
...
@@ -64,7 +64,7 @@ print(variable.grad) # 初始 Variable 的梯度
直接 print(variable) 只会输出 Variable 形式的数据, 在很多时候是用不了的(比如想要用 plt 画图), 所以我们要转换一下, 将它变成 tensor 形式.
```
```
py
print
(
variable
)
# Variable 形式
"""
Variable containing:
...
...
docs/pytorch/07.md
浏览文件 @
045dee58
...
...
@@ -8,7 +8,7 @@
Torch 中的激励函数有很多, 不过我们平时要用到的就这几个. relu, sigmoid, tanh, softplus . 那我们就看看他们各自长什么样啦.
```
```
py
import
torch
import
torch.nn.functional
as
F
# 激励函数都在这
from
torch.autograd
import
Variable
...
...
@@ -20,7 +20,7 @@ x = Variable(x)
接着就是做生成不同的激励函数数据:
```
```
py
x_np
=
x
.
data
.
numpy
()
# 换成 numpy array, 出图时用
# 几种常用的 激励函数
...
...
@@ -35,7 +35,7 @@ y_softplus = F.softplus(x).data.numpy()
![](
img/f1108a1b6941305fa7a39e488c023fe9.png
)
```
```
py
import
matplotlib.pyplot
as
plt
# python 的可视化模块, 我有教程 (https://morvanzhou.github.io/tutorials/data-manipulation/plt/)
plt
.
figure
(
1
,
figsize
=
(
8
,
6
))
...
...
docs/pytorch/09.md
浏览文件 @
045dee58
...
...
@@ -8,7 +8,7 @@
我们创建一些假数据来模拟真实的情况. 比如一个一元二次函数: y = a
*
x^2 b , 我们给 y 数据加上一点噪声来更加真实的展示它.
```
```
py
import
torch
from
torch.autograd
import
Variable
import
matplotlib.pyplot
as
plt
...
...
@@ -28,7 +28,7 @@ plt.show()
建立一个神经网络我们可以直接运用 torch 中的体系. 先定义所有的层属性( __init__() ), 然后再一层层搭建( forward(x) )层于层的关系链接. 建立关系的时候, 我们会用到激励函数, 如果还不清楚激励函数用途的同学, 这里有非常好的一篇动画教程 (如下).
```
```
py
import
torch
import
torch.nn.functional
as
F
# 激励函数都在这
...
...
@@ -60,7 +60,7 @@ Net (
训练的步骤很简单, 如下:
```
```
py
# optimizer 是训练的工具
optimizer
=
torch
.
optim
.
SGD
(
net
.
parameters
(),
lr
=
0.5
)
# 传入 net 的所有参数, 学习率
loss_func
=
torch
.
nn
.
MSELoss
()
# 预测值和真实值的误差计算公式 (均方差)
...
...
@@ -79,7 +79,7 @@ for t in range(100):
为了可视化整个训练的过程, 更好的理解是如何训练, 我们如下操作:
```
```
py
import
matplotlib.pyplot
as
plt
plt
.
ion
()
# 画图
...
...
docs/pytorch/10.md
浏览文件 @
045dee58
...
...
@@ -8,7 +8,7 @@
我们创建一些假数据来模拟真实的情况. 比如两个二次分布的数据, 不过他们的均值都不一样.
```
```
py
import
torch
from
torch.autograd
import
Variable
import
matplotlib.pyplot
as
plt
...
...
@@ -39,7 +39,7 @@ plt.show()
建立一个神经网络我们可以直接运用 torch 中的体系. 先定义所有的层属性( __init__() ), 然后再一层层搭建( forward(x) )层于层的关系链接. 这个和我们在前面 regression 的时候的神经网络基本没差. 建立关系的时候, 我们会用到激励函数.
```
```
py
import
torch
import
torch.nn.functional
as
F
# 激励函数都在这
...
...
@@ -70,7 +70,7 @@ Net (
训练的步骤很简单, 如下:
```
```
py
# optimizer 是训练的工具
optimizer
=
torch
.
optim
.
SGD
(
net
.
parameters
(),
lr
=
0.02
)
# 传入 net 的所有参数, 学习率
# 算误差的时候, 注意真实值!不是! one-hot 形式的, 而是1D Tensor, (batch,)
...
...
@@ -91,7 +91,7 @@ for t in range(100):
为了可视化整个训练的过程, 更好的理解是如何训练, 我们如下操作:
```
```
py
import
matplotlib.pyplot
as
plt
plt
.
ion
()
# 画图
...
...
docs/pytorch/11.md
浏览文件 @
045dee58
...
...
@@ -6,7 +6,7 @@ Torch 中提供了很多方便的途径, 同样是神经网络, 能快则快,
我们先看看之前写神经网络时用到的步骤. 我们用 net1 代表这种方式搭建的神经网络.
```
```
py
class
Net
(
torch
.
nn
.
Module
):
def
__init__
(
self
,
n_feature
,
n_hidden
,
n_output
):
super
(
Net
,
self
).
__init__
()
...
...
@@ -23,7 +23,7 @@ net1 = Net(1, 10, 1) # 这是我们用这种方式搭建的 net1
我们用 class 继承了一个 torch 中的神经网络结构, 然后对其进行了修改, 不过还有更快的一招, 用一句话就概括了上面所有的内容!
```
```
py
net2
=
torch
.
nn
.
Sequential
(
torch
.
nn
.
Linear
(
1
,
10
),
torch
.
nn
.
ReLU
(),
...
...
@@ -33,7 +33,7 @@ net2 = torch.nn.Sequential(
我们再对比一下两者的结构:
```
```
py
print
(
net1
)
"""
Net (
...
...
docs/pytorch/12.md
浏览文件 @
045dee58
...
...
@@ -6,7 +6,7 @@
我们快速地建造数据, 搭建网络:
```
```
py
torch
.
manual_seed
(
1
)
# reproducible
# 假数据
...
...
@@ -35,7 +35,7 @@ def save():
接下来我们有两种途径来保存
```
```
py
torch
.
save
(
net1
,
\
'net.pkl
\'
) # 保存整个网络
torch.save(net1.state_dict(),
\'
net_params.pkl
\'
) # 只保存网络中的参数 (速度快, 占内存少)
```
...
...
@@ -44,7 +44,7 @@ torch.save(net1.state_dict(), \'net_params.pkl\') # 只保存网络中的参
这种方式将会提取整个神经网络, 网络大的时候可能会比较慢.
```
```
py
def
restore_net
():
# restore entire net1 to net2
net2
=
torch
.
load
(
\
'net.pkl
\'
)
...
...
@@ -55,7 +55,7 @@ def restore_net():
这种方式将会提取所有的参数, 然后再放到你的新建网络中.
```
```
py
def
restore_params
():
# 新建 net3
net3
=
torch
.
nn
.
Sequential
(
...
...
docs/pytorch/13.md
浏览文件 @
045dee58
...
...
@@ -2,7 +2,7 @@
DataLoader 是 torch 给你用来包装你的数据的工具. 所以你要讲自己的 (numpy array 或其他) 数据形式装换成 Tensor, 然后再放进这个包装器中. 使用 DataLoader 有什么好处呢? 就是他们帮你有效地迭代数据, 举例:
```
```
py
import
torch
import
torch.utils.data
as
Data
torch
.
manual_seed
(
1
)
# reproducible
...
...
@@ -45,7 +45,7 @@ Epoch: 2 | Step: 1 | batch x: [ 10\. 4\. 8\. 1\. 5.] | batch y: [ 1
真正方便的还不是这点. 如果我们改变一下 BATCH_SIZE = 8 , 这样我们就知道, step=0 会导出8个数据, 但是, step=1 时数据库中的数据不够 8个, 这时怎么办呢:
```
```
py
BATCH_SIZE
=
8
# 批训练的数据个数
...
...
...
docs/pytorch/14.md
浏览文件 @
045dee58
...
...
@@ -12,7 +12,7 @@
![](
img/2fc34594dcb247d4a3414467eed4a109.png
)
```
```
py
import
torch
import
torch.utils.data
as
Data
import
torch.nn.functional
as
F
...
...
@@ -42,7 +42,7 @@ loader = Data.DataLoader(dataset=torch_dataset, batch_size=BATCH_SIZE, shuffle=T
为了对比每一种优化器, 我们给他们各自创建一个神经网络, 但这个神经网络都来自同一个 Net 形式.
```
```
py
# 默认的 network 形式
class
Net
(
torch
.
nn
.
Module
):
def
__init__
(
self
):
...
...
@@ -67,7 +67,7 @@ nets = [net_SGD, net_Momentum, net_RMSprop, net_Adam]
接下来在创建不同的优化器, 用来训练不同的网络. 并创建一个 loss_func 用来计算误差. 我们用几种常见的优化器, SGD , Momentum , RMSprop , Adam .
```
```
py
# different optimizers
opt_SGD
=
torch
.
optim
.
SGD
(
net_SGD
.
parameters
(),
lr
=
LR
)
opt_Momentum
=
torch
.
optim
.
SGD
(
net_Momentum
.
parameters
(),
lr
=
LR
,
momentum
=
0.8
)
...
...
@@ -83,7 +83,7 @@ losses_his = [[], [], [], []] # 记录 training 时不同神经网络的 loss
接下来训练和 loss 画图.
```
```
py
for
epoch
in
range
(
EPOCH
):
print
(
\\
'Epoch:
\\
'
,
epoch
)
for
step
,
(
batch_x
,
batch_y
)
in
enumerate
(
loader
):
...
...
docs/pytorch/16.md
浏览文件 @
045dee58
...
...
@@ -8,7 +8,7 @@
## MNIST手写数据
```
```
py
import
torch
import
torch.nn
as
nn
from
torch.autograd
import
Variable
...
...
@@ -40,7 +40,7 @@ train_data = torchvision.datasets.MNIST(
同样, 我们除了训练数据, 还给一些测试数据, 测试看看它有没有训练好.
```
```
py
test_data
=
torchvision
.
datasets
.
MNIST
(
root
=
\\
'./mnist/
\\
'
,
train
=
False
)
# 批训练 50samples, 1 channel, 28x28 (50, 1, 28, 28)
...
...
@@ -55,7 +55,7 @@ test_y = test_data.test_labels[:2000]
和以前一样, 我们用一个 class 来建立 CNN 模型. 这个 CNN 整体流程是 卷积( Conv2d ) -> 激励函数( ReLU ) -> 池化, 向下采样 ( MaxPooling ) -> 再来一遍 -> 展平多维的卷积成的特征图 -> 接入全连接层 ( Linear ) -> 输出
```
```
py
class
CNN
(
nn
.
Module
):
def
__init__
(
self
):
super
(
CNN
,
self
).
__init__
()
...
...
@@ -107,7 +107,7 @@ CNN (
下面我们开始训练, 将 y 都用 Variable 包起来, 然后放入 cnn 中计算 output, 最后再计算误差. 下面代码省略了计算精确度 accuracy 的部分, 如果想细看 accuracy 代码的同学, 请去往我的 github 看全部代码.
```
```
py
optimizer
=
torch
.
optim
.
Adam
(
cnn
.
parameters
(),
lr
=
LR
)
# optimize all cnn parameters
loss_func
=
nn
.
CrossEntropyLoss
()
# the target label is not one-hotted
...
...
@@ -134,7 +134,7 @@ Epoch: 0 | train loss: 0.0078 | test accuracy: 0.98
最后我们再来取10个数据, 看看预测的值到底对不对:
```
```
py
test_output
=
cnn
(
test_x
[:
10
])
pred_y
=
torch
.
max
(
test_output
,
1
)[
1
].
data
.
numpy
().
squeeze
()
print
(
pred_y
,
\\
'prediction number
\\
'
)
...
...
docs/pytorch/17.md
浏览文件 @
045dee58
...
...
@@ -8,7 +8,7 @@
## MNIST手写数据
```
```
py
import
torch
from
torch
import
nn
from
torch.autograd
import
Variable
...
...
@@ -42,7 +42,7 @@ train_data = torchvision.datasets.MNIST(
同样, 我们除了训练数据, 还给一些测试数据, 测试看看它有没有训练好.
```
```
py
test_data
=
torchvision
.
datasets
.
MNIST
(
root
=
\\
'./mnist/
\\
'
,
train
=
False
)
# 批训练 50samples, 1 channel, 28x28 (50, 1, 28, 28)
...
...
@@ -63,7 +63,7 @@ test_y = test_data.test_labels[:2000]
4.
(inputN, stateN)-> LSTM -> (outputN, stateN 1) ;
5.
outputN -> Linear -> prediction . 通过LSTM分析每一时刻的值, 并且将这一时刻和前面时刻的理解合并在一起, 生成当前时刻对前面数据的理解或记忆. 传递这种理解给下一时刻分析.
```
```
py
class
RNN
(
nn
.
Module
):
def
__init__
(
self
):
super
(
RNN
,
self
).
__init__
()
...
...
@@ -103,7 +103,7 @@ RNN (
我们将图片数据看成一个时间上的连续数据, 每一行的像素点都是这个时刻的输入, 读完整张图片就是从上而下的读完了每行的像素点. 然后我们就可以拿出 RNN 在最后一步的分析值判断图片是哪一类了. 下面的代码省略了计算 accuracy 的部分, 你可以在我的 github 中看到全部代码.
```
```
py
optimizer
=
torch
.
optim
.
Adam
(
rnn
.
parameters
(),
lr
=
LR
)
# optimize all parameters
loss_func
=
nn
.
CrossEntropyLoss
()
# the target label is not one-hotted
...
...
@@ -129,7 +129,7 @@ Epoch: 0 | train loss: 0.1868 | test accuracy: 0.96
最后我们再来取10个数据, 看看预测的值到底对不对:
```
```
py
test_output
=
rnn
(
test_x
[:
10
].
view
(
-
1
,
28
,
28
))
pred_y
=
torch
.
max
(
test_output
,
1
)[
1
].
data
.
numpy
().
squeeze
()
print
(
pred_y
,
\\
'prediction number
\\
'
)
...
...
docs/pytorch/18.md
浏览文件 @
045dee58
...
...
@@ -14,7 +14,7 @@
![](
img/22309cd02ee52b3a65e1f0022e8b964e.png
)
```
```
py
import
torch
from
torch
import
nn
from
torch.autograd
import
Variable
...
...
@@ -34,7 +34,7 @@ DOWNLOAD_MNIST = False # set to True if haven\'t download the data
这一次的 RNN, 我们对每一个 r_out 都得放到 Linear 中去计算出预测的 output , 所以我们能用一个 for loop 来循环计算.
**这点是 Tensorflow 望尘莫及的!**
除了这点, 还有一些动态的过程都可以在这个教程中查看, 看看我们的 PyTorch 和 Tensorflow 到底哪家强.
```
```
py
class
RNN
(
nn
.
Module
):
def
__init__
(
self
):
super
(
RNN
,
self
).
__init__
()
...
...
@@ -70,7 +70,7 @@ RNN (
其实熟悉 RNN 的朋友应该知道, forward 过程中的对每个时间点求输出还有一招使得计算量比较小的. 不过上面的内容主要是为了呈现 PyTorch 在动态构图上的优势, 所以我用了一个 for loop 来搭建那套输出系统. 下面介绍一个替换方式. 使用 reshape 的方式整批计算.
```
```
py
def
forward
(
self
,
x
,
h_state
):
r_out
,
h_state
=
self
.
rnn
(
x
,
h_state
)
r_out_reshaped
=
r_out
.
view
(
-
1
,
HIDDEN_SIZE
)
# to 2D data
...
...
@@ -84,7 +84,7 @@ def forward(self, x, h_state):
![](
img/f38868821469cadc36810cfd827511d1.png
)
```
```
py
optimizer
=
torch
.
optim
.
Adam
(
rnn
.
parameters
(),
lr
=
LR
)
# optimize all rnn parameters
loss_func
=
nn
.
MSELoss
()
...
...
docs/pytorch/19.md
浏览文件 @
045dee58
...
...
@@ -14,7 +14,7 @@
自编码只用训练集就好了, 而且只需要训练 training data 的 image, 不用训练 labels.
```
```
py
import
torch
import
torch.nn
as
nn
from
torch.autograd
import
Variable
...
...
@@ -46,7 +46,7 @@ train_data = torchvision.datasets.MNIST(
AutoEncoder 形式很简单, 分别是 encoder 和 decoder , 压缩和解压, 压缩后得到压缩的特征值, 再从压缩的特征值解压成原图片.
```
```
py
class
AutoEncoder
(
nn
.
Module
):
def
__init__
(
self
):
super
(
AutoEncoder
,
self
).
__init__
()
...
...
@@ -87,7 +87,7 @@ autoencoder = AutoEncoder()
![](
img/c429fb827df769a542339e200e2ea20c.png
)
```
```
py
optimizer
=
torch
.
optim
.
Adam
(
autoencoder
.
parameters
(),
lr
=
LR
)
loss_func
=
nn
.
MSELoss
()
...
...
@@ -113,7 +113,7 @@ for epoch in range(EPOCH):
3D 的可视化图挺有趣的, 还能挪动观看, 更加直观, 好理解.
```
```
py
# 要观看的数据
view_data
=
Variable
(
train_data
.
train_data
[:
200
].
view
(
-
1
,
28
*
28
).
type
(
torch
.
FloatTensor
)
/
255.
)
encoded_data
,
_
=
autoencoder
(
view_data
)
# 提取压缩的特征值
...
...
docs/pytorch/20.md
浏览文件 @
045dee58
...
...
@@ -8,7 +8,7 @@ Torch 是神经网络库, 那么也可以拿来做强化学习, 之前我用另
这次除了 Torch 自家模块, 我们还要导入 Gym 环境库模块.
```
```
py
import
torch
import
torch.nn
as
nn
from
torch.autograd
import
Variable
...
...
@@ -33,7 +33,7 @@ N_STATES = env.observation_space.shape[0] # 杆子能获取的环境信息数
DQN 当中的神经网络模式, 我们将依据这个模式建立两个神经网络, 一个是现实网络 (Target Net), 一个是估计网络 (Eval Net).
```
```
py
class
Net
(
nn
.
Module
):
def
__init__
(
self
,
):
super
(
Net
,
self
).
__init__
()
...
...
@@ -53,7 +53,7 @@ class Net(nn.Module):
简化的 DQN 体系是这样, 我们有两个 net, 有选动作机制, 有存经历机制, 有学习机制.
```
```
py
class
DQN
(
object
):
def
__init__
(
self
):
# 建立 target net 和 eval net 还有 memory
...
...
@@ -72,7 +72,7 @@ class DQN(object):
接下来就是具体的啦, 在 DQN 中每个功能都是怎么做的.
```
```
py
class
DQN
(
object
):
def
__init__
(
self
):
self
.
eval_net
,
self
.
target_net
=
Net
(),
Net
()
...
...
@@ -130,7 +130,7 @@ class DQN(object):
按照 Qlearning 的形式进行 off-policy 的更新. 我们进行回合制更行, 一个回合完了, 进入下一回合. 一直到他们将杆子立起来很久.
```
```
py
dqn
=
DQN
()
# 定义 DQN 系统
for
i_episode
in
range
(
400
):
...
...
docs/pytorch/21.md
浏览文件 @
045dee58
...
...
@@ -12,7 +12,7 @@ GAN 是一个近几年比较流行的生成网络形式. 对比起传统的生
新手画家 (Generator) 在作画的时候需要有一些灵感 (random noise), 我们这些灵感的个数定义为 N_IDEAS . 而一幅画需要有一些规格, 我们将这幅画的画笔数定义一下, N_COMPONENTS 就是一条一元二次曲线(这幅画画)上的点个数. 为了进行批训练, 我们将一整批话的点都规定一下( PAINT_POINTS ).
```
```
py
import
torch
import
torch.nn
as
nn
from
torch.autograd
import
Variable
...
...
@@ -35,7 +35,7 @@ PAINT_POINTS = np.vstack([np.linspace(-1, 1, ART_COMPONENTS) for _ in range(BATC
我们需要有很多画是来自著名画家的(real data), 将这些著名画家的画, 和新手画家的画都传给新手鉴赏家, 让鉴赏家来区分哪些是著名画家, 哪些是新手画家的画. 如何区分我们在后面呈现. 这里我们生成一些著名画家的画 (batch 条不同的一元二次方程曲线).
```
```
py
def
artist_works
():
# painting from the famous artist (real target)
a
=
np
.
random
.
uniform
(
1
,
2
,
size
=
BATCH_SIZE
)[:,
np
.
newaxis
]
paintings
=
a
*
np
.
power
(
PAINT_POINTS
,
2
)
(
a
-
1
)
...
...
@@ -53,7 +53,7 @@ def artist_works(): # painting from the famous artist (real target)
D 会接收一幅画作 (一元二次曲线), 输出这幅画作到底是不是著名画家的画(是著名画家的画的概率).
```
```
py
G
=
nn
.
Sequential
(
# Generator
nn
.
Linear
(
N_IDEAS
,
128
),
# random ideas (could from normal distribution)
nn
.
ReLU
(),
...
...
@@ -72,7 +72,7 @@ D = nn.Sequential( # Discriminator
接着我们来同时训练 D 和 G. 训练之前, 我们来看看G作画的原理. G 首先会有些灵感, G_ideas 就会拿到这些随机灵感 (可以是正态分布的随机数), 然后 G 会根据这些灵感画画. 接着我们拿着著名画家的画和 G 的画, 让 D 来判定这两批画作是著名画家画的概率.
```
```
py
for
step
in
range
(
10000
):
artist_paintings
=
artist_works
()
# real painting from artist
G_ideas
=
Variable
(
torch
.
randn
(
BATCH_SIZE
,
N_IDEAS
))
# random ideas
...
...
@@ -84,14 +84,14 @@ for step in range(10000):
然后计算有多少来之画家的画猜对了, 有多少来自 G 的画猜对了, 我们想最大化这些猜对的次数. 这也就是 log(D(x)) log(1-D(G(z)) 在
[
论文
](
https://www.pytorchtutorial.com/goto/https://arxiv.org/abs/1406.2661
)
中的形式. 而因为 torch 中提升参数的形式是最小化误差, 那我们把最大化 score 转换成最小化 loss, 在两个 score 的合的地方加一个符号就好. 而 G 的提升就是要减小 D 猜测 G 生成数据的正确率, 也就是减小 D_score1.
```
```
py
D_loss
=
-
torch
.
mean
(
torch
.
log
(
prob_artist0
)
torch
.
log
(
1
\
.
-
prob_artist1
))
G_loss
=
torch
.
mean
(
torch
.
log
(
1
\
.
-
prob_artist1
))
```
最后我们在根据 loss 提升神经网络就好了.
```
```
py
opt_D
.
zero_grad
()
D_loss
.
backward
(
retain_variables
=
True
)
# retain_variables 这个参数是为了再次使用计算图纸
opt_D
.
step
()
...
...
docs/pytorch/23.md
浏览文件 @
045dee58
...
...
@@ -12,7 +12,7 @@
我们拿
[
这一节内容的 RNN
](
https://www.pytorchtutorial.com/4-3-rnn-for-regression/
)
来解释动态计算图. 那节内容的
[
代码在这
](
https://www.pytorchtutorial.com/goto/https://github.com/MorvanZhou/PyTorch-Tutorial/blob/master/tutorial-contents/11_RNN_regressor.py
)
.
```
```
py
..
######################## 前面代码都一样, 下面开始不同 #########################
...
...
docs/pytorch/24.md
浏览文件 @
045dee58
...
...
@@ -9,7 +9,7 @@
这份 GPU 的代码是依据
[
之前这份CNN
](
https://www.pytorchtutorial.com/goto/https://github.com/MorvanZhou/PyTorch-Tutorial/blob/master/tutorial-contents/401_CNN.py
)
的代码修改的. 大概修改的地方包括将数据的形式变成 GPU 能读的形式, 然后将 CNN 也变成 GPU 能读的形式. 做法就是在后面加上 .cuda() , 很简单.
```
```
py
...
test_data
=
torchvision
.
datasets
.
MNIST
(
root
=
\
'./mnist/
\'
, train=False)
...
...
@@ -21,7 +21,7 @@ test_y = test_data.test_labels[:2000].cuda()
再来把我们的 CNN 参数也变成 GPU 兼容形式.
```
```
py
class
CNN
(
nn
.
Module
):
...
...
...
@@ -33,7 +33,7 @@ cnn.cuda() # Moves all model parameters and buffers to the GPU.
然后就是在 train 的时候, 将每次的training data 变成 GPU 形式. .cuda()
```
```
py
for
epoch
..:
for
step
,
...:
# !!!!!!!! 这里有修改 !!!!!!!!! #
...
...
docs/pytorch/25.md
浏览文件 @
045dee58
...
...
@@ -10,7 +10,7 @@
![](
img/761c210ceb0fdd69c7e0f8bd85e39698.png
)
```
```
py
import
torch
from
torch.autograd
import
Variable
import
matplotlib.pyplot
as
plt
...
...
@@ -42,7 +42,7 @@ plt.show()
我们在这里搭建两个神经网络, 一个没有 dropout, 一个有 dropout. 没有 dropout 的容易出现 过拟合, 那我们就命名为 net_overfitting, 另一个就是 net_dropped. torch.nn.Dropout(0.5) 这里的 0.5 指的是随机有 50% 的神经元会被关闭/丢弃.
```
```
py
net_overfitting
=
torch
.
nn
.
Sequential
(
torch
.
nn
.
Linear
(
1
,
N_HIDDEN
),
torch
.
nn
.
ReLU
(),
...
...
@@ -66,7 +66,7 @@ net_dropped = torch.nn.Sequential(
训练的时候, 这两个神经网络分开训练. 训练的环境都一样.
```
```
py
optimizer_ofit
=
torch
.
optim
.
Adam
(
net_overfitting
.
parameters
(),
lr
=
0.01
)
optimizer_drop
=
torch
.
optim
.
Adam
(
net_dropped
.
parameters
(),
lr
=
0.01
)
loss_func
=
torch
.
nn
.
MSELoss
()
...
...
@@ -92,7 +92,7 @@ for t in range(500):
![](
img/a545e4a49909bd7a80e042fd6d8267cb.png
)
```
```
py
...
optimizer_ofit
.
step
()
...
...
docs/pytorch/26.md
浏览文件 @
045dee58
...
...
@@ -14,7 +14,7 @@
![](
img/fedaa24e2fcad876c77a2038c2d8d14d.png
)
```
```
py
import
torch
from
torch.autograd
import
Variable
from
torch
import
nn
...
...
@@ -60,7 +60,7 @@ plt.show()
这里就教你如何构建带有 BN 的神经网络的. BN 其实可以看做是一个 layer ( BN layer ). 我们就像平时加层一样加 BN layer 就好了. 注意, 我还对输入数据进行了一个 BN 处理, 因为如果你把输入数据看出是 从前面一层来的输出数据, 我们同样也能对她进行 BN.
```
```
py
class
Net
(
nn
.
Module
):
def
__init__
(
self
,
batch_normalization
=
False
):
super
(
Net
,
self
).
__init__
()
...
...
@@ -108,7 +108,7 @@ nets = [Net(batch_normalization=False), Net(batch_normalization=True)]
训练的时候, 这两个神经网络分开训练. 训练的环境都一样.
```
```
py
opts
=
[
torch
.
optim
.
Adam
(
net
.
parameters
(),
lr
=
LR
)
for
net
in
nets
]
loss_func
=
torch
.
nn
.
MSELoss
()
...
...
@@ -132,7 +132,7 @@ for epoch in range(EPOCH):
![](
img/cb2138c3f800c7ca4b5ae38076d09429.png
)
```
```
py
f
,
axs
=
plt
.
subplots
(
4
,
N_HIDDEN
1
,
figsize
=
(
10
,
5
))
def
plot_histogram
(
l_in
,
l_in_bn
,
pre_ac
,
pre_ac_bn
):
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录