机器学习——神经网络

educoder平台练习题
如果博客中图片加载失败可点击链接跳转至实训详情
https://www.educoder.net/shixuns/tf9qcivo/challenges

---

1.神经网络基本概念

题目

2.激活函数

代码

#encoding=utf8

def relu(x):
    '''
    x:负无穷到正无穷的实数
    '''
    #********* Begin *********#
    if x>0 or x==0:
        return x
    if x<0:
        return 0   
    #********* End *********#

3.反向传播算法

#获取训练数据
train_data = pd.read_csv('./step2/train_data.csv')
#获取训练标签
train_label = pd.read_csv('./step2/train_label.csv')
train_label = train_label['target']
#获取测试数据
test_data = pd.read_csv('./step2/test_data.csv')

数据集中部分数据与标签如下图所示：

from sklearn.neural_network import MLPClassifier
mlp = MLPClassifier(solver='lbfgs',max_iter =10,
           alpha=1e-5,hidden_layer_sizes=(3,2))
mlp.fit(X_train, Y_train)
result = mlp.predict(X_test)

代码

#encoding=utf8
import os
import pandas as pd
from sklearn.neural_network import MLPClassifier

if os.path.exists('./step2/result.csv'):
    os.remove('./step2/result.csv')
    
#********* Begin *********#
#获取训练数据
train_data = pd.read_csv('./step2/train_data.csv')
#获取训练标签
train_label = pd.read_csv('./step2/train_label.csv')
train_label = train_label['target']
#获取测试数据
test_data = pd.read_csv('./step2/test_data.csv')

#调用MLP模型并进行训练
mlp = MLPClassifier(solver='lbfgs',max_iter =500,
           alpha=1e-3,hidden_layer_sizes=(100,),learning_rate_init=0.0001)
mlp.fit(train_data, train_label)

#预测
result = mlp.predict(test_data)
#保存
save_df = pd.DataFrame({'result':result})
save_df.to_csv('./step2/result.csv',index=0)
#********* End *********#

4.使用pytorch搭建卷积神经网络识别手写数字

参数太多：如果输入图像大小为100 × 100 × 3。
在全连接前馈网络中，第一个隐藏层的每个神经元到输入层都有 30000个相互独立的连接，每个连接都对应一个权重参数。
随着隐藏层神经元数量的增多，参数的规模也会急剧增加。这会导致整个神经网络的训练效率会非常低，也很容易出现过拟合。

局部不变性特征： 自然图像中的物体都具有局部不变性特征，比如在尺度缩放、平移、旋转等操作不影响其语义信息。
而全连接前馈网络很难提取这些局部不变特征，一般需要进行数据增强来提高性能。

那为什么说卷积能够提取图像中物体的特征呢？其实很好理解，上图中的卷积核中值的分布如下：

#加载数据
import torchvision
train_data = torchvision.datasets.MNIST(
    root='./step3/mnist/',
    train=True,                                     # this is training data
    transform=torchvision.transforms.ToTensor(),    # Converts a PIL.Image or numpy.ndarray to                                                    
    download=False,
)
#取6000个样本为训练集
train_data_tiny = []
for i in range(6000):
    train_data_tiny.append(train_data[i])
train_data = train_data_tiny

构建模型
加载好数据集，就需要构建卷积神经网络模型

#构建卷积神经网络模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Sequential(         # input shape (1, 28, 28)
            nn.Conv2d(
                in_channels=1,              # input height
                out_channels=16,            # n_filters
                kernel_size=5,              # filter size
                stride=1,                   # filter movement/step
                padding=2,                  # if want same width and length of this image after con2d, padding=(kernel_size-1)/2 if stride=1
            ),                              # output shape (16, 28, 28)
            nn.ReLU(),                      # activation
            nn.MaxPool2d(kernel_size=2),    # choose max value in 2x2 area, output shape (16, 14, 14)
        )
        self.conv2 = nn.Sequential(         # input shape (16, 14, 14)
            nn.Conv2d(16, 32, 5, 1, 2),     # output shape (32, 14, 14)
            nn.ReLU(),                      # activation
            nn.MaxPool2d(2),                # output shape (32, 7, 7)
        )
        self.out = nn.Linear(32 * 7 * 7, 10)   # fully connected layer, output 10 classes
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1)           # flatten the output of conv2 to (batch_size, 32 * 7 * 7)
        output = self.out(x)
        return output
