首页手记 MLP入门：轻松掌握多层感知器基础

MLP入门：轻松掌握多层感知器基础

标签：

Python 机器学习

概述

本文介绍了多层感知器（MLP）的基础知识，包括其结构、前向传播和训练过程，以及在分类和回归问题中的应用。此外，文章还详细讲解了如何使用Python和TensorFlow实现MLP，并提供了实践示例，帮助读者掌握MLP入门知识。

MLP入门：轻松掌握多层感知器基础

1. MLP简介

什么是MLP

多层感知器（Multi-Layer Perceptron，MLP）是一种基本的神经网络结构，由多个全连接的神经元层构成。其主要特点是包含一个或多个隐含层，且每个神经元接受来自前一层所有神经元的输入，并通过加权求和与激活函数获得输出。

MLP是由苏联科学家叶夫根尼·莫斯科夫斯基（Evgeny G. Moskalev）在1960年代提出的。然而，直到1980年代，随着反向传播算法的引入，MLP才得到了广泛应用。反向传播算法使得神经网络的训练变得高效，从而推动了深度学习的发展。

MLP的历史背景

MLP的历史可以追溯到1960年代，当时科学家们开始尝试使用计算机模拟人脑的神经网络。1969年，马文·明斯基（Marvin Minsky）和塞缪尔·派珀特（Seymour Papert）对早期的神经网络模型——感知器进行了批评，认为其功能有限。这导致了神经网络研究的短暂停滞。

然而，1980年代的反向传播算法使得神经网络能够处理非线性问题，从而恢复了神经网络研究的热情。1986年，大卫·鲁梅尔哈特（David E. Rumelhart）、杰弗里·辛顿（Geoffrey Hinton）和罗纳德·威廉姆斯（Ronald J. Williams）发表了著名论文《Learning Representations by Back-Propagating Errors》，详细介绍了反向传播算法，标志着MLP进入了一个新的发展阶段。

MLP在深度学习中的位置

MLP是深度学习领域的基础模型之一。由于其全连接的特性，MLP能够处理复杂的非线性问题。虽然现代的深度学习模型（如卷积神经网络、循环神经网络）在某些特定任务上表现更好，但MLP仍然在很多场景下发挥着重要作用。例如，当处理文本、音频或图像等数据时，MLP可以作为基础模型嵌入到更复杂的网络结构中。

2. MLP的基本结构

层的概念

MLP由输入层、一个或多个隐藏层和输出层构成。每一层都是由多个神经元组成的。神经元之间通过加权连接，每个连接都有一个权重值，表示信号的强度。

输入层：输入层接收原始数据，如图像像素值或文本词向量。
隐藏层：隐藏层用于提取数据的高级特征。这些特征是通过输入层传递的数据经过加权求和和激活函数处理而得到的。
输出层：输出层生成最终的预测结果，例如分类标签或回归值。

例如，一个简单的MLP可以包含一个输入层、一个隐藏层和一个输出层。假设输入层有4个神经元，隐藏层有3个神经元，输出层有2个神经元。每个隐藏层神经元都连接到输入层的4个神经元，每个输出层神经元都连接到隐藏层的3个神经元。

神经元及其激活函数

神经元是MLP的基本计算单元。每个神经元接收多个输入，应用权重进行加权求和，然后通过一个激活函数产生输出。

权重和偏置

权重：权重是连接两个神经元之间的权重值。假设有一个神经元${\textstyle x{i}}$，它通过权重${\textstyle w{ij}}$连接到另一个神经元${\textstyle x{j}}$。加权求和过程可以表示为：
[
y = \sum{i} w{ij} x{i} + b
]
其中，${\textstyle b}$是偏置项。
偏置项：偏置项${\textstyle b}$是神经元的一个额外输入，用于调节网络的输出。偏置项使得神经元可以拟合那些不能完全通过加权求和来表示的函数。

激活函数

