【Pytorch教程】：區分類型 (分類)

Pytorch教程目錄

Torch and Numpy

變量 (Variable)

激勵函數

關系拟合（回歸）

區分類型 (分類)

快速搭建法

批訓練

加速神經網絡訓練

Optimizer優化器

卷積神經網絡 CNN

卷積神經網絡（RNN、LSTM）

RNN 循環神經網絡 (分類)

RNN 循環神經網絡 (回歸)

自編碼 (Autoencoder)

DQN 強化學習

生成對抗網絡 (GAN)

為什麼 Torch 是動态的

GPU 加速運算

過拟合 (Overfitting)

批标準化 (Batch Normalization)

目錄

• Pytorch教程目錄
• 建立資料集
• 建立神經網絡
• 訓練網絡
• 可視化訓練過程
• • torch.max
  • [torch.unsqueeze & torch.squeeze](https://blog.csdn.net/nanke_4869/article/details/113410598)
• 全部代碼

建立資料集

我們建立一些假資料來模拟真實的情況. 比如兩個二次分布的資料, 不過他們的均值都不一樣.

import torch
import matplotlib.pyplot as plt

# 假資料
n_data = torch.ones(100, 2)         # 資料的基本形态
x0 = torch.normal(2*n_data, 1)      # 類型0 x data (tensor), shape=(100, 2)
y0 = torch.zeros(100)               # 類型0 y data (tensor), shape=(100, 1)
x1 = torch.normal(-2*n_data, 1)     # 類型1 x data (tensor), shape=(100, 2)
y1 = torch.ones(100)                # 類型1 y data (tensor), shape=(100, 1)

# 注意 x, y 資料的資料形式是一定要像下面一樣 (torch.cat 是在合并資料, 按維數0（行）拼接) 
x = torch.cat((x0, x1), 0).type(torch.FloatTensor)  # FloatTensor = 32-bit floating
y = torch.cat((y0, y1), ).type(torch.LongTensor)    # LongTensor = 64-bit integer

# 畫圖
plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn')
plt.show()

# plt.scatter(x.data.numpy(), y.data.numpy())
# plt.show()
           

建立神經網絡

建立一個神經網絡我們可以直接運用 torch 中的體系. 先定義所有的層屬性(

__init__()

), 然後再一層層搭建(

forward(x)

)層于層的關系連結. 這個和我們在前面 regression 的時候的神經網絡基本沒差. 建立關系的時候, 我們會用到激勵函數

import torch
import torch.nn.functional as F     # 激勵函數都在這

class Net(torch.nn.Module):     # 繼承 torch 的 Module
    def __init__(self, n_feature, n_hidden, n_output):
        super(Net, self).__init__()     # 繼承 __init__ 功能
        self.hidden = torch.nn.Linear(n_feature, n_hidden)   # 隐藏層線性輸出
        self.out = torch.nn.Linear(n_hidden, n_output)       # 輸出層線性輸出

    def forward(self, x):
        # 正向傳播輸入值, 神經網絡分析出輸出值
        x = F.relu(self.hidden(x))      # 激勵函數(隐藏層的線性值)
        x = self.out(x)                 # 輸出值, 但是這個不是預測值, 預測值還需要再另外計算
        return x

net = Net(n_feature=2, n_hidden=10, n_output=2) # 幾個類别就幾個 output

print(net)  # net 的結構
"""
Net (
  (hidden): Linear (2 -> 10)
  (out): Linear (10 -> 2)
)
"""
           

訓練網絡

訓練的步驟很簡單, 如下:

# optimizer 是訓練的工具
optimizer = torch.optim.SGD(net.parameters(), lr=0.02)  # 傳入 net 的所有參數, 學習率
# 算誤差的時候, 注意真實值!不是! one-hot 形式的, 而是1D Tensor, (batch,)
# 但是預測值是2D tensor (batch, n_classes)
loss_func = torch.nn.CrossEntropyLoss()

for t in range(100):
    out = net(x)     # 喂給 net 訓練資料 x, 輸出分析值

    loss = loss_func(out, y)     # 計算兩者的誤差

    optimizer.zero_grad()   # 清空上一步的殘餘更新參數值
    loss.backward()         # 誤差反向傳播, 計算參數更新值
    optimizer.step()        # 将參數更新值施加到 net 的 parameters 上
           

import matplotlib.pyplot as plt

plt.ion()   # 畫圖
plt.show()

for t in range(100):
    out = net(x)     # 喂給 net 訓練資料 x, 輸出分析值

    loss = loss_func(out, y)     # 計算兩者的誤差

    optimizer.zero_grad()   # 清空上一步的殘餘更新參數值
    loss.backward()
    optimizer.step()

    # 接着上面來
    if t % 2 == 0:
        plt.cla()
        # 過了一道 softmax 的激勵函數後的最大機率才是預測值
        prediction = torch.max(F.softmax(out), 1)[1]
        pred_y = prediction.data.numpy().squeeze()
        target_y = y.data.numpy()
        plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=pred_y, s=100, lw=0, cmap='RdYlGn')
        accuracy = sum(pred_y == target_y)/200.  # 預測中有多少和真實值一樣
        plt.text(1.5, -4, 'Accuracy=%.2f' % accuracy, fontdict={'size': 20, 'color':  'red'})
        plt.pause(0.1)

