pytorch 用神经网络搭建自己的回归和分类模型

目录

1.pytorch基本知识  

2.回归模型

3.分类模型

4.快速搭建法

5.参考资料

---

1.pytorch基本知识  

      1、tensor的定义

      2、tensor与numpy的相互转换

      3、tensor使用cuda加速

      4、Variable的使用

# -*- coding: utf-8 -*-
"""
Created on Thu Aug  8 16:40:47 2019
pytorch快速入门教程
参考书籍：《深度学习框架pytorch:入门与实践》
@author: xiaoxiaoke
"""
import torch as t
import numpy as np


#####################1Tensor的基础使用###########
#1.1、构建5*3的矩阵，未分配空间进行初始化
x1=t.Tensor(5,3)
print(x1)

#1.2、使用[0 1]的均匀分布随机初始化二维数组
x2=t.rand(5,3)
print(x2)

#1.3、查看矩阵的形状
print(x2.shape)
print(x2.size())#等价写法

#1.4、tensor 的加法
y=t.rand(5,3)
z=y+x1
print(z)
y2=t.add(y,x1)#加法的等价写法
print(y2)
y2.add_(100)
print(y2)
#注释：add_与add的不同
#     add_ 以_进行结尾，函数会修改对象本身的值
#     add的语法则是等式形式
########################2、Tensor与numpy的结合###########################
#tensor不支持的操作可以先转为numpy，操作之后在转为tensor进行操作
#2.1、tensor转换为numpy
a_tensor=t.ones(5)
print(a_tensor)
b_np=a_tensor.numpy()#tensor—>numpy
print(b_np)
#2.2、将numpy转换为tensor
c_np=np.ones(5)
print(c_np)
d_tensor=t.from_numpy(c_np)#numpy->tensor
print(d_tensor)
#注意：tensor与numpy之间的转换，对象共享内存!!
#      内存共享意味着二者之间的转换会很快，
#      但是同时意味着一方的值改变之后，另外一方的值也会随之更改。
#验证如下：
a_tensor.add_(1000)
print("内存共享：",a_tensor)
print("内存共享：",b_np)
##################3、tensor可以使用CUDA加速######################
if t.cuda.is_available():
    y=y.cuda()
    y2=y2.cuda()
    print(x+y2)
    
#####################4、Autograd：自动微分#######################
#autograd.Veribale是Autograd中的核心类，封装了tensor之后，可以调用backward实现自动计算反向梯度

from torch.autograd import Variable
x_var=Variable(t.ones(2,2),requires_grad=True)
print(x_var)   
y_var=x_var.sum()
print(y_var)
print(y_var.grad_fn)
y_var.backward()
print("第一次反向传播",x_var.grad)
y_var.backward()
print("第二次反向传播",x_var.grad)
# 注意：grad在反向传播的过程中是累加的，深度学习是多层神经网络，在每次反向传播结束之后会累加上次的结果。
#  基于上述原因，训练过程中会在首次反向传播之前将梯度置为零。

#将梯度置为零
x_var.grad.data.zero_()
print(x_var.grad)
y_var.backward()
print("置零之后反向传播",x_var.grad)

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

# =============================================================================
#              利用三层神经网络对带有噪声的正弦信号进行回归拟合
# =============================================================================
#准备数据（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))

3.分类模型

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

4.快速搭建法

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

5.参考资料

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

2、《深度学习框架PYTORCH入门与实践》