激活函数将加权求和的结果映射到一个新的值。常见的激活函数包括ReLU（整流线性单元）、Sigmoid、Tanh等。

ReLU：ReLU激活函数定义为$f(x)=max(0,x)$。它的优点是计算简单，而且能够缓解梯度消失的问题。
Sigmoid：Sigmoid函数定义为$f(x)=\frac{1}{1+e^{-x}}$。它的输出值在0和1之间，因此常用于二分类问题。
Tanh：Tanh函数定义为$f(x)=\frac{1-e^{-2x}}{1+e^{-2x}}$。Tanh函数的输出值在-1和1之间，与Sigmoid函数类似，但其在0附近具有更好的平滑性。

实践示例

假设有一个简单的MLP，包含一个输入层、一个隐藏层和一个输出层。输入层有2个特征，隐藏层有3个神经元，输出层有1个神经元。权重和偏置项如下：

import numpy as np

# 输入层到隐藏层的权重和偏置
weights_input_hidden = np.array([[0.2, 0.3, 0.5],
                                 [0.4, 0.1, 0.6]])
bias_hidden = np.array([0.1, 0.2, 0.3])

# 隐藏层到输出层的权重和偏置
weights_hidden_output = np.array([[0.1, 0.2, 0.3]])
bias_output = np.array([0.2])

假设输入数据为x = [0.5, 0.8]，使用ReLU激活函数。

def relu(x):
    return np.maximum(0, x)

# 输入层到隐藏层的加权求和
hidden_input = np.dot(x, weights_input_hidden) + bias_hidden

# 隐藏层的激活
hidden_output = relu(hidden_input)

# 隐藏层到输出层的加权求和
output_input = np.dot(hidden_output, weights_hidden_output.T) + bias_output

# 输出层的激活
output = relu(output_input)

print("Hidden Layer Output:", hidden_output)
print("Output Layer Output:", output)

3. MLP的前向传播过程

输入层的处理

输入层不包含任何激活函数，它直接将输入数据传递给隐藏层。假设输入数据为x，则输入层的处理过程如下：

x = np.array([0.5, 0.8])

隐藏层的处理

隐藏层对输入数据进行加权求和，并应用激活函数。假设隐藏层有3个神经元，权重和偏置项如下：

weights_input_hidden = np.array([[0.2, 0.3, 0.5],
                                 [0.4, 0.1, 0.6]])
bias_hidden = np.array([0.1, 0.2, 0.3])

加权求和过程为：

hidden_input = np.dot(x, weights_input_hidden) + bias_hidden

应用ReLU激活函数：

def relu(x):
    return np.maximum(0, x)

hidden_output = relu(hidden_input)

输出层的处理

输出层对隐藏层的输出进行加权求和，并应用激活函数。假设输出层有1个神经元，权重和偏置项如下：

weights_hidden_output = np.array([[0.1, 0.2, 0.3]])
bias_output = np.array([0.2])

加权求和过程为：

output_input = np.dot(hidden_output, weights_hidden_output.T) + bias_output

应用ReLU激活函数：

output = relu(output_input)

实践示例

假设输入数据为x = [0.5, 0.8]，权重和偏置项如下：

import numpy as np

x = np.array([0.5, 0.8])
weights_input_hidden = np.array([[0.2, 0.3, 0.5],
                                 [0.4, 0.1, 0.6]])
bias_hidden = np.array([0.1, 0.2, 0.3])
weights_hidden_output = np.array([[0.1, 0.2, 0.3]])
bias_output = np.array([0.2])

def relu(x):
    return np.maximum(0, x)

# 隐藏层的加权求和
hidden_input = np.dot(x, weights_input_hidden) + bias_hidden

# 隐藏层的激活
hidden_output = relu(hidden_input)

# 输出层的加权求和
output_input = np.dot(hidden_output, weights_hidden_output.T) + bias_output

# 输出层的激活
output = relu(output_input)

