pytorch神经网络实现

pytorch神经网络实现

包括CNN、RNN、LSTM等神经网络的介绍以及PyTorch实现。

卷积神经网络(CNN)

CNN(Convolutional Neural Network)

卷积

“卷积” 和 “神经网络”。卷积也就是说神经网络不再是对每个像素的输入信息做处理了,而是图片上每一小块像素区域进行处理，这种做法加强了图片信息的连续性。使得神经网络能看到图形，而非一个点。这种做法同时也加深了神经网络对图片的理解。具体来说，卷积神经网络有一个批量过滤器，持续不断的在图片上滚动收集图片里的信息,每一次收集的时候都只是收集一小块像素区域，然后把收集来的信息进行整理，这时候整理出来的信息有了一些实际上的呈现，比如这时的神经网络能看到一些边缘的图片信息，然后在以同样的步骤，用类似的批量过滤器扫过产生的这些边缘信息，神经网络从这些边缘信息里面总结出更高层的信息结构,比如说总结的边缘能够画出眼睛,鼻子等等。再经过一次过滤，脸部的信息也从这些眼睛鼻子的信息中被总结出来。最后我们再把这些信息套入几层普通的全连接神经层进行分类，这样就能得到输入的图片能被分为哪一类的结果了.

卷积核(core) -> 高度的维度

池化(pooling)

研究发现，在每一次卷积的时候，神经层可能会无意地丢失一些信息。这时，池化 (pooling) 就可以很好地解决这一问题。而且池化是一个筛选过滤的过程，能将 layer 中有用的信息筛选出来，给下一个层分析。同时也减轻了神经网络的计算负担 (具体细节参考)。也就是说在卷集的时候，我们不压缩长宽，尽量地保留更多信息，压缩的工作就交给池化了,这样的一项附加工作能够很有效的提高准确性。有了这些技术,我们就可以搭建一个属于我们自己的卷积神经网络啦.

流行的CNN结构

比较流行的一种搭建结构是这样，从下到上的顺序，首先是输入的图片(image)，经过一层卷积层 (convolution)，然后在用池化(pooling)方式处理卷积的信息，这里使用的是 max pooling 的方式。然后在经过一次同样的处理，把得到的第二次处理的信息传入两层全连接的神经层 (fully connected),这也是一般的两层神经网络层,最后在接上一个分类器(classifier)进行分类预测。这仅仅是对卷积神经网络在图片处理上一次简单的介绍。如果你想知道使用 python 搭建这样的卷积神经网络，欢迎点击下面的内容.

PyTorch搭建CNN

卷积神经网络目前被广泛地用在图片识别上，已经有层出不穷的应用，如果你对卷积神经网络还没有特别了解，我制作的 卷积神经网络 动画简介 能让你花几分钟就了解什么是卷积神经网络。接着我们就一步一步做一个分析手写数字的 CNN 吧。

# library
# standard library
import os

# third-party library
import torch
import torch.nn as nn
import torch.utils.data as Data
import torchvision
import matplotlib.pyplot as plt

# torch.manual_seed(1)    # reproducible

# Hyper Parameters
EPOCH = 1               # train the training data n times，to save time，we just train 1 epoch
BATCH_SIZE = 50
LR = 0.001              # learning rate
DOWNLOAD_MNIST = False


# Mnist digits dataset
if not(os.path.exists('./mnist/')) or not os.listdir('./mnist/'):
    # not mnist dir or mnist is empyt dir
    DOWNLOAD_MNIST = True

train_data = torchvision.datasets.MNIST(
    root='./mnist/',
    train=True，                                    # this is training data
    transform=torchvision.transforms.ToTensor()，   # Converts a PIL.Image or numpy.ndarray to
    # torch.FloatTensor of shape (C x H x W) and normalize in the range [0.0，1.0]
    download=DOWNLOAD_MNIST,
)

# plot one example
print(train_data.train_data.size())                 # (60000，28，28)
print(train_data.train_labels.size())               # (60000)
plt.imshow(train_data.train_data[0].numpy()，cmap='gray')
plt.title('%i' % train_data.train_labels[0])
plt.show()

