目录

1.回归模型

2.分类模型

3.参考资料

1.回归模型

import torch
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt
import time 
import numpy as np

# =============================================================================
#              利用三层神经网络对带有噪声的正弦信号进行回归拟合
# =============================================================================
#准备数据（unsqueeze 一维转成二维）
start=time.time()
X = torch.unsqueeze(torch.linspace(-2.5, 2.5, 200), dim=1) # x (tensor)(200, 1)
y = X.sin() + 0.2*torch.rand(X.size())                     # y (tensor)(200, 1)

#定义三层神经网络模型
class Net(torch.nn.Module):
    def __init__(self,n_input,n_hidden,n_output):
        super(Net,self).__init__()#继承
        self.hidden=torch.nn.Linear(n_input,n_hidden)
        self.predict=torch.nn.Linear(n_hidden,n_output)
        
    def forward(self,X):
        X=F.relu(self.hidden(X))
        X=self.predict(X)
        return X

#设置网络节点数，损失函数和优化方法         
net=Net(n_input=1,n_hidden=10,n_output=1)
loss_func=torch.nn.MSELoss()
optimizer=torch.optim.SGD(net.parameters(),lr=0.2)
loss_List=[]
for t in range(150): 
    prediction=net(X)
    loss=loss_func(prediction,y)
    loss_List.append(loss)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
#训练过程和损失函数的可视化
    if t % 1 == 0:
        plt.figure(1)
        plt.subplot(211)
        plt.cla() 
        plt.scatter(X.data.numpy(), y.data.numpy())
        plt.text(-2.1, 1.2,'time:%d' % t, fontdict={'size':20, 'color':'green'})
        plt.plot(X.data.numpy(), prediction.data.numpy(), 'r-', lw=2)
        plt.text(-0.9, 1.2,'Loss=%.4f' %loss.data.numpy(),fontdict={'size':20, 'color':'red'})
        plt.xlim((-2.5,2.5))
        plt.ylim((-1.9,1.9))
        plt.pause(0.1)
        plt.title('data')
      
plt.subplot(212)
plt.cla() 
plt.plot(range(0,t+1), loss_List,'b-')
plt.title('loss')
plt.xlabel('epoch')
plt.ylabel('MSELoss')
end=time.time()
print("共用时%.2fs"%(end-start))

2.分类模型

import torch
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt
import time 
import numpy as np
# =============================================================================
#              利用三层神经网络对带有噪声的正弦信号进行回归拟合
# =============================================================================

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

# 注意 x, y 数据的数据形式是一定要像下面一样 (torch.cat 是在合并数据)
x = torch.cat((x0, x1)).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()


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) 

# optimizer 训练的工具
optimizer = torch.optim.SGD(net.parameters(), lr=0.02)  # 传入 net 的所有参数, 学习率
loss_func = torch.nn.CrossEntropyLoss()
for t in range(50):
    out = net(x)                  # 喂给 net 训练数据 x, 输出分析值
    loss = loss_func(out, y)      # 计算两者的误差
    optimizer.zero_grad()         # 清空上一步的残余更新参数值
    loss.backward()               # 误差反向传播, 计算参数更新值
    optimizer.step()              # 将参数更新值施加到 net 的 parameters 上
    # 画图
    plt.ion()  
    plt.show()
    if t % 2 == 0:
        plt.cla()
        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)/1000.  # 预测中有多少和真实值一样
        plt.text(1.5, -4, 'Accuracy=%.2f' % accuracy, fontdict={'size': 20, 'color':  'red'})
        plt.pause(0.1)

plt.ioff()  # 停止画图
plt.show()

3.快速搭建法

net = torch.nn.Sequential(
    torch.nn.Linear(1, 10),
    torch.nn.ReLU(),
    torch.nn.Linear(10, 1)
)

4.参考资料

1.莫烦python：https://morvanzhou.github.io/tutorials/machine-learning/torch/3-02-classification/