3.建立第一个神经网络

最新推荐文章于 2024-11-02 22:05:46 发布

komorebi6

最新推荐文章于 2024-11-02 22:05:46 发布

阅读量288

点赞数 1

分类专栏： PyTorch 文章标签：神经网络 pytorch 深度学习

本文链接：https://blog.csdn.net/komorebi6/article/details/104239617

版权

PyTorch 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

关系拟合（回归）
- 建立数据集
- 建立神经网络
区分类型 (分类)
快速搭建
保存提取
批训练
- DataLoader
优化器 Optimizer

神经网络分成两种类型：回归（如：一堆数据对应的值是连续的值，像房价）、分类（如：图片分类）

关系拟合（回归）

建立数据集

创建一些假数据来模拟真实的情况. 比如一个一元二次函数: y = a * x^2 + b, 将 y 数据加上一点噪声来更加真实的展示它.

#关系拟合（回归）
import torch
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt
#fake data
x=torch.unsqueeze(torch.linspace(-1,1,100),dim=1)
#unsqueeze将一维变成二维	因为在torch中只处理二维的数据
y=x.pow(2)+0.2*torch.rand(x.size())
#   二次方+噪点的影响

plt.scatter(x.data.numpy(),y.data.numpy())
#打印散点图
plt.show()

建立神经网络

建立一个神经网络可以直接运用 torch 中的体系. 先定义所有的层属性(init()), 然后再一层层搭建(forward(x))层于层的关系链接.建立关系的时候, 会用到激励函数,

每一个torch模块都包含着两个功能
init()搭建层需要的信息
forward(x)前向传递的过程，将init里信息在forward中一个一个组合起来（相当于搭流程图）
Linear全连接网络

#关系拟合（回归）
import torch

from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt
class Net(torch.nn.Module):#module是net主模块
    #搭建torch所需要的两个功能
    def __init__(self,n_feature,n_hidden,n_output):#搭建net所需要的信息
        super(Net,self).__init__()#继承net到Module模块并输出init功能
        #下面为层信息，层信息都是属性
        self.hidden=torch.nn.Linear(n_feature,n_hidden)#多少输入多少输出
        self.predict = torch.nn.Linear(n_hidden,n_output)
    def forward(self,x):#前向传递的过程，正向传播输入值, 神经网络分析出输出值
       x=F.relu(self.hidden(x))#x经过hidden输出n_hidden，再用relu激活函数嵌套
       x=self.predict(x)#将上述x放入predict中 输出层输出x
       #输出层不用激励函数，因为在大多数回归问题当中
       #预测值在大多数回归问题中它的分布从正无穷到负无穷，
       #用激励函数会将值截断了一点，predict不喜欢截断的结果
       return x

#定义net
#！！！！不要打在class里
net=Net(n_feature=1,n_hidden=10,n_output=1)#x值1个，隐藏层（神经元10），y1
print(net)


plt.ion()   #实时 画图
plt.show()

#优化网络
optimizer=torch.optim.SGD(net.parameters(),lr=0.2)#越高越快
#用optim优化器优化神经网络的参数,学习效率0.2
loss_func=torch.nn.MSELoss()#计算误差的手段    MSELoss()均方差



#开始训练
for t in  range(100):#100步
    prediction=net(x)#输入信息预测值

    loss=loss_func(prediction,y)#预测prediction和y的误差

    optimizer.zero_grad()#所有参数梯度降为0（因为计算loss梯度都会保留在optimizer中）
    loss.backward()#反向传递，给每个神经网络节点计算出梯度
    optimizer.step()#优化梯度（以学习效率优化梯度）

    if t % 5 == 0:
        # plot and show learning process
        plt.cla()
        plt.scatter(x.data.numpy(), y.data.numpy())
        plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
        plt.text(0.2, 0, 'Loss=%.4f' % loss.data, fontdict={'size': 20, 'color':  'red'})
        plt.pause(0.1)
plt.ioff()
plt.show()

预测–计算误差–梯度归零–反向传播–前向传播
在这里插入图片描述

区分类型 (分类)