# Data Loader for easy mini-batch return in training，the image batch shape will be (50，1，28，28)
train_loader = Data.DataLoader(dataset=train_data，batch_size=BATCH_SIZE，shuffle=True)

# pick 2000 samples to speed up testing
test_data = torchvision.datasets.MNIST(root='./mnist/'，train=False)
test_x = torch.unsqueeze(test_data.test_data，dim=1).type(torch.FloatTensor)[:2000]/255。  # shape from (2000，28，28) to (2000，1，28，28)，value in range(0,1)
test_y = test_data.test_labels[:2000]


class CNN(nn.Module):
    def __init__(self):
        super(CNN，self).__init__()
        # 卷积层1
        self.conv1 = nn.Sequential(         # input shape (1，28，28)
            nn.Conv2d(
                in_channels=1，             # input height
                out_channels=16，           # n_filters
                kernel_size=5，             # filter size
                stride=1，                  # filter movement/step
                padding=2，                 # if want same width and length of this image after Conv2d，padding=(kernel_size-1)/2 if stride=1
            )，                             # output shape (16，28，28)
            nn.ReLU()，                     # activation
            nn.MaxPool2d(kernel_size=2)，   # choose max value in 2x2 area，output shape (16，14，14)
        )
        # 卷积层2
        self.conv2 = nn.Sequential(         # input shape (16，14，14)
            nn.Conv2d(16，32，5，1，2)，    # output shape (32，14，14)
            nn.ReLU()，                     # activation
            nn.MaxPool2d(2)，               # output shape (32，7，7)
        )
        self.out = nn.Linear(32 * 7 * 7，10)   # fully connected layer，output 10 classes

    def forward(self，x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0)，-1)           # flatten the output of conv2 to (batch_size，32 * 7 * 7)
        output = self.out(x)
        return output，x    # return x for visualization


cnn = CNN()
print(cnn)  # net architecture

optimizer = torch.optim.Adam(cnn.parameters()，lr=LR)   # optimize all cnn parameters
loss_func = nn.CrossEntropyLoss()                       # the target label is not one-hotted

# following function (plot_with_labels) is for visualization，can be ignored if not interested
from matplotlib import cm
try: from sklearn.manifold import TSNE; HAS_SK = True
except: HAS_SK = False; print('Please install sklearn for layer visualization')
def plot_with_labels(lowDWeights，labels):
    plt.cla()
    X，Y = lowDWeights[:，0]，lowDWeights[:，1]
    for x，y，s in zip(X，Y，labels):
        c = cm.rainbow(int(255 * s / 9)); plt.text(x，y，s，backgroundcolor=c，fontsize=9)
    plt.xlim(X.min()，X.max()); plt.ylim(Y.min()，Y.max()); plt.title('Visualize last layer'); plt.show(); plt.pause(0.01)


plt.ion()
# training and testing
for epoch in range(EPOCH):
    for step，(b_x，b_y) in enumerate(train_loader):   # gives batch data，normalize x when iterate train_loader

        output = cnn(b_x)[0]               # cnn output
        loss = loss_func(output，b_y)   # cross entropy loss
        optimizer.zero_grad()           # clear gradients for this training step
        loss.backward()                 # backpropagation，compute gradients
        optimizer.step()                # apply gradients

        if step % 50 == 0:
            test_output，last_layer = cnn(test_x)
            pred_y = torch.max(test_output，1)[1].data.numpy()
            accuracy = float((pred_y == test_y.data.numpy()).astype(int).sum()) / float(test_y.size(0))
            print('Epoch: '，epoch，'| train loss: %.4f' % loss.data.numpy()，'| test accuracy: %.2f' % accuracy)
            if HAS_SK:
                # Visualization of trained flatten layer (T-SNE)
                tsne = TSNE(perplexity=30，n_components=2，init='pca'，n_iter=5000)
                plot_only = 500
                low_dim_embs = tsne.fit_transform(last_layer.data.numpy()[:plot_only，:])
                labels = test_y.numpy()[:plot_only]
                plot_with_labels(low_dim_embs，labels)