print("Hidden Layer Output:", hidden_output)
print("Output Layer Output:", output)

4. MLP的训练过程

损失函数的选择

在训练MLP时，选择合适的损失函数至关重要。损失函数用于衡量模型预测值与真实值之间的差异。常见的损失函数包括均方误差（MSE）、交叉熵损失等。

均方误差（Mean Squared Error, MSE）：适用于回归问题。其定义为：
[
\text{MSE} = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y_i})^2
]
其中，$y_i$是真实值，$\hat{y_i}$是预测值。
交叉熵损失（Cross-Entropy Loss）：适用于分类问题。其定义为：
[
\text{Cross-Entropy} = - \frac{1}{n} \sum_{i=1}^{n} y_i \log(\hat{y_i}) + (1 - y_i) \log(1 - \hat{y_i})
]
其中，$y_i$是真实值，$\hat{y_i}$是预测值。

反向传播算法简介

反向传播算法是训练MLP的核心算法。它通过链式法则计算损失函数关于模型参数的梯度，并更新参数以最小化损失函数。

反向传播算法主要包括以下步骤：

前向传播：从输入层到输出层逐层计算输出值。
计算损失：使用损失函数计算模型的预测值与真实值之间的差异。
反向传播：从输出层开始逐层计算损失函数关于模型参数的梯度。
参数更新：使用梯度下降法等优化算法更新模型参数。

参数更新方法

参数更新方法主要有梯度下降法（Gradient Descent）和随机梯度下降法（Stochastic Gradient Descent, SGD）。

梯度下降法：梯度下降法通过计算损失函数关于参数的梯度，并沿着梯度的反方向更新参数。其更新公式为：
[
\theta_{t+1} = \theta_t - \eta \cdot \nabla L(\theta_t)
]
其中，$\theta$是模型参数，$\eta$是学习率，$\nabla L(\theta_t)$是损失函数关于参数的梯度。
随机梯度下降法：SGD每次迭代只使用一个样本的梯度来更新参数。这种方法计算速度快，但在某些情况下可能会导致参数更新不稳定。其更新公式为：
[
\theta_{t+1} = \theta_t - \eta \cdot \nabla L(\theta_t, x_i, y_i)
]
其中，$x_i$是样本，$y_i$是样本的真实值。

实践示例

假设有一个简单的MLP，包含一个输入层、一个隐藏层和一个输出层。输入层有2个特征，隐藏层有3个神经元，输出层有1个神经元。假设使用均方误差损失函数和梯度下降法进行训练。

import numpy as np
from sklearn.metrics import mean_squared_error

# 初始化权重和偏置
weights_input_hidden = np.random.rand(2, 3)
bias_hidden = np.random.rand(3)
weights_hidden_output = np.random.rand(3, 1)
bias_output = np.random.rand(1)

# 梯度下降法
def gradient_descent(X, y, weights_input_hidden, bias_hidden, weights_hidden_output, bias_output, learning_rate=0.01, epochs=1000):
    for epoch in range(epochs):
        # 前向传播
        hidden_input = np.dot(X, weights_input_hidden) + bias_hidden
        hidden_output = np.maximum(0, hidden_input)
        output_input = np.dot(hidden_output, weights_hidden_output.T) + bias_output
        output = np.maximum(0, output_input)

        # 计算损失
        loss = mean_squared_error(y, output)

        # 反向传播
        output_error = y - output
        output_delta = output_error * (output > 0)
        hidden_error = output_delta.dot(weights_hidden_output)
        hidden_delta = hidden_error * (hidden_output > 0)

        # 更新权重和偏置
        weights_hidden_output += learning_rate * hidden_output.T.dot(output_delta)
        bias_output += learning_rate * np.sum(output_delta, axis=0, keepdims=True)
        weights_input_hidden += learning_rate * X.T.dot(hidden_delta)
        bias_hidden += learning_rate * np.sum(hidden_delta, axis=0)

        if epoch % 100 == 0:
            print(f'Epoch {epoch}, Loss: {loss}')

    return weights_input_hidden, bias_hidden, weights_hidden_output, bias_output