在这里插入图片描述
创建一些假数据来模拟真实的情况. 比如两个二次分布的数据, 不过他们的均值都不一样.建立一个神经网络可以直接运用 torch 中的体系. 先定义所有的层属性(init()), 然后再一层层搭建(forward(x))层于层的关系链接.
这个和前面 regression 的时候的神经网络基本没差.建立关系的时候, 会用到激励函数,

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

# 假数据
n_data = torch.ones(100, 2)         # 数据的基本形态 x包含横纵坐标 y为类型
x0 = torch.normal(2*n_data, 1)      # 类型0 x data (tensor), shape=(100, 2)
y0 = torch.zeros(100)               # 标签为0
x1 = torch.normal(-2*n_data, 1)     # 类型1 x data (tensor), shape=(100, 1)
y1 = torch.ones(100)                # 标签为1

# 注意 x, y 数据的数据形式是一定要像下面一样 (torch.cat 是在合并数据)
x = torch.cat((x0, x1), 0).type(torch.FloatTensor)  #数据一定要为FloatTensor = 32-bit floating
            #x合并在一起做数据

y = torch.cat((y0, y1), ).type(torch.LongTensor)    # 标签一定要为LongTensor = 64-bit integer
            # y合并在一起做标签0.
# 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
        #x输入为2个特征（x，y坐标）    输出2个特征（0和你）

print(net)  # net 的结构

# optimizer 是训练的工具
optimizer = torch.optim.SGD(net.parameters(), lr=0.02)  # 传入 net 的所有参数, 学习率
loss_func = torch.nn.CrossEntropyLoss()
#CrossEntropyLoss()作用   标签值:【0,0,1】 预测值：【0.1,0.3,0.6】两者误差

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()        # 将参数更新值施加到 net 的 parameters 上


    if t % 2 == 0:
        plt.cla()
        prediction = torch.max(out, 1)[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 = 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()

快速搭建

在回归里用的方法，用 class 继承了一个 torch 中的神经网络结构, 然后对其进行了修改, 快速搭建更快, 用一句话就概括了上面所有的内容!

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

net1 = Net(1, 10, 1)   # 这是我们用这种方式搭建的 net1

快速搭建

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


print(net1)
"""
Net (
  (hidden): Linear (1 -> 10)
  (predict): Linear (10 -> 1)
)
"""
print(net2)
"""
Sequential (
  (0): Linear (1 -> 10)
  (1): ReLU ()
  (2): Linear (10 -> 1)
)
"""

net2把激励函数也一同纳入进去了, 但是 net1 中, 激励函数实际上是在 forward() 功能中才被调用的.
这也就说明了, 相比 net2, net1 的好处就是, 可以根据个人需要更加个性化你自己的前向传播过程, 比如(RNN).
不过如果不需要七七八八的过程, net2 更适合.

保存提取

训练好了一个模型, 我们想要保存它, 留到下次要用的时候直接提取直接用, 这里用回归的神经网络举例实现保存提取.

一种保存整个神经网络 torch.save(net1,‘net.pkl’)
一种保存神经网络的参数torch.save(net1.state_dict(),‘net_params.pkl’)
提取整个神经网络
提取神经网络的参数

import torch

import matplotlib.pyplot as plt

#fake data
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)
#unsqueeze将一维变成二维
y = x.pow(2) + 0.2*torch.rand(x.size())
#   二次方+噪点的影响


#保存数据
def save():
    #建网络
    net1=torch.nn.Sequential(
        torch.nn.Linear(1,10),
        torch.nn.ReLU(),
        torch.nn.Linear(10,1)
    )
    #优化网络
    optimizer=torch.optim.SGD(net1.parameters(),lr=0.2)
    loss_func=torch.nn.MSELoss()

    # 开始训练
    for t in range(100):  # 100步
        prediction =net1(x)  # 输入信息预测值
        loss = loss_func(prediction, y)  # 预测prediction和y的误差
        optimizer.zero_grad()  # 所有参数梯loss = loss_func(prediction, y)度降为0
        loss.backward()  # 反向传递，给每个神经网络节点计算出梯度
        optimizer.step()  # 优化梯度

     # 出图
    plt.figure(1, figsize=(10, 3))
    plt.subplot(131)
    plt.title('Net1')
    plt.scatter(x.data.numpy(), y.data.numpy())
    plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)

    torch.save(net1,'net.pkl')#保存整个神经网络
                    #保存的名字
    torch.save(net1.state_dict(),'net_params.pkl')#保存整个神经网络的参数

