diff --git a/docs/pytorch/03.md b/docs/pytorch/03.md index 8e58e77d1fbe1368952cabc45733217532e56a6c..147499efc4d48aefff36511516cf3380e8f484a9 100644 --- a/docs/pytorch/03.md +++ b/docs/pytorch/03.md @@ -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 ``` diff --git a/docs/pytorch/05.md b/docs/pytorch/05.md index 0e6631a8c269be1918e3095831a0850ef085a91a..6267ecf6551c4bc4eab52c8077837260e780991c 100644 --- a/docs/pytorch/05.md +++ b/docs/pytorch/05.md @@ -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 diff --git a/docs/pytorch/06.md b/docs/pytorch/06.md index 6303b9f36078928c2719bea19b4fa293520f31e0..5e2e4006c5b427ed030c9f651e5baaadb63015d6 100644 --- a/docs/pytorch/06.md +++ b/docs/pytorch/06.md @@ -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: diff --git a/docs/pytorch/07.md b/docs/pytorch/07.md index 4e88f9bd94e9eee91b1978f687060db9df5ee21b..a69986c3a6a35bca4fa052b788531e2613c7ebd9 100644 --- a/docs/pytorch/07.md +++ b/docs/pytorch/07.md @@ -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)) diff --git a/docs/pytorch/09.md b/docs/pytorch/09.md index 5d61c40dbf994fa421e8ace2e2e9732e24e4bacf..084789e67022e23805879ce8c1f59498360dab60 100644 --- a/docs/pytorch/09.md +++ b/docs/pytorch/09.md @@ -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() # 画图 diff --git a/docs/pytorch/10.md b/docs/pytorch/10.md index 71ccfeed84ec13894094f86de1619c5252f4a9d5..4d19bdbc76da0bc12ba8c4ca694d96d04a4f00b4 100644 --- a/docs/pytorch/10.md +++ b/docs/pytorch/10.md @@ -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() # 画图 diff --git a/docs/pytorch/11.md b/docs/pytorch/11.md index 1572a3cac5dcb342777d6fac649d1bdc2b6b459c..348f809f402bb0978734dcf7243d2106e7184d55 100644 --- a/docs/pytorch/11.md +++ b/docs/pytorch/11.md @@ -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 ( diff --git a/docs/pytorch/12.md b/docs/pytorch/12.md index 42c8326a673ffd5ba31b83dce34f95bc9c8b1079..1753d5d75dffaabdda045d14eb6ad6262eafad5d 100644 --- a/docs/pytorch/12.md +++ b/docs/pytorch/12.md @@ -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( diff --git a/docs/pytorch/13.md b/docs/pytorch/13.md index c0b46433d84cfad5817650cd6286a0b6a850e296..eebda76f8c2c0bc5f7bd43252452c29372a59c02 100644 --- a/docs/pytorch/13.md +++ b/docs/pytorch/13.md @@ -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 # 批训练的数据个数 ... diff --git a/docs/pytorch/14.md b/docs/pytorch/14.md index ba244ced8142b41d16259cac4fe07741be579a6c..1e3b5885e36c7c777586e15cac745275ebd00052 100644 --- a/docs/pytorch/14.md +++ b/docs/pytorch/14.md @@ -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): diff --git a/docs/pytorch/16.md b/docs/pytorch/16.md index 07e2fb35028b7fe95e5274c94bcd1898db6ff72f..802f7de12d285914c6f2be9d46b1e76034c675e9 100644 --- a/docs/pytorch/16.md +++ b/docs/pytorch/16.md @@ -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\\') diff --git a/docs/pytorch/17.md b/docs/pytorch/17.md index 5ee3376e8b771daba5b4ea86054a789fd0423fe9..9e3818025f939c505891c0086bca2a4c16303dd4 100644 --- a/docs/pytorch/17.md +++ b/docs/pytorch/17.md @@ -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\\') diff --git a/docs/pytorch/18.md b/docs/pytorch/18.md index bf5940e3d9166a6dacd11cec991188c0a7333911..0852c6eea123ee98f819742f2b636569d98ff750 100644 --- a/docs/pytorch/18.md +++ b/docs/pytorch/18.md @@ -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() diff --git a/docs/pytorch/19.md b/docs/pytorch/19.md index 9ab0af4e3dd46930d43e877f862beed8299ad9fe..7bdef0f7588a1457ee9ef42ce381fa10ec01f800 100644 --- a/docs/pytorch/19.md +++ b/docs/pytorch/19.md @@ -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) # 提取压缩的特征值 diff --git a/docs/pytorch/20.md b/docs/pytorch/20.md index c785c36ecd0cb09c9b666fae083a65f27f0c7c66..b4f13eb0776cc7c0c4c4f9248b62d152cc555afa 100644 --- a/docs/pytorch/20.md +++ b/docs/pytorch/20.md @@ -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): diff --git a/docs/pytorch/21.md b/docs/pytorch/21.md index 925b61519687b3a544c04162b55b74d78484c8af..e42310f4006139feaaf50d4d3b9020961a316ad8 100644 --- a/docs/pytorch/21.md +++ b/docs/pytorch/21.md @@ -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() diff --git a/docs/pytorch/23.md b/docs/pytorch/23.md index 321f188775d256a1868f72cc3b915a203822a8e6..1cdf42584bf509f4396c83c67d2ef243e1796475 100644 --- a/docs/pytorch/23.md +++ b/docs/pytorch/23.md @@ -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 .. ######################## 前面代码都一样, 下面开始不同 ######################### diff --git a/docs/pytorch/24.md b/docs/pytorch/24.md index fa1e7293b23ba6b53bc65e78dda52dd41e814ed4..58cb31ef12f4992f8ef8ea593202092a3fcaf426 100644 --- a/docs/pytorch/24.md +++ b/docs/pytorch/24.md @@ -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, ...: # !!!!!!!! 这里有修改 !!!!!!!!! # diff --git a/docs/pytorch/25.md b/docs/pytorch/25.md index bb75711b2054846e3d66ed78a1c1a97f58b51b4c..bada45b1a9b9da0a2b1d16e9606acbd96bf503b3 100644 --- a/docs/pytorch/25.md +++ b/docs/pytorch/25.md @@ -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() diff --git a/docs/pytorch/26.md b/docs/pytorch/26.md index c5d046420870bf6e72923c4ece45d30cf389bfa5..866a5ceee3c18755014263a6ab9a1249166b210d 100644 --- a/docs/pytorch/26.md +++ b/docs/pytorch/26.md @@ -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):