# 数据示例
X = np.array([[0.5, 0.8], [0.2, 0.7]])
y = np.array([[0.1], [0.3]])

# 训练模型
weights_input_hidden, bias_hidden, weights_hidden_output, bias_output = gradient_descent(X, y, weights_input_hidden, bias_hidden, weights_hidden_output, bias_output)

5. MLP的应用场景

分类问题

MLP在分类问题中表现优异，特别是在处理多分类任务时。例如，预测图像中的物体类别，或者对文本进行情感分析。

假设有一个简单的二分类问题，输入数据为X，真实标签为y。使用交叉熵损失函数和SGD进行训练。

import numpy as np
import tensorflow as tf

# 初始化权重和偏置
weights_input_hidden = tf.Variable(tf.random.normal([2, 3]))
bias_hidden = tf.Variable(tf.random.normal([3]))
weights_hidden_output = tf.Variable(tf.random.normal([3, 1]))
bias_output = tf.Variable(tf.random.normal([1]))

# 定义损失函数和优化器
loss_fn = tf.keras.losses.BinaryCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.SGD(learning_rate=0.01)

# 训练模型
for epoch in range(1000):
    with tf.GradientTape() as tape:
        # 前向传播
        hidden_input = tf.matmul(X, weights_input_hidden) + bias_hidden
        hidden_output = tf.nn.relu(hidden_input)
        output_input = tf.matmul(hidden_output, weights_hidden_output) + bias_output
        output = tf.nn.sigmoid(output_input)

        # 计算损失
        loss = loss_fn(y, output)

    # 反向传播
    gradients = tape.gradient(loss, [weights_input_hidden, bias_hidden, weights_hidden_output, bias_output])
    optimizer.apply_gradients(zip(gradients, [weights_input_hidden, bias_hidden, weights_hidden_output, bias_output]))

    if epoch % 100 == 0:
        print(f'Epoch {epoch}, Loss: {loss.numpy()}')

回归问题

MLP在回归问题中同样表现出色。例如，预测房价或股票价格。

假设有一个简单的回归问题，输入数据为X，真实值为y。使用均方误差损失函数和SGD进行训练。

import numpy as np
import tensorflow as tf

# 初始化权重和偏置
weights_input_hidden = tf.Variable(tf.random.normal([2, 3]))
bias_hidden = tf.Variable(tf.random.normal([3]))
weights_hidden_output = tf.Variable(tf.random.normal([3, 1]))
bias_output = tf.Variable(tf.random.normal([1]))

# 定义损失函数和优化器
loss_fn = tf.keras.losses.MeanSquaredError()
optimizer = tf.keras.optimizers.SGD(learning_rate=0.01)

# 训练模型
for epoch in range(1000):
    with tf.GradientTape() as tape:
        # 前向传播
        hidden_input = tf.matmul(X, weights_input_hidden) + bias_hidden
        hidden_output = tf.nn.relu(hidden_input)
        output_input = tf.matmul(hidden_output, weights_hidden_output) + bias_output
        output = tf.nn.relu(output_input)

        # 计算损失
        loss = loss_fn(y, output)

    # 反向传播
    gradients = tape.gradient(loss, [weights_input_hidden, bias_hidden, weights_hidden_output, bias_output])
    optimizer.apply_gradients(zip(gradients, [weights_input_hidden, bias_hidden, weights_hidden_output, bias_output]))

    if epoch % 100 == 0:
        print(f'Epoch {epoch}, Loss: {loss.numpy()}')

实际案例分析

假设我们需要构建一个MLP模型，用于预测房价。模型输入是一个包含房屋面积和房间数的特征向量，输出是预测的房价。使用均方误差损失函数和SGD训练模型。

