从认识AI开始-----MLP详解：从历史动机到实战实现-CSDN博客

本文链接：https://blog.csdn.net/weixin_48222697/article/details/148239364

前言

在人工智能的word中，深度学习是最核心的组成部分，而神经网络正是其基础结构。对于初学者来说，直接使用Pytroch等框架能够快速构建模型，但小伙伴们是否真正理解了每一层在做什么?现在，让我们从最古老的感知机开始，深入理解神经网络究竟干了什么？

一、从感知机到多层感知机

1. 感知机的诞生

1958年，Frank Rosenblatt 提出了“感知机”模型，这是一种模仿人脑神经元的二分类线性模型，其实现原理只是一个简单的公式：

$y=sign(w^Tx+b)$

当时，这个感知机模型已经能很好地处理线性可分问题了，比如判断一个点是否在某条直线的左边。然而，Minsky 在1969年证明了：单层感知机无法解决异或问题，因为异或是一个非线性可分问题。这使得神经网络的研究在70-80年代陷入了低谷。

2. 多层感知机（MLP）的崛起

因为感知机无法处理非线性可分问题，导致那时神经网络的研究停滞不前，甚至很多研究者都放弃了这个方向的探索，直到1986年，Rumelhart和Hinton提出了反向传播算法，成功训练了包含多个隐藏层的感知机，这就是直到还在发挥作用的多层感知机MLP

为什么需要MLP？

我们前面已经知道，感知机无法处理非线性问题，而在现实世界中，很多问题都是非线性问题，比如：图像识别的猫狗分类，股票预测等等，这些问题都无法用一条直线分割，因此我们需要MLP来进行更强大的非线性建模

三、MLP的结构与原理

MLP是什么呢？其实它的结构也很简单，只是有多个“线性层+非线性激活函数”堆叠而成的前馈神经网络：

输入层 $\rightarrow$ 隐藏层1（线性 + 非线性） $\rightarrow$ 隐藏层2 $\rightarrow$ ..... $\rightarrow$ 输出层

每一层都执行：

$h^l=\sigma (w^l*h^{l-1} + b^l)$

假设我们有两个隐藏层，则2层MLP就可以表示为：

$h_1 = \sigma(w_1*x+b_1)$

$h_2 = \sigma (w_2*h_1+b_2)$

$\hat y=softmax(w_3*h_2+b_3)$

四、手写一个两层MLP

接下来，我简单写一下如何实现两层MLP：

首先，先实现以下非线性激活函数ReLU

import numpy as np

def relu(x):
    return np.maximum(0, x)
def relu_derivative(x):
    return (x > 0).astype(float)

接着，实现两层MLP

class MLP:
    def __init__(self, input_size, hidden_size, output_size):
        super(MLP, self).__init__()
        self.w1 = nn.random.randn(input_size, hidden_size) * np.sqrt(1./input_size)
        self.b1 = nn.zeros((1, hidden_size))
        self.w2 = nn.random.randn(hidden_size, output_size) * np.sqrt(1./hidden_size)
        self.b2 = nn.zeros((1, output_size))

    def forward(self, x):
        self.h1 = x @ self.w1 + self.b1
        self.h1 = relu(self.h1)
        self.h2 = self.h1 @ self.w2 + self.b2
        self.h2 = self.softmax(self.h2)

    def softmax(self, x):
        x = np.exe(x-np.max(x, axis=1, keepdims=True))
        return x / np.sum(x, axis=1, keepdims=True)
    
    def compute_loss(pred, lable):
        len = label.shape[0]
        log_ = -np.log(pred[range[len], label])
        return np.sum(log_)

以上就是手写的MLP，接下来，我使用pytorch内置的linear函数来实现两层MLP：

import torch
import torch.nn as nn
import torch.nn.functional as F

class MLP(nn.Module):
    def __init__(self, ):
        super(MLP, self,).__init__()
        self.fc1 = nn.Linear(256, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)
    def forward(self, x):
        x = x.view(-1, 256)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.fc2(x)
        x = F.relu(x)
        x = self.fc3(x)
        return x