【人工智能-初级】第9章 神经网络的基础：理解感知器与激活函数

时间：2024-10-20 10:53:02

文章目录

    • 一、神经网络简介
    • 二、感知器简介
      • 2.1 感知器的定义
      • 2.2 感知器的工作过程
    • 三、激活函数
      • 3.1 阶跃函数
      • 3.2 Sigmoid 函数
      • 3.3 Tanh 函数
      • 3.4 ReLU 函数
      • 3.5 Leaky ReLU 函数
    • 四、Python 实现感知器与激活函数
      • 4.1 导入必要的库
      • 4.2 实现感知器模型
      • 4.3 使用感知器进行分类
      • 4.4 实现激活函数
    • 五、总结
      • 5.1 学习要点
      • 5.2 练习题

一、神经网络简介

神经网络（Neural Network）是一种模仿人脑神经元结构的机器学习模型，是深度学习的核心。神经网络由多个“神经元”组成，这些神经元通过权重连接形成层次结构，从而实现对复杂数据的学习和建模。神经网络的应用广泛，包括图像识别、自然语言处理、语音识别等领域。

神经网络的基本单元是感知器（Perceptron），感知器可以看作是最简单的神经网络，它的理解是深入神经网络和深度学习的第一步。此外，激活函数也是神经网络的重要组成部分，能够帮助神经网络捕捉数据的非线性特征。

二、感知器简介

2.1 感知器的定义

感知器（Perceptron）是最基本的神经元模型，用于模拟人类神经元的工作原理。它是一个线性分类器，能够将输入数据划分为两个类别。感知器接收若干输入信号，通过权重和偏置进行加权和运算，然后通过一个激活函数输出结果。

感知器的数学表达式为：

y = f ( w 1 x 1 + w 2 x 2 + . . . + w n x n + b ) y = f(w_1 x_1 + w_2 x_2 + ... + w_n x_n + b) y=f(w1​x1​+w2​x2​+...+wn​xn​+b)

其中：

  • x_1, x_2, …, x_n：输入特征。
  • w_1, w_2, …, w_n：感知器的权重。
  • b：偏置项，调节感知器的输出。
  • f：激活函数，决定感知器的输出。
  • y：感知器的输出（通常是0或1）。

2.2 感知器的工作过程

感知器的工作过程可以简单描述为：

  1. 计算加权和：将所有输入特征与对应的权重相乘，然后相加，最后加上偏置项。
  2. 应用激活函数：将加权和传递给激活函数，得到感知器的输出。
  3. 输出结果：根据激活函数的输出，得到0或1的分类结果。

感知器可以用于解决简单的线性分类问题，例如判断某个数据点是属于类别A还是类别B。然而，单一的感知器只能处理线性可分的问题，对于更复杂的非线性问题，必须通过将多个感知器组合成更复杂的神经网络来解决。

三、激活函数

激活函数（Activation Function）是神经网络中非常重要的组成部分，它的作用是将输入的加权和转换为输出。激活函数引入了非线性，使得神经网络能够捕捉复杂的数据关系和特征。常用的激活函数有：

3.1 阶跃函数

阶跃函数（Step Function）是感知器最早使用的激活函数，用于将输入映射到0或1。阶跃函数的数学表达式为：

f ( x ) = { 1 x ≥ 0 0 x < 0 f(x) = \begin{cases} 1 & x \geq 0 \\ 0 & x < 0 \end{cases} f(x)={10​x≥0x<0​

虽然阶跃函数简单，但它不能处理连续数值输入，因此在现代神经网络中很少使用。

3.2 Sigmoid 函数

Sigmoid 函数将输入映射到0到1之间，是一种常见的激活函数。它的数学表达式为：

f ( x ) = 1 1 + e − x f(x) = \frac{1}{1 + e^{-x}} f(x)=1+e−x1​

Sigmoid 函数的输出值介于0和1之间，常用于二分类任务。它的优点是输出值可以解释为概率，但缺点是容易在反向传播中导致梯度消失。

3.3 Tanh 函数

Tanh 函数（双曲正切函数）是 Sigmoid 函数的改进版本，输出范围在 -1 到 1 之间。它的数学表达式为：

f ( x ) = tanh ⁡ ( x ) = e x − e − x e x + e − x f(x) = \tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}} f(x)=tanh(x)=ex+e−xex−e−x​

Tanh 函数的输出范围比 Sigmoid 更大，梯度消失问题相对较轻，因此常用于隐藏层的激活函数。

3.4 ReLU 函数

ReLU 函数（Rectified Linear Unit）是现代神经网络中最常用的激活函数，定义为：

f ( x ) = max ⁡ ( 0 , x ) f(x) = \max(0, x) f(x)=max(0,x)

ReLU 的优点是计算简单，不容易导致梯度消失问题，但其缺点是可能会导致一些神经元“死亡”，即它们的梯度始终为0，无法更新。

3.5 Leaky ReLU 函数