import numpy as np
import tensorflow as tf

# 生成示例数据
np.random.seed(0)
X = np.random.rand(100, 2)  # 特征向量：[面积, 房间数]
y = np.random.rand(100, 1)  # 真实房价

# 初始化权重和偏置
weights_input_hidden = tf.Variable(tf.random.normal([2, 3]))
bias_hidden = tf.Variable(tf.random.normal([3]))
weights_hidden_output = tf.Variable(tf.random.normal([3, 1]))
bias_output = tf.Variable(tf.random.normal([1]))

# 定义损失函数和优化器
loss_fn = tf.keras.losses.MeanSquaredError()
optimizer = tf.keras.optimizers.SGD(learning_rate=0.01)

# 训练模型
for epoch in range(1000):
    with tf.GradientTape() as tape:
        # 前向传播
        hidden_input = tf.matmul(X, weights_input_hidden) + bias_hidden
        hidden_output = tf.nn.relu(hidden_input)
        output_input = tf.matmul(hidden_output, weights_hidden_output) + bias_output
        output = tf.nn.relu(output_input)

        # 计算损失
        loss = loss_fn(y, output)

    # 反向传播
    gradients = tape.gradient(loss, [weights_input_hidden, bias_hidden, weights_hidden_output, bias_output])
    optimizer.apply_gradients(zip(gradients, [weights_input_hidden, bias_hidden, weights_hidden_output, bias_output]))

    if epoch % 100 == 0:
        print(f'Epoch {epoch}, Loss: {loss.numpy()}')

6. MLP的实现入门

使用Python实现MLP

使用Python实现MLP需要掌握NumPy等科学计算库。NumPy提供了高效的数组操作和矩阵运算功能，非常适合实现MLP。

简单示例

假设有一个简单的MLP，包含一个输入层、一个隐藏层和一个输出层。输入层有2个特征，隐藏层有3个神经元，输出层有1个神经元。

import numpy as np

# 初始化权重和偏置
weights_input_hidden = np.random.rand(2, 3)
bias_hidden = np.random.rand(3)
weights_hidden_output = np.random.rand(3, 1)
bias_output = np.random.rand(1)

# 梯度下降法
def gradient_descent(X, y, weights_input_hidden, bias_hidden, weights_hidden_output, bias_output, learning_rate=0.01, epochs=1000):
    for epoch in range(epochs):
        # 前向传播
        hidden_input = np.dot(X, weights_input_hidden) + bias_hidden
        hidden_output = np.maximum(0, hidden_input)
        output_input = np.dot(hidden_output, weights_hidden_output.T) + bias_output
        output = np.maximum(0, output_input)

        # 计算损失
        loss = np.mean((y - output) ** 2)

        # 反向传播
        output_error = y - output
        output_delta = output_error * (output > 0)
        hidden_error = output_delta.dot(weights_hidden_output)
        hidden_delta = hidden_error * (hidden_output > 0)

        # 更新权重和偏置
        weights_hidden_output += learning_rate * hidden_output.T.dot(output_delta)
        bias_output += learning_rate * np.sum(output_delta, axis=0, keepdims=True)
        weights_input_hidden += learning_rate * X.T.dot(hidden_delta)
        bias_hidden += learning_rate * np.sum(hidden_delta, axis=0)

        if epoch % 100 == 0:
            print(f'Epoch {epoch}, Loss: {loss}')

    return weights_input_hidden, bias_hidden, weights_hidden_output, bias_output

# 数据示例
X = np.array([[0.5, 0.8], [0.2, 0.7]])
y = np.array([[0.1], [0.3]])

# 训练模型
weights_input_hidden, bias_hidden, weights_hidden_output, bias_output = gradient_descent(X, y, weights_input_hidden, bias_hidden, weights_hidden_output, bias_output)

常见库介绍

TensorFlow