plt.ioff()  # 停止畫圖
plt.show()
           

torch.unsqueeze & torch.squeeze

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt

# torch.manual_seed(1)    # reproducible

# make fake data
n_data = torch.ones(100, 2)
x0 = torch.normal(2*n_data, 1)      # class0 x data (tensor), shape=(100, 2)
y0 = torch.zeros(100)               # class0 y data (tensor), shape=(100, 1)
x1 = torch.normal(-2*n_data, 1)     # class1 x data (tensor), shape=(100, 2)
y1 = torch.ones(100)                # class1 y data (tensor), shape=(100, 1)
x = torch.cat((x0, x1), 0).type(torch.FloatTensor)  # shape (200, 2) FloatTensor = 32-bit floating
y = torch.cat((y0, y1), ).type(torch.LongTensor)    # shape (200,) LongTensor = 64-bit integer

# The code below is deprecated in Pytorch 0.4. Now, autograd directly supports tensors
# x, y = Variable(x), Variable(y)

# plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn')
# plt.show()


class Net(torch.nn.Module):
    def __init__(self, n_feature, n_hidden, n_output):
        super(Net, self).__init__()
        self.hidden = torch.nn.Linear(n_feature, n_hidden)   # hidden layer
        self.out = torch.nn.Linear(n_hidden, n_output)   # output layer

    def forward(self, x):
        x = F.relu(self.hidden(x))      # activation function for hidden layer
        x = self.out(x)
        return x

net = Net(n_feature=2, n_hidden=10, n_output=2)     # define the network
print(net)  # net architecture

optimizer = torch.optim.SGD(net.parameters(), lr=0.02)
loss_func = torch.nn.CrossEntropyLoss()  # the target label is NOT an one-hotted

plt.ion()   # something about plotting

for t in range(100):
    out = net(x)                 # input x and predict based on x
    loss = loss_func(out, y)     # must be (1. nn output, 2. target), the target label is NOT one-hotted

    optimizer.zero_grad()   # clear gradients for next train
    loss.backward()         # backpropagation, compute gradients
    optimizer.step()        # apply gradients

    if t % 2 == 0:
        # plot and show learning process
        plt.cla()
        prediction = torch.max(out, 1)[1]
        pred_y = prediction.data.numpy()
        target_y = y.data.numpy()
        plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=pred_y, s=100, lw=0, cmap='RdYlGn')
        accuracy = float((pred_y == target_y).astype(int).sum()) / float(target_y.size)
        plt.text(1.5, -4, 'Accuracy=%.2f' % accuracy, fontdict={'size': 20, 'color':  'red'})
        plt.pause(0.1)

plt.ioff()
plt.show()