plt.ioff()

# print 10 predictions from test data
test_output，_ = cnn(test_x[:10])
pred_y = torch.max(test_output，1)[1].data.numpy()
print(pred_y，'prediction number')
print(test_y[:10].numpy()，'real number')

RNN循环神经网络

序列数据
数据关联

LSTM RNN

解决问题：
1.梯度消失（梯度弥散）
2.梯度爆炸

主线：长期记忆
分线：短期记忆

PyTorch实现RNN

我们将图片数据看成一个时间上的连续数据，每一行的像素点都是这个时刻的输入，读完整张图片就是从上而下的读完了每行的像素点。 然后我们就可以拿出 RNN 在最后一步的分析值判断图片是哪一类了。这里基于mnist数据集，每个样本数据为28*28的大小，一次输入28个像素数据，一共输入28行数据形成时间序列的建立。

• classfication

import torch
from torch import nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms
import matplotlib.pyplot as plt


# torch.manual_seed(1)    # reproducible

# Hyper Parameters
EPOCH = 1               # train the training data n times，to save time，we just train 1 epoch
BATCH_SIZE = 64
TIME_STEP = 28          # rnn time step / image height  输出次数
INPUT_SIZE = 28         # rnn input size / image width  一次数据输入量
LR = 0.01               # learning rate
DOWNLOAD_MNIST = False   # set to True if haven't download the data


# Mnist digital dataset
train_data = dsets.MNIST(
    root='./mnist/',
    train=True，                        # this is training data
    transform=transforms.ToTensor()，   # Converts a PIL.Image or numpy.ndarray to
                                        # torch.FloatTensor of shape (C x H x W) and normalize in the range [0.0，1.0]
    download=DOWNLOAD_MNIST，           # download it if you don't have it
)

# plot one example
print(train_data.train_data.size())     # (60000，28，28)
print(train_data.train_labels.size())   # (60000)
plt.imshow(train_data.train_data[0].numpy()，cmap='gray')
plt.title('%i' % train_data.train_labels[0])
plt.show()

# Data Loader for easy mini-batch return in training
train_loader = torch.utils.data.DataLoader(dataset=train_data，batch_size=BATCH_SIZE，shuffle=True)

# convert test data into Variable，pick 2000 samples to speed up testing
test_data = dsets.MNIST(root='./mnist/'，train=False，transform=transforms.ToTensor())
test_x = test_data.test_data.type(torch.FloatTensor)[:2000]/255。  # shape (2000，28，28) value in range(0,1)
test_y = test_data.test_labels.numpy()[:2000]    # covert to numpy array


class RNN(nn.Module):
    def __init__(self):
        super(RNN，self).__init__()

        self.rnn = nn.LSTM(         # if use nn.RNN()，it hardly learns
            input_size=INPUT_SIZE,
            hidden_size=64，        # rnn hidden unit
            num_layers=1，          # number of rnn layer
            batch_first=True，      # input & output will has batch size as 1s dimension。e.g。(batch，time_step，input_size) 数据格式
        )

        self.out = nn.Linear(64，10)

    def forward(self，x):
        # x shape (batch，time_step，input_size)
        # r_out shape (batch，time_step，output_size)
        # h_n shape (n_layers，batch，hidden_size)
        # h_c shape (n_layers，batch，hidden_size)
        r_out，(h_n，h_c) = self.rnn(x，None)   # None represents zero initial hidden state

        # choose r_out at the last time step
        out = self.out(r_out[:，-1，:])
        return out


rnn = RNN()
print(rnn)

optimizer = torch.optim.Adam(rnn.parameters()，lr=LR)   # optimize all cnn parameters
loss_func = nn.CrossEntropyLoss()                       # the target label is not one-hotted

