【人工智能-初级】第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(w1x1+w2x2+...+wnxn+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)={10x0x<0

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

3.2 Sigmoid 函数

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

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

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+exexex

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αxx0x<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 从零构建简单的神经网络。如果有任何问题,欢迎在评论中讨论!