Leaky ReLU 函数是 ReLU 的改进版，允许对负值有一个小的斜率，以避免神经元“死亡”。它的数学表达式为：

f ( x ) = { x x ≥ 0 α x x < 0 f(x) = \begin{cases} x & x \geq 0 \\ \alpha x & x < 0 \end{cases} f(x)={xαx​x≥0x<0​

其中，(\alpha) 是一个较小的常数，通常取0.01。

四、Python 实现感知器与激活函数

接下来，我们使用 Python 来实现一个简单的感知器，并尝试使用不同的激活函数。

4.1 导入必要的库

首先，我们需要导入一些必要的库：

import numpy as np
import matplotlib.pyplot as plt
  • numpy：用于数值计算。
  • matplotlib：用于绘制图形，帮助我们更好地理解激活函数的作用。

4.2 实现感知器模型

我们实现一个简单的感知器模型，感知器的输入是特征向量，输出是0或1。

class Perceptron:
    def __init__(self, input_size, learning_rate=0.01):
        self.weights = np.random.randn(input_size)
        self.bias = np.random.randn()
        self.learning_rate = learning_rate

    def step_function(self, x):
        return 1 if x >= 0 else 0

    def predict(self, x):
        linear_output = np.dot(self.weights, x) + self.bias
        return self.step_function(linear_output)

    def train(self, X, y, epochs):
        for _ in range(epochs):
            for xi, yi in zip(X, y):
                y_pred = self.predict(xi)
                error = yi - y_pred
                self.weights += self.learning_rate * error * xi
                self.bias += self.learning_rate * error
  • Perceptron 类：实现感知器的基本结构。
  • step_function：用于将加权和转换为输出0或1。
  • predict：计算线性输出并通过激活函数获得最终预测。
  • train：通过调整权重和偏置来训练感知器。

4.3 使用感知器进行分类

接下来，我们生成一些简单的数据，并使用感知器对其进行分类。

# 生成数据
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 0, 0, 1])  # AND 操作

# 创建感知器并进行训练
perceptron = Perceptron(input_size=2)
perceptron.train(X, y, epochs=10)

# 测试感知器
for xi in X:
    print(f"Input: {xi}, Predicted: {perceptron.predict(xi)}")
  • X 和 y：输入数据和标签，这里使用的是 AND 操作的数据集。
  • Perceptron(input_size=2)：创建一个具有两个输入特征的感知器。
  • train：训练感知器，使其学习 AND 操作。
  • predict：使用训练好的感知器进行预测。

4.4 实现激活函数

我们实现一些常见的激活函数，并绘制它们的图像，帮助我们更好地理解这些函数的作用。

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def tanh(x):
    return np.tanh(x)

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

def leaky_relu(x, alpha=0.01):
    return np.where(x > 0, x, alpha * x)

# 绘制激活函数
x = np.linspace(-10, 10, 100)

plt.figure(figsize=(12, 8))
plt.subplot(2, 2, 1)
plt.plot(x, sigmoid(x))
plt.title('Sigmoid Function')

plt.subplot(2, 2, 2)
plt.plot(x, tanh(x))
plt.title('Tanh Function')

plt.subplot(2, 2, 3)
plt.plot(x, relu(x))
plt.title('ReLU Function')

plt.subplot(2, 2, 4)
plt.plot(x, leaky_relu(x))
plt.title('Leaky ReLU Function')

plt.tight_layout()
plt.show()
  • sigmoid, tanh, relu, leaky_relu：实现常见的激活函数。
  • plt.plot：绘制激活函数的图像，帮助理解它们的特性。

五、总结

感知器是神经网络的基础，通过加权和偏置来对输入数据进行分类。然而，单一的感知器只能解决线性可分的问题，无法处理复杂的非线性问题。因此，在现代神经网络中，感知器通常被组合成多层感知器（MLP），以实现更复杂的功能。

激活函数是神经网络的重要组成部分，它为网络引入非线性，使得神经网络能够学习复杂的数据模式。常见的激活函数包括 Sigmoid、Tanh、ReLU 和 Leaky ReLU，每种激活函数都有其优缺点。

5.1 学习要点

  1. 感知器的基本结构：理解感知器的输入、权重、偏置和激活函数。
  2. 激活函数的作用：激活函数为神经网络引入非线性，使得网络能够学习复杂的数据关系。
  3. Python 实现：通过 Python 实现感知器和激活函数，理解其基本工作原理。

5.2 练习题

  1. 修改感知器的代码，使其能够解决 OR 操作的问题。
  2. 使用 ReLU 激活函数替代阶跃函数，观察对感知器输出的影响。
  3. 结合多个感知器实现一个简单的多层感知器（MLP），并用其解决 XOR 问题。

希望本文能帮助您更好地理解神经网络的基础知识。下一篇文章将为您介绍如何用 Python 从零构建简单的神经网络。如果有任何问题，欢迎在评论中讨论！

相关文章