# training and testing
for epoch in range(EPOCH):
    for step，(b_x，b_y) in enumerate(train_loader):        # gives batch data
        b_x = b_x.view(-1，28，28)              # reshape x to (batch，time_step，input_size) 第一个参数-1表示自动判断

        output = rnn(b_x)                               # rnn output
        loss = loss_func(output，b_y)                   # cross entropy loss
        optimizer.zero_grad()                           # clear gradients for this training step
        loss.backward()                                 # backpropagation，compute gradients
        optimizer.step()                                # apply gradients

        if step % 50 == 0:
            test_output = rnn(test_x)                   # (samples，time_step，input_size)
            pred_y = torch.max(test_output，1)[1].data.numpy()
            accuracy = float((pred_y == test_y).astype(int).sum()) / float(test_y.size)
            print('Epoch: '，epoch，'| train loss: %.4f' % loss.data.numpy()，'| test accuracy: %.2f' % accuracy)

# print 10 predictions from test data
test_output = rnn(test_x[:10].view(-1，28，28))
pred_y = torch.max(test_output，1)[1].data.numpy()
print(pred_y，'prediction number')
print(test_y[:10]，'real number')

• regression

import torch
from torch import nn
import numpy as np
import matplotlib.pyplot as plt

# torch.manual_seed(1)    # reproducible

# Hyper Parameters
TIME_STEP = 10      # rnn time step
INPUT_SIZE = 1      # rnn input size
LR = 0.02           # learning rate

# show data
steps = np.linspace(0，np.pi*2，100，dtype=np.float32)  # float32 for converting torch FloatTensor
x_np = np.sin(steps)
y_np = np.cos(steps)
plt.plot(steps，y_np，'r-'，label='target (cos)')
plt.plot(steps，x_np，'b-'，label='input (sin)')
plt.legend(loc='best')
plt.show()


class RNN(nn.Module):
    def __init__(self):
        super(RNN，self).__init__()

        self.rnn = nn.RNN(
            input_size=INPUT_SIZE,
            hidden_size=32，    # rnn hidden unit
            num_layers=1，      # number of rnn layer
            batch_first=True，  # input & output will has batch size as 1s dimension。e.g。(batch，time_step，input_size)
        )
        self.out = nn.Linear(32，1)

    def forward(self，x，h_state):
        # x (batch，time_step，input_size)
        # h_state (n_layers，batch，hidden_size)
        # r_out (batch，time_step，hidden_size)
        r_out，h_state = self.rnn(x，h_state)

        outs = []    # save all predictions
        for time_step in range(r_out.size(1)):    # calculate output for each time step
            outs.append(self.out(r_out[:，time_step，:]))
        return torch.stack(outs，dim=1)，h_state

        # instead，for simplicity，you can replace above codes by follows
        # r_out = r_out.view(-1，32)
        # outs = self.out(r_out)
        # outs = outs.view(-1，TIME_STEP，1)
        # return outs，h_state
        
        # or even simpler，since nn.Linear can accept inputs of any dimension 
        # and returns outputs with same dimension except for the last
        # outs = self.out(r_out)
        # return outs

rnn = RNN()
print(rnn)

optimizer = torch.optim.Adam(rnn.parameters()，lr=LR)   # optimize all cnn parameters
loss_func = nn.MSELoss()

h_state = None      # for initial hidden state

plt.figure(1，figsize=(12，5))
plt.ion()           # continuously plot

for step in range(100):
    start，end = step * np.pi，(step+1)*np.pi   # time range
    # use sin predicts cos
    steps = np.linspace(start，end，TIME_STEP，dtype=np.float32，endpoint=False)  # float32 for converting torch FloatTensor
    x_np = np.sin(steps)
    y_np = np.cos(steps)

    x = torch.from_numpy(x_np[np.newaxis，:，np.newaxis])    # shape (batch，time_step，input_size)
    y = torch.from_numpy(y_np[np.newaxis，:，np.newaxis])

    prediction，h_state = rnn(x，h_state)   # rnn output
    # !! next step is important !!
    h_state = h_state.data        # repack the hidden state，break the connection from last iteration

    loss = loss_func(prediction，y)         # calculate loss
    optimizer.zero_grad()                   # clear gradients for this training step
    loss.backward()                         # backpropagation，compute gradients
    optimizer.step()                        # apply gradients

    # plotting
    plt.plot(steps，y_np.flatten()，'r-')
    plt.plot(steps，prediction.data.numpy().flatten()，'b-')
    plt.draw(); plt.pause(0.05)

