PyTorch学习4

PyTorch 实现多层网络
引入模块，读取数据
构建计算图（构建网络模型）
损失函数与优化器
开始训练模型
对训练的模型预测结果进行评估

import torch
import numpy as np
from torch import nn
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt
def plot_decision_boundary(model, x, y):
    # Set min and max values and give it some padding
    x_min, x_max = x[:, 0].min() - 1, x[:, 0].max() + 1
    y_min, y_max = x[:, 1].min() - 1, x[:, 1].max() + 1
    h = 0.01
    # Generate a grid of points with distance h between them
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
    # Predict the function value for the whole grid
    Z = model(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    # Plot the contour and training examples
    plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
    plt.ylabel('x2')
    plt.xlabel('x1')
    plt.scatter(x[:, 0], x[:, 1], c=y.reshape(-1), s=40, cmap=plt.cm.Spectral)
def draw_picture():    
    np.random.seed(1)
    m = 400 # 样本数量
    N = int(m/2) # 每一类的点的个数
    D = 2 # 维度
    x = np.zeros((m, D))
    y = np.zeros((m, 1), dtype='uint8') # label 向量，0 表示红色，1 表示蓝色
    a = 4
    for j in range(2):
        ix = range(N*j,N*(j+1))
        t = np.linspace(j*3.12,(j+1)*3.12,N) + np.random.randn(N)*0.2 # theta
        r = a*np.sin(4*t) + np.random.randn(N)*0.2 # radius
        x[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
        y[ix] = j
    plt.scatter(x[:, 0], x[:, 1], c=y.reshape(-1), s=40, cmap=plt.cm.Spectral)
    plt.show()
    plt.close()
    return x,y
def logistic_regression(x,w,b):
    return torch.mm(x, w) + b
def plot_logistic(x,w,b):
    x = Variable(torch.from_numpy(x).float())
    out = F.sigmoid(logistic_regression(x,w,b))
    out = (out > 0.5) * 1
    return out.data.numpy()
def logistic_train(x,y):
    x = torch.from_numpy(x).float()
    y = torch.from_numpy(y).float()
    w = nn.Parameter(torch.randn(2, 1))
    b = nn.Parameter(torch.zeros(1))
    optimizer = torch.optim.SGD([w, b], 1e-1)
 
    criterion = nn.BCEWithLogitsLoss()
    
    for e in range(100):
        out = logistic_regression(Variable(x),w,b)
        loss = criterion(out, Variable(y))
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        if (e + 1) % 20 == 0:
            print('epoch: {}, loss: {}'.format(e+1, loss.item()))
    plot_decision_boundary(lambda x: plot_logistic(x,w,b), x.numpy(), y.numpy())
    plt.title('logistic regression')
    plt.show()
    plt.close()
def two_network_train(x,y):
    # 定义两层神经网络的参数
    w1 = nn.Parameter(torch.randn(2, 4) * 0.01) # 隐藏层神经元个数 2
    b1 = nn.Parameter(torch.zeros(4))
    
    w2 = nn.Parameter(torch.randn(4, 1) * 0.01)
    b2 = nn.Parameter(torch.zeros(1))
    
    # 定义模型
    def two_network(x):
        x1 = torch.mm(x, w1) + b1
        x1 = F.tanh(x1) # 使用 PyTorch 自带的 tanh 激活函数
        x2 = torch.mm(x1, w2) + b2
        return x2
    x = torch.from_numpy(x).float()
    y = torch.from_numpy(y).float()
    optimizer = torch.optim.SGD([w1, w2, b1, b2], 1.)
    criterion = nn.BCEWithLogitsLoss()
    # 我们训练 10000 次
    for e in range(10000):
        out = two_network(Variable(x))
        loss = criterion(out, Variable(y))
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        if (e + 1) % 1000 == 0:
            print('epoch: {}, loss: {}'.format(e+1, loss.item()))
    def plot_network(x):
        x = Variable(torch.from_numpy(x).float())
        x1 = torch.mm(x, w1) + b1
        x1 = F.tanh(x1)
        x2 = torch.mm(x1, w2) + b2
        out = F.sigmoid(x2)
        out = (out > 0.5) * 1
        return out.data.numpy()
    plot_decision_boundary(lambda x: plot_network(x), x.numpy(), y.numpy())
    plt.title('2 layer network')
    plt.show()
    plt.close()
def sequential_train(x,y):
    x = torch.from_numpy(x).float()
    y = torch.from_numpy(y).float()
    # Sequential
    seq_net = nn.Sequential(
        nn.Linear(2, 4), # PyTorch 中的线性层，wx + b
        nn.Tanh(),
        nn.Linear(4, 1)
    )
    # 通过 parameters 可以取得模型的参数
    param = seq_net.parameters()
    
    criterion = nn.BCEWithLogitsLoss()
    # 定义优化器
    optim = torch.optim.SGD(param, 1.)
    # 我们训练 10000 次
    for e in range(10000):
        out = seq_net(Variable(x))
        loss = criterion(out, Variable(y))
        optim.zero_grad()
        loss.backward()
        optim.step()
        if (e + 1) % 1000 == 0:
            print('epoch: {}, loss: {}'.format(e+1, loss.item()))
    def plot_seq(x):
        out = F.sigmoid(seq_net(Variable(torch.from_numpy(x).float()))).data.numpy()
        out = (out > 0.5) * 1
        return out
    plot_decision_boundary(lambda x: plot_seq(x), x.numpy(), y.numpy())
    plt.title('sequential') 
    plt.show()
    plt.close()   
    
    
    #两种保存模型的办法
    # 1.将参数和模型保存在一起
    torch.save(seq_net, 'save_seq_net.pth')
    # 2.保存模型参数
    torch.save(seq_net.state_dict(), 'save_seq_net_params.pth')
def load_moudle():
    # 读取保存的模型
    seq_net1 = torch.load('save_seq_net.pth')
    print(seq_net1)
    print(seq_net1[0].weight)
    seq_net2 = nn.Sequential(
      nn.Linear(2, 4),
      nn.Tanh(),
      nn.Linear(4, 1)
    )
    seq_net2.load_state_dict(torch.load('save_seq_net_params.pth'))  
    print(seq_net2)
    print(seq_net2[0].weight)
def module_train(x,y):
    class module_net(nn.Module):
        def __init__(self, num_input, num_hidden, num_output):
            super(module_net, self).__init__()
            self.layer1 = nn.Linear(num_input, num_hidden)
            
            self.layer2 = nn.Tanh()
            
            self.layer3 = nn.Linear(num_hidden, num_output)
            
        def forward(self, x):
            x = self.layer1(x)
            x = self.layer2(x)
            x = self.layer3(x)
            return x
    x = torch.from_numpy(x).float()
    y = torch.from_numpy(y).float()
    mo_net = module_net(2, 4, 1)    
    optim = torch.optim.SGD(mo_net.parameters(), 1.)
    criterion = nn.BCEWithLogitsLoss()
    # 我们训练 10000 次
    for e in range(10000):
        out = mo_net(Variable(x))
        loss = criterion(out, Variable(y))
        optim.zero_grad()
        loss.backward()
        optim.step()
        if (e + 1) % 1000 == 0:
            print('epoch: {}, loss: {}'.format(e+1, loss.item()))
if __name__ == "__main__":
    x,y=draw_picture()
    logistic_train(x,y)# 自定义两层神经网络
    sequential_train(x,y)# 定义sequential神经网络
    load_moudle()
    module_train(x,y)# 定义module神经网络