（菜鸟入门）使用pytorch框架实现前馈神经网络

前馈神经网络

常见的前馈神经网络有感知机（Perceptrons）、BP（Back Propagation）网络等。前馈神经网络(FNN)是人工智能领域中最早发明的简单人工神经网络类型。各神经元分层排列。每个神经元只与前一层的神经元相连。接收前一层的输出，并输出给下一层．各层间没有反馈。在它内部，参数从输入层经过隐含层向输出层单向传播。与递归神经网络不同，在它内部不会构成有向环。下图为一个简单前馈神经网络示意图：

整个网络中无反馈，信号从输入层向输出层单向传播，可用一个有向无环图表示

感知器

感知器实际上是神经网络结构中的一个神经元，那么一个感知器就构成了最简单的神经网络。
感知器是前向结构的人工神经网络，可以被看作是一个有向图，由多个的节点层所组成，每一层都全连接到下一层。除了输入节点，每个节点都是一个带有非线性激活函数的神经元（或称处理单元）

实现前馈神经网络

之前的blog已经说过如何搭建windows系统的pytorch-gpu环境，我们使用pytorch来实现第一个前馈神经网络：
源代码：
源码中我作了详细的注释，供参考

import torch
import torch.nn as nn
import torchvision.datasets as dsets #torchvision为一个做图形处理的库，加载数据集
import torchvision.transforms as transforms

'''
torchvision.datasets这个包中包含MNIST、FakeData、COCO、LSUN、ImageFolder、DatasetFolder、ImageNet、CIFAR等一些常用的数据集，并且提供了数据集设置的一些重要参数设置，可以通过简单数据集设置来进行数据集的调用。从这些数据集中我们也可以看出数据集设置的主要变量有哪些并且有什么功能对将来自己数据集的设置也有极大的帮助。
以上数据集的接口基本上很相近。它们至少包括两个公共的参数transform和target_transform，以便分别对输入和和目标做变换
'''
from torch.autograd import Variable
#torch.autograd提供了类和函数用来对任意标量函数进行求导。
import torch.utils.data as Data
#我们需要使用torch.utils.data.DataLoader加载数据
import matplotlib.pyplot as plt
#画图所需的库

# Hyper Parameters 超参数(hyperparameters)/算法参数 根据经验进行设定，影响到权重和偏置的大小，比如迭代次数、隐藏层的层数、每层神经元的个数、学习速率等
input_size = 784
hidden_size = 500
num_classes = 10
num_epochs = 5
batch_size = 100
learning_rate = 0.001

# MNIST Dataset 数据集
train_dataset = dsets.MNIST(root='./data', #指定数据集的目录
                            train=True, 
                            transform=transforms.ToTensor(),  
# transforms.ToTensor() 将numpy的ndarray或PIL.Image读的图片转换成形状为(C,H, W)的Tensor格式，且/255归一化到[0,1.0]之间
                            download=True)

test_dataset = dsets.MNIST(root='./data', 
                           train=False, 
                           transform=transforms.ToTensor())

# Data Loader (Input Pipeline)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, 
                                           batch_size=batch_size, 
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset, 
                                          batch_size=batch_size, 
                                          shuffle=False)
'''
dataset:加载数据的数据集
batch_size：加载批训练的数据个数
shuffle：在每个Epoch中打乱数据
'''
test_y=test_dataset.test_labels

# Neural Network Model (1 hidden layer)
class Net(nn.Module):
    #初始化网络结构
    def __init__(self, input_size, hidden_size, num_classes):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size) #输入层，线性（liner）关系
        self.relu = nn.ReLU()#隐藏层，使用ReLU函数
        self.fc2 = nn.Linear(hidden_size, num_classes)  #输出层，线性（liner）关系
    #forword 参数传递函数，网络中数据的流动
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out
    