plt.ioff()
plt.show()

自编码（Autoencoder）

数据压缩再解压

有时神经网络要接受大量的输入信息，比如输入信息是高清图片时，输入信息量可能达到上千万，让神经网络直接从上千万个信息源中学习是一件很吃力的工作。所以，何不压缩一下，提取出原图片中的最具代表性的信息，缩减输入信息量，再把缩减过后的信息放进神经网络学习。这样学习起来就简单轻松了。所以，自编码就能在这时发挥作用。通过将原数据白色的X 压缩，解压 成黑色的X，然后通过对比黑白 X ,求出预测误差，进行反向传递，逐步提升自编码的准确性。训练好的自编码中间这一部分就是能总结原数据的精髓。可以看出，从头到尾，我们只用到了输入数据 X，并没有用到 X 对应的数据标签，所以也可以说自编码是一种非监督学习。到了真正使用自编码的时候。通常只会用到自编码前半部分。

MNIST实战

使用MINST手写数字数据进行压缩再解压的操作，用压缩的特征进行非监督学习。

自编码只用训练集就好了，而且只需要训练 training data 的 image，不用训练 labels。

import torch
import torch.nn as nn
import torch.utils.data as Data
import torchvision
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
import numpy as np


# torch.manual_seed(1)    # reproducible

# Hyper Parameters
EPOCH = 10
BATCH_SIZE = 64
LR = 0.005         # learning rate
DOWNLOAD_MNIST = False
N_TEST_IMG = 5

# Mnist digits dataset
train_data = torchvision.datasets.MNIST(
    root='./mnist/',
    train=True,                                     
    # this is training data
    transform=torchvision.transforms.ToTensor(),    
    # Converts a PIL.Image or numpy.ndarray to
    # torch.FloatTensor of shape (C x H x W) and normalize in the range [0.0, 1.0]
    download=DOWNLOAD_MNIST,                        
    # download it if you don't have it
)

# plot one example
print(train_data.train_data.size())     # (60000, 28, 28)
print(train_data.train_labels.size())   # (60000)
plt.imshow(train_data.train_data[2].numpy(), cmap='gray')
plt.title('%i' % train_data.train_labels[2])
plt.show()

# Data Loader for easy mini-batch return in training, the image batch shape will be (50, 1, 28, 28)
train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)


class AutoEncoder(nn.Module):
    def __init__(self):
        super(AutoEncoder, self).__init__()

        self.encoder = nn.Sequential(
            nn.Linear(28*28, 128),
            nn.Tanh(),
            nn.Linear(128, 64),
            nn.Tanh(),
            nn.Linear(64, 12),
            nn.Tanh(),
            nn.Linear(12, 3),   # compress to 3 features which can be visualized in plt
        )
        self.decoder = nn.Sequential(
            nn.Linear(3, 12),
            nn.Tanh(),
            nn.Linear(12, 64),
            nn.Tanh(),
            nn.Linear(64, 128),
            nn.Tanh(),
            nn.Linear(128, 28*28),
            nn.Sigmoid(),       # compress to a range (0, 1)
        )

    def forward(self, x):
        encoded = self.encoder(x)
        decoded = self.decoder(encoded)
        return encoded, decoded


autoencoder = AutoEncoder()

optimizer = torch.optim.Adam(autoencoder.parameters(), lr=LR)
loss_func = nn.MSELoss()

# initialize figure
f, a = plt.subplots(2, N_TEST_IMG, figsize=(5, 2))
plt.ion()   # continuously plot