def restore_net():
    net2=torch.load('net.pkl')#提取神经网络
    prediction=net2(x)
    # 出图

    plt.subplot(132)
    plt.title('Net2')
    plt.scatter(x.data.numpy(), y.data.numpy())
    plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)

def restore_parames():
    #net3提取参数 首先要建立一个和net1一样的神经网络
    #然后把net1的参数复制到net3中
    net3 = torch.nn.Sequential(
        torch.nn.Linear(1, 10),
        torch.nn.ReLU(),
        torch.nn.Linear(10, 1)
    )#但里面的参数肯定不一样
    net3.load_state_dict(torch.load('net_params.pkl'))
    prediction=net3(x)
    # 出图

    plt.subplot(133)
    plt.title('Net3')
    plt.scatter(x.data.numpy(), y.data.numpy())
    plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
    plt.show()


save()

restore_net()

restore_parames()

在这里插入图片描述

批训练

拆成一小段一小段方式训练

DataLoader

DataLoader 是 torch 给你用来包装你的数据的工具. 所以要将自己的 (numpy array 或其他) 数据形式装换成 Tensor, 然后再放进这个包装器中.DataLoader帮你有效地迭代数据,

#批处理
import torch
import torch.utils.data as Data

BATCH_SIZE=5#一堆数据分为5个一组 5个 5个

x=torch.linspace(1,10,10)#从1到10分为10个点
y=torch.linspace(10,1,10)#从10到1。。
  
#定义一个数据库
torch_dataset=Data.TensorDataset(x,y)#x训练数据y目标数据
#使用loader将训练变成一小批一小批的
loader=Data.DataLoader(
    dataset=torch_dataset,
    batch_size=BATCH_SIZE,
    shuffle=True,#要不要在训练的时候随机打乱数据再开始抽样 false为不打乱

)

for epoch in range(3):#把上述10个数据整体训练3次
    for step,(batch_x,batch_y) in enumerate(loader):#总训练3次每次训练分为2部分
        #loader定义要不要打乱数据 不打乱数据每次训练的形式是一样的先训练数据点1再训练数据点2.。
        #enumerate在每次提取的时候都给他一个索引 第一个就是第一步
        #training
        print('Epoch: ', epoch, '| Step: ', step, '| batch x: ',
              batch_x.numpy(), '| batch y: ', batch_y.numpy())
。。。
Epoch:  0 | Step:  0 | batch x:  [3. 5. 1. 4. 8.] | batch y:  [ 8.  6. 10.  7.  3.]
Epoch:  0 | Step:  1 | batch x:  [ 2.  6. 10.  9.  7.] | batch y:  [9. 5. 1. 2. 4.]
Epoch:  1 | Step:  0 | batch x:  [ 4.  2.  6.  7. 10.] | batch y:  [7. 9. 5. 4. 1.]
Epoch:  1 | Step:  1 | batch x:  [9. 5. 8. 1. 3.] | batch y:  [ 2.  6.  3. 10.  8.]
Epoch:  2 | Step:  0 | batch x:  [4. 7. 6. 2. 8.] | batch y:  [7. 4. 5. 9. 3.]
Epoch:  2 | Step:  1 | batch x:  [10.  9.  1.  3.  5.] | batch y:  [ 1.  2. 10.  8.  6.]

若将BATCH_SIZE=5改为8输出