cnn = CNN()

需要指出的几个地方：

class CNN需要继承Module
需要调用父类的构造方法：super(CNN, self).__init__()
在Pytorch中激活函数Relu也算是一层layer
需要实现forward()方法，用于网络的前向传播，而反向传播只需要调用Variable.backward()即可。

定义好模型后还要构建优化器与损失函数：
torch.optim是一个实现了各种优化算法的库。使用方法如下：

#SGD表示使用随机梯度下降方法，lr为学习率，momentum为动量项系数
optimizer = torch.optim.SGD(model.parameters(), lr = 0.01, momentum=0.9)
#交叉熵损失函数
loss_func = nn.CrossEntropyLoss()

训练模型
在定义好模型后，就可以根据反向传播计算出来的梯度，对模型参数进行更新，在pytorch中实现部分代码如下：

#将梯度清零
optimizer.zero_grad()
#对损失函数进行反向传播
loss.backward()
#训练
optimizer.step()

保存模型
在pytorch中使用torch.save保存模型，有两种方法，第一种：
保存整个模型和参数，方法如下：

torch.save(model, PATH)

第二种为官方推荐，只保存模型的参数，方法如下：

torch.save(model.state_dict(), PATH)

加载模型
对应两种保存模型的方法，加载模型也有两种方法，第一种如下：

model = torch.load(PATH)

第二种：

#CNN()为你搭建的模型
model = CNN()
model.load_state_dict(torch.load(PATH))

如果要对加载的模型进行测试，需将模型切换为验证模式

model.eval()

#mini_batch
train_loader = Data.DataLoader(dataset=train_data, batch_size=64, shuffle=True)

代码

#encoding=utf8
import torch
import torch.nn as nn
from torch.autograd import Variable
import torch.utils.data as Data
import torchvision
import os
if os.path.exists('./step3/cnn.pkl'):
    os.remove('./step3/cnn.pkl')
    
#加载数据             
train_data = torchvision.datasets.MNIST(
    root='./step3/mnist/',
    train=True,                                     # this is training data
    transform=torchvision.transforms.ToTensor(),    # Converts a PIL.Image or numpy.ndarray to                                                    
    download=False,
)
#取6000个样本为训练集
train_data_tiny = []

for i in range(6000):
    train_data_tiny.append(train_data[i])

train_data = train_data_tiny

#********* Begin *********#
#构建卷积神经网络模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Sequential(         # input shape (1, 28, 28)
            nn.Conv2d(
                in_channels=1,              # input height
                out_channels=16,            # n_filters
                kernel_size=5,              # filter size
                stride=1,                   # filter movement/step
                padding=2,                  # if want same width and length of this image after con2d, padding=(kernel_size-1)/2 if stride=1
            ),                              # output shape (16, 28, 28)
            nn.ReLU(),                      # activation
            nn.MaxPool2d(kernel_size=2),    # choose max value in 2x2 area, output shape (16, 14, 14)
        )
        self.conv2 = nn.Sequential(         # input shape (16, 14, 14)
            nn.Conv2d(16, 32, 5, 1, 2),     # output shape (32, 14, 14)
            nn.ReLU(),                      # activation
            nn.MaxPool2d(2),                # output shape (32, 7, 7)
        )
        self.out = nn.Linear(32 * 7 * 7, 10)   # fully connected layer, output 10 classes
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1)           # flatten the output of conv2 to (batch_size, 32 * 7 * 7)
        output = self.out(x)
        return output
cnn = CNN()              

optimizer = torch.optim.Adam(cnn.parameters(), lr = 0.01)
#交叉熵损失函数
loss_func = nn.CrossEntropyLoss()

train_loader = Data.DataLoader(dataset=train_data, batch_size=64, shuffle=True)
for step, (x, y) in enumerate(train_loader): 
    b_x = Variable(x)
    b_y = Variable(y) 
    output = cnn(b_x)
    loss = loss_func(output, b_y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

#********* End *********#
#保存模型
torch.save(cnn.state_dict(), './step3/cnn.pkl')