# original data (first row) for viewing
view_data = train_data.train_data[:N_TEST_IMG].view(-1, 28*28).type(torch.FloatTensor)/255.
for i in range(N_TEST_IMG):
    a[0][i].imshow(np.reshape(view_data.data.numpy()[i], (28, 28)), cmap='gray'); a[0][i].set_xticks(()); a[0][i].set_yticks(())

for epoch in range(EPOCH):
    for step, (x, b_label) in enumerate(train_loader):
        b_x = x.view(-1, 28*28)   # batch x, shape (batch, 28*28)
        b_y = x.view(-1, 28*28)   # batch y, shape (batch, 28*28)

        encoded, decoded = autoencoder(b_x)

        loss = loss_func(decoded, b_y)      # mean square error
        optimizer.zero_grad()               # clear gradients for this training step
        loss.backward()                     # backpropagation, compute gradients
        optimizer.step()                    # apply gradients

        if step % 100 == 0:
            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy())

            # plotting decoded image (second row)
            _, decoded_data = autoencoder(view_data)
            for i in range(N_TEST_IMG):
                a[1][i].clear()
                a[1][i].imshow(np.reshape(decoded_data.data.numpy()[i], (28, 28)), cmap='gray')
                a[1][i].set_xticks(()); a[1][i].set_yticks(())
            plt.draw()
            plt.pause(0.05)

plt.ioff()
plt.show()

# visualize in 3D plot
view_data = train_data.train_data[:200].view(-1, 28*28).type(torch.FloatTensor)/255.
encoded_data, _ = autoencoder(view_data)
fig = plt.figure(2); ax = Axes3D(fig)
X, Y, Z = encoded_data.data[:, 0].numpy(), encoded_data.data[:, 1].numpy(), encoded_data.data[:, 2].numpy()
values = train_data.train_labels[:200].numpy()
for x, y, z, s in zip(X, Y, Z, values):
    c = cm.rainbow(int(255*s/9)); ax.text(x, y, z, s, backgroundcolor=c)
ax.set_xlim(X.min(), X.max()); ax.set_ylim(Y.min(), Y.max()); ax.set_zlim(Z.min(), Z.max())
plt.show()

GAN生成对抗网络(Generative Adversarial Networks)

"""
View more, visit my tutorial page: https://morvanzhou.github.io/tutorials/
My Youtube Channel: https://www.youtube.com/user/MorvanZhou

Dependencies:
torch: 0.4
numpy
matplotlib
"""
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt

# torch.manual_seed(1)    # reproducible
# np.random.seed(1)

# Hyper Parameters
BATCH_SIZE = 64
LR_G = 0.0001           # learning rate for generator
LR_D = 0.0001           # learning rate for discriminator
N_IDEAS = 5             # think of this as number of ideas for generating an art work (Generator)
ART_COMPONENTS = 15     # it could be total point G can draw in the canvas
PAINT_POINTS = np.vstack([np.linspace(-1, 1, ART_COMPONENTS) for _ in range(BATCH_SIZE)])

# show our beautiful painting range
# plt.plot(PAINT_POINTS[0], 2 * np.power(PAINT_POINTS[0], 2) + 1, c='#74BCFF', lw=3, label='upper bound')
# plt.plot(PAINT_POINTS[0], 1 * np.power(PAINT_POINTS[0], 2) + 0, c='#FF9359', lw=3, label='lower bound')
# plt.legend(loc='upper right')
# plt.show()


def artist_works_with_labels():     # painting from the famous artist (real target)
    a = np.random.uniform(1, 2, size=BATCH_SIZE)[:, np.newaxis]   # 在列上增加一个维度
    paintings_np = a * np.power(PAINT_POINTS, 2) + (a-1)
    labels_np = ((a-1) > 0.5)            # upper paintings (1), lower paintings (0), two classes
    paintings = torch.from_numpy(paintings_np).float()
    labels = torch.from_numpy(labels_np.astype(np.float32))
    return paintings, labels


G = nn.Sequential(                      # Generator
    nn.Linear(N_IDEAS+1, 128),          # random ideas (could from normal distribution) + class label
    nn.ReLU(),
    nn.Linear(128, ART_COMPONENTS),     # making a painting from these random ideas
)