Epoch:  0 | Step:  0 | batch x:  [2. 1. 5. 9. 7. 8. 4. 6.] | batch y:  [ 9. 10.  6.  2.  4.  3.  7.  5.]
Epoch:  0 | Step:  1 | batch x:  [10.  3.] | batch y:  [1. 8.]
Epoch:  1 | Step:  0 | batch x:  [4. 8. 6. 7. 1. 3. 2. 9.] | batch y:  [ 7.  3.  5.  4. 10.  8.  9.  2.]
Epoch:  1 | Step:  1 | batch x:  [ 5. 10.] | batch y:  [6. 1.]
Epoch:  2 | Step:  0 | batch x:  [ 3.  5.  9.  7. 10.  4.  6.  1.] | batch y:  [ 8.  6.  2.  4.  1.  7.  5. 10.]
Epoch:  2 | Step:  1 | batch x:  [2. 8.] | batch y:  [9. 3.]

在 step=1 就只给你返回这个 epoch 中剩下的数据

优化器 Optimizer

加速神经网络训练

SGD 是最普通的优化器, 也可以说没有加速效果, 而 Momentum 是 SGD 的改良版, 它加入了动量原则.
后面的 RMSprop 又是 Momentum 的升级版. 而 Adam 又是 RMSprop 的升级版.
不过从这个结果中我们看到, Adam 的效果似乎比 RMSprop 要差一点. 所以说并不是越先进的优化器, 结果越佳.
我们在自己的试验中可以尝试不同的优化器, 找到那个最适合你数据/网络的优化器.

import torch
import torch.utils.data as Data
import torch.nn.functional as F
from torch.autograd import Variable
import matplotlib.pyplot as plt

#超参数
LR=0.01
BATCH_SIZE=32
EPOCH=12

#回归的数据
x = torch.unsqueeze(torch.linspace(-1, 1, 1000), dim=1)
y = x.pow(2) + 0.1*torch.normal(torch.zeros(*x.size()))

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

#定义一个数据库
torch_dataset=Data.TensorDataset(x,y)
loader=Data.DataLoader(
    dataset=torch_dataset,
    batch_size=BATCH_SIZE,
    shuffle=True,
    num_workers=2,#工作进程
)

#建立神经网络
class Net(torch.nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.hidden=torch.nn.Linear(1,20)#隐藏层
        self.predict=torch.nn.Linear(20,1)#输出层
    def forward(self,x):
        x=F.relu(self.hidden(x))
        x=self.predict(x)
        return x
#四个不同的神经网络
if __name__ == '__main__':
    net_SGD = Net()
    net_Momentum= Net()
    net_RMSprop= Net()
    net_Adam= Net()
    nets = [net_SGD, net_Momentum, net_RMSprop, net_Adam]

    opt_SGD= torch.optim.SGD(net_SGD.parameters(), lr=LR)
    opt_Momentum= torch.optim.SGD(net_Momentum.parameters(), lr=LR, momentum=0.8)
    opt_RMSprop= torch.optim.RMSprop(net_RMSprop.parameters(), lr=LR, alpha=0.9)
    opt_Adam= torch.optim.Adam(net_Adam.parameters(), lr=LR, betas=(0.9, 0.99))
    optimizers=[opt_SGD, opt_Momentum, opt_RMSprop, opt_Adam]

    #开始训练
    loss_func = torch.nn.MSELoss()#回归的误差计算公式
    losses_his = [[], [], [], []]   # 记录 training 时不同神经网络的 loss

    for epoch in range(EPOCH):
        print('Epoch: ', epoch)
        for step, (b_x, b_y) in enumerate(loader):
        #将不同的神经网络拿出来一个一个的训练
          for net, opt, l_his in zip(nets, optimizers, losses_his):
              output = net(b_x)  # 输入信息预测值
              loss = loss_func(output, b_y)  # 预测prediction和y的误差

              opt.zero_grad()   # 所有参数梯度降为0
              loss.backward()  # 反向传递，给每个神经网络节点计算出梯度
              opt.step()  # 优化梯度
              l_his.append(loss.data.numpy())#将误差放到记录里面
    #打印
    labels = ['SGD', 'Momentum', 'RMSprop', 'Adam']
    for i, l_his in enumerate(losses_his):
        plt.plot(l_his, label=labels[i])
    plt.legend(loc='best')
    plt.xlabel('Steps')
    plt.ylabel('Loss')
    plt.ylim((0, 0.2))
    plt.show()