net = Net(input_size, hidden_size, num_classes)

    
# Loss and Optimizer
criterion = nn.CrossEntropyLoss()  #设置loss为最小二乘loss
optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate)  
#设置优化器，torch.optim.Adam
# Train the Model
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):  
        #enumrate
        # Convert torch tensor to Variable
        images = Variable(images.view(-1, 28*28))#图片大小为28*28
        labels = Variable(labels)
        #pytorch都是有tensor计算的，而tensor里面的参数都是Variable的形式
        # Forward + Backward + Optimize
        optimizer.zero_grad()  # zero the gradient buffer
        outputs = net(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        
        if (i+1) % 100 == 0:
            print ('Epoch [%d/%d], Step [%d/%d], Loss: %.4f' 
                   %(epoch+1, num_epochs, i+1, len(train_dataset)//batch_size, loss.item()))
#每训练100个step输出一次结果
# Test the Model
correct = 0
total = 0
for images, labels in test_loader:
    images = Variable(images.view(-1, 28*28))
    outputs = net(images)
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)#计算所有的label数量
    correct += (predicted == labels).sum()#计算预测对的label数量

print('Accuracy of the network on the 10000 test images: %d %%' % (100 * torch.true_divide(correct, total)))

# Save the Model
for i in range(1,4):

    plt.imshow(train_dataset.train_data[i].numpy(), cmap='gray')  

    plt.title('%i' % train_dataset.train_labels[i])  

plt.show()  
torch.save(net.state_dict(), 'model.pkl')
#net.state_dict(),模型文件
test_output = net(images[:20])  

pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()  

print('prediction number',pred_y)  

print('real number',test_y[:20].numpy())  

最小二乘Loss

class torch.nn.CrossEntropyLoss(weight=None, size_average=True)[source]
此标准将LogSoftMax和NLLLoss集成到一个类中。

当训练一个多类分类器的时候，这个方法是十分有用的。

weight(tensor): 1-D tensor，n个元素，分别代表n类的权重，如果你的训练样本很不均衡的话，是非常有用的。默认值为None。
调用时参数：

input : 包含每个类的得分，2-D tensor,shape为 batch*n

target: 大小为 n 的 1—D tensor，包含类别的索引(0到 n-1)。

Loss可以表述为以下形式：

当weight参数被指定的时候，loss的计算公式变为：

torch.optim.Adam

torch.optim是一个实现了各种优化算法的库。大部分常用的方法得到支持，并且接口具备足够的通用性，使得未来能够集成更加复杂的方法。
·
为了使用torch.optim，需要构建一个optimizer对象。这个对象能够保持当前参数状态并基于计算得到的梯度进行参数更新。
·
为了构建一个Optimizer，需要给它一个包含了需要优化的参数（必须都是Variable对象）的iterable。然后，你可以设置optimizer的参 数选项，比如学习率，权重衰减，等等。
·
例如：

optimizer = optim.SGD(model.parameters(), lr = 0.01, momentum=0.9)
optimizer = optim.Adam([var1, var2], lr = 0.0001)

·
对于Adam

class torch.optim.Adam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)[source]

参数：

1. params (iterable) – 待优化参数的iterable或者是定义了参数组的dict lr (float, 可选) –
2. 学习率（默认：1e-3） betas (Tuple[float, float], 可选) –
3. 用于计算梯度以及梯度平方的运行平均值的系数（默认：0.9，0.999） eps (float, 可选) –
4. 为了增加数值计算的稳定性而加到分母里的项（默认：1e-8） weight_decay (float, 可选) –
   权重衰减（L2惩罚）（默认: 0）

附上pytorch文档的解释

torch.max

output = torch.max(input, dim)

1.输入

input是softmax函数输出的一个tensor
dim是max函数索引的维度0/1，0是每列的最大值，1是每行的最大值

2. 输出

函数会返回两个tensor，第一个tensor是每行的最大值，softmax的输出中最大的是1，所以第一个tensor是全1的tensor；第二个tensor是每行最大值的索引。

torch.nn.state_dict()

pytorch 中的 state_dict 是一个简单的python的字典对象,将每一层与它的对应参数建立映射关系.(如model的每一层的weights及偏置等等)

(注意,只有那些参数可以训练的layer才会被保存到模型的state_dict中,如卷积层,线性层等等)

squeeze函数

import numpy as np

x = np.array([[[0], [1], [2]]])
print(x)
"""
x=

[[[0]
  [1]
  [2]]]
"""
print(x.shape)  # (1, 3, 1)

x1 = np.squeeze(x)  # 从数组的形状中删除单维条目，即把shape中为1的维度去掉


print(x1)  # [0 1 2]
print(x1.shape)  # (3,)