2020-10-19 21:48:57

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
 ```

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

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:

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))

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()   # 画图

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()   # 画图

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 (

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(

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      # 批训练的数据个数
 
 ...

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):

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\\')

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\\')

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()
 

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)    # 提取压缩的特征值

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):

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()

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
 ..
 
 ######################## 前面代码都一样, 下面开始不同 #########################

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, ...:
         # !!!!!!!! 这里有修改 !!!!!!!!! #

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()

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):