TensorFlow是一个流行的深度学习框架，提供了强大的工具和API来构建和训练神经网络。以下是一个简单的MLP使用TensorFlow实现的示例：

import tensorflow as tf

# 定义模型
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(3, activation='relu', input_shape=(2,)),
    tf.keras.layers.Dense(1)
])

# 编译模型
model.compile(optimizer='sgd', loss='mean_squared_error')

# 训练模型
X = np.array([[0.5, 0.8], [0.2, 0.7]])
y = np.array([[0.1], [0.3]])

model.fit(X, y, epochs=1000, verbose=0)

Keras

Keras是一个高级神经网络API，可以在TensorFlow等后端上运行。Keras提供了简洁的API来构建和训练神经网络。以下是一个简单的MLP使用Keras实现的示例：

import tensorflow as tf
from tensorflow import keras

# 定义模型
model = keras.Sequential([
    keras.layers.Dense(3, activation='relu', input_shape=(2,)),
    keras.layers.Dense(1)
])

# 编译模型
model.compile(optimizer='sgd', loss='mean_squared_error')

# 训练模型
X = np.array([[0.5, 0.8], [0.2, 0.7]])
y = np.array([[0.1], [0.3]])

model.fit(X, y, epochs=1000, verbose=0)

注意事项和调试技巧

在实现MLP时，需要注意以下事项：

权重初始化：随机初始化权重可以避免所有权重初始为零的情况。
学习率：选择合适的学习率对训练速度和模型性能有很大影响。过高的学习率可能导致模型发散，过低的学习率可能导致训练速度过慢。
损失函数：选择合适的损失函数可以提高模型的性能。例如，对于分类问题，使用交叉熵损失函数比均方误差损失函数更适合。
优化算法：使用梯度下降法或随机梯度下降法进行参数更新。梯度下降法计算量大，但更新更为稳定；随机梯度下降法计算量小，但更新可能不稳定。

调试MLP模型时，可以参考以下技巧：

打印中间结果：在训练过程中打印中间结果，观察损失函数的变化趋势，判断模型是否收敛。
可视化：使用可视化工具（如TensorBoard）观察模型的训练过程和权重的变化。
调整超参数：调整学习率、批次大小等超参数，观察模型性能的变化。
使用验证集：使用验证集评估模型的泛化能力，防止过拟合。

实践示例

假设我们需要构建一个MLP模型，用于预测房价。模型输入是一个包含房屋面积和房间数的特征向量，输出是预测的房价。使用TensorFlow实现。

import numpy as np
import tensorflow as tf

# 生成示例数据
np.random.seed(0)
X = np.random.rand(100, 2)  # 特征向量：[面积, 房间数]
y = np.random.rand(100, 1)  # 真实房价

# 定义模型
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(3, activation='relu', input_shape=(2,)),
    tf.keras.layers.Dense(1)
])

# 编译模型
model.compile(optimizer='sgd', loss='mean_squared_error')

# 训练模型
history = model.fit(X, y, epochs=1000, verbose=0)

# 打印训练过程中的损失变化
print(history.history['loss'])

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕莱坞森

手记
篇

粉丝

36

获赞与收藏

146

关注作者，订阅最新文章

阅读免费教程

Python 办公自动化教程

17个小节 25740 873

Python 算法入门教程

15个小节 27463 1074

Python 进阶应用教程

38个小节 65875 1035

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

MLP入门：轻松掌握多层感知器基础

什么是MLP

MLP的历史背景

MLP在深度学习中的位置

层的概念

神经元及其激活函数

权重和偏置

激活函数

实践示例

输入层的处理

隐藏层的处理

输出层的处理

实践示例

损失函数的选择

反向传播算法简介

参数更新方法

实践示例

分类问题

回归问题

实际案例分析

使用Python实现MLP

简单示例

常见库介绍

TensorFlow

Keras

注意事项和调试技巧

实践示例

阅读免费教程