一.多层感知机

1.基本概念

线性神经网络只能拟合线性关系，加入多个隐藏层的多层感知机，可使模型获得分析非线性问题的能力

若隐藏层H的计算方法依旧如输入层一样为WX+b的话，模型将依旧等价一个线性模型：

因此需要给输入层一个非线性的激活函数，得（单隐藏层，多隐藏层的话，除最后一个隐藏层，也都要有激活函数）：

2.常见的激活函数

1.修正线性单元ReLU

其导数就是一个阶跃函数，优点是可减轻梯度消失问题，且需要的算力小

2.sigmoid函数

即logistic函数，在logistic回归中也有使用，机器学习笔记(2)--logistic回归分类模型

优点是适合做概率分析

3.tanh函数

类似sigmoid函数，优点是均值为0且和坐标轴原点对称

3.自搭建多层感知机

import torch
import numpy as np
import torchvision 
import torchvision.transforms as transforms


# 获取MNIST数据集
def load_data_fashion_mnist(batch_size, resize=None):
    # 定义转换，将图像转换为Tensor，并且归一化
    transform = transforms.ToTensor()
    if resize:
        transform = transforms.Compose([
            transforms.Resize(resize),
            transforms.ToTensor()
        ])
    # 加载数据集
    mnist_train = torchvision.datasets.FashionMNIST(root='./database', train=True, download=True, transform=transform)
    mnist_test = torchvision.datasets.FashionMNIST(root='./database', train=False, download=True, transform=transform)

    # 加载数据，windows下只支持num_workers=0，其他可以为4
    train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=0)
    test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=0)
    return train_iter, test_iter


batch_size = 256
train_iter, test_iter = load_data_fashion_mnist(batch_size)

# 初始化参数
num_inputs = 784 # 28*28像素
num_hiddens = 256 # 隐藏层神经元数量
num_outputs = 10 # 10个类型
W1 = torch.tensor(np.random.normal(0, 0.01, (num_inputs, num_hiddens)), 
                    dtype=torch.float32, requires_grad=True) # 权重为均值为0，标准差为0.01的正态分布随机数
b1 = torch.zeros(num_hiddens, dtype=torch.float32, requires_grad=True) # 偏置为0
W2 = torch.tensor(np.random.normal(0, 0.01, (num_hiddens, num_outputs)), 
                    dtype=torch.float32, requires_grad=True) 
b2 = torch.zeros(num_outputs, dtype=torch.float32, requires_grad=True) 
params = [W1, b1, W2, b2]

# 定义ReLU函数
def relu(X):
    return torch.max(input=X, other=torch.tensor(0.0))

# 定义模型
def net(X):
    X = X.view(-1, num_inputs)
    H = relu(torch.matmul(X, W1) + b1)
    return torch.matmul(H, W2) + b2

# 定义损失函数
loss = torch.nn.CrossEntropyLoss()

# 定义sgd优化算法
def sgd(params, lr, batch_size):
    for param in params:
        if param.grad is not None:
            param.data -= lr * param.grad / batch_size

# 计算模型分类准确性
def evaluate_accuracy(data_iter, net):
    acc_sum, n = 0.0, 0
    for X, y in data_iter:
        acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()
        n += y.shape[0]
    return acc_sum / n

# 定义训练模型函数
def train_net(net, train_iter, test_iter, loss, num_epochs, batch_size, params=None, lr=None, optimizer=None):
    for epoch in range(num_epochs):
        train_l_sum, train_acc_sum, n = 0.0, 0.0, 0
        for X, y in train_iter:
            y_hat = net(X)
            l = loss(y_hat, y).sum()
            # 梯度清零
            if optimizer is None:
                for param in params:
                    if param.grad is not None:
                        param.grad.data.zero_()
            else:
                optimizer.zero_grad()

            l.backward()
            if optimizer is None:
                sgd(params, lr, batch_size)
            else:
                optimizer.step()
            l = l.item()
            train_l_sum += l
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()
            n += y.shape[0]
        test_acc = evaluate_accuracy(test_iter, net)
        print('epoch %d, loss %f, train acc %f, test acc %f'
              % (epoch + 1, train_l_sum / n, train_acc_sum / n, test_acc))

# 训练模型
num_epochs = 5
lr = 100.0
train_net(net, train_iter, test_iter, loss, num_epochs, batch_size, params, lr)

4.pytorch实现多层感知机

import torch
import numpy as np
import sys
import torchvision 
import torchvision.transforms as transforms
from torch import nn
from torch.nn import init



# 获取MNIST数据集
def load_data_fashion_mnist(batch_size, resize=None):
    # 定义转换，将图像转换为Tensor，并且归一化
    transform = transforms.ToTensor()
    if resize:
        transform = transforms.Compose([
            transforms.Resize(resize),
            transforms.ToTensor()
        ])
    # 加载数据集
    mnist_train = torchvision.datasets.FashionMNIST(root='./database', train=True, download=True, transform=transform)
    mnist_test = torchvision.datasets.FashionMNIST(root='./database', train=False, download=True, transform=transform)

    # 加载数据，windows下只支持num_workers=0，其他可以为4
    train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=0)
    test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=0)
    return train_iter, test_iter


batch_size = 256
train_iter, test_iter = load_data_fashion_mnist(batch_size)

num_inputs, num_outputs, num_hiddens = 784, 10, 256

# 形状转换，将1*28*28的图像转换为784的向量
class FlattenLayer(torch.nn.Module):
    def __init__(self):
        super(FlattenLayer, self).__init__()
    def forward(self, x):
        return x.view(x.shape[0], -1)

# 定义模型
net = torch.nn.Sequential(
    FlattenLayer(),
    torch.nn.Linear(num_inputs, num_hiddens),
    torch.nn.ReLU(),
    torch.nn.Linear(num_hiddens, num_outputs)
)

# 参数初始化
for param in net.parameters():
    init.normal_(param, mean=0, std=0.01)

loss = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(), lr=0.5)

# 计算模型分类准确性
def evaluate_accuracy(data_iter, net):
    acc_sum, n = 0.0, 0
    for X, y in data_iter:
        acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()
        n += y.shape[0]
    return acc_sum / n

# 定义训练模型函数
def train_net(net, train_iter, test_iter, loss, num_epochs, batch_size, params=None, lr=None, optimizer=None):
    for epoch in range(num_epochs):
        train_l_sum, train_acc_sum, n = 0.0, 0.0, 0
        for X, y in train_iter:
            y_hat = net(X)
            l = loss(y_hat, y).sum()
            # 梯度清零
            if optimizer is None:
                for param in params:
                    if param.grad is not None:
                        param.grad.data.zero_()
            else:
                optimizer.zero_grad()

            l.backward()
            if optimizer is None:
                sgd(params, lr, batch_size)
            else:
                optimizer.step()
            l = l.item()
            train_l_sum += l
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()
            n += y.shape[0]
        test_acc = evaluate_accuracy(test_iter, net)
        print('epoch %d, loss %f, train acc %f, test acc %f'
              % (epoch + 1, train_l_sum / n, train_acc_sum / n, test_acc))

# 训练模型
num_epochs = 5
train_net(net, train_iter, test_iter, loss, num_epochs, batch_size, None, None, optimizer)