D = nn.Sequential(                      # Discriminator
    nn.Linear(ART_COMPONENTS+1, 128),   # receive art work either from the famous artist or a newbie like G with label
    nn.ReLU(),
    nn.Linear(128, 1),
    nn.Sigmoid(),                       # tell the probability that the art work is made by artist
)

opt_D = torch.optim.Adam(D.parameters(), lr=LR_D)
opt_G = torch.optim.Adam(G.parameters(), lr=LR_G)

plt.ion()   # something about continuous plotting

for step in range(10000):
    artist_paintings, labels = artist_works_with_labels()           # real painting, label from artist
    G_ideas = torch.randn(BATCH_SIZE, N_IDEAS)                      # random ideas (BATCH_SIZE*N_IDEAS)
    G_inputs = torch.cat((G_ideas, labels), 1)                      # ideas with labels
    G_paintings = G(G_inputs)                                       # fake painting w.r.t label from G

    D_inputs0 = torch.cat((artist_paintings, labels), 1)            # all have their labels
    D_inputs1 = torch.cat((G_paintings, labels), 1)
    prob_artist0 = D(D_inputs0)                 # D try to increase this prob
    prob_artist1 = D(D_inputs1)                 # D try to reduce this prob

    D_score0 = torch.log(prob_artist0)          # maximise this for D  log以e为底数
    D_score1 = torch.log(1. - prob_artist1)     # maximise this for D
    D_loss = - torch.mean(D_score0 + D_score1)  # minimise the negative of both two above for Dd
    G_loss = torch.mean(D_score1)               # minimise D score w.r.t G

    opt_D.zero_grad()
    D_loss.backward(retain_graph=True)      # reusing computational graph
    opt_D.step()

    opt_G.zero_grad()
    G_loss.backward()
    opt_G.step()

    if step % 200 == 0:  # plotting
        plt.cla()
        plt.plot(PAINT_POINTS[0], G_paintings.data.numpy()[0], c='#4AD631', lw=3, label='Generated painting',)
        bound = [0, 0.5] if labels.data[0, 0] == 0 else [0.5, 1]
        plt.plot(PAINT_POINTS[0], 2 * np.power(PAINT_POINTS[0], 2) + bound[1], c='#74BCFF', lw=3, label='upper bound')
        plt.plot(PAINT_POINTS[0], 1 * np.power(PAINT_POINTS[0], 2) + bound[0], c='#FF9359', lw=3, label='lower bound')
        plt.text(-.5, 2.3, 'D accuracy=%.2f (0.5 for D to converge)' % prob_artist0.data.numpy().mean(), fontdict={'size': 13})
        plt.text(-.5, 2, 'D score= %.2f (-1.38 for G to converge)' % -D_loss.data.numpy(), fontdict={'size': 13})
        plt.text(-.5, 1.7, 'Class = %i' % int(labels.data[0, 0]), fontdict={'size': 13})
        plt.ylim((0, 3));plt.legend(loc='upper right', fontsize=10);plt.draw();plt.pause(0.1)

plt.ioff()
plt.show()

# plot a generated painting for upper class
z = torch.randn(1, N_IDEAS)
label = torch.FloatTensor([[1.]])     # for upper class
G_inputs = torch.cat((z, label), 1)
G_paintings = G(G_inputs)
plt.plot(PAINT_POINTS[0], G_paintings.data.numpy()[0], c='#4AD631', lw=3, label='G painting for upper class',)
plt.plot(PAINT_POINTS[0], 2 * np.power(PAINT_POINTS[0], 2) + bound[1], c='#74BCFF', lw=3, label='upper bound (class 1)')
plt.plot(PAINT_POINTS[0], 1 * np.power(PAINT_POINTS[0], 2) + bound[0], c='#FF9359', lw=3, label='lower bound (class 1)')
plt.ylim((0, 3)); plt.legend(loc='upper right', fontsize=10); plt.show()