如何创建基本的人工神经网络
学习使用Python和NumPy从头构建神经网络。通过简单示例理解神经元、层、激活函数和训练。
神经网络为许多我们日常使用的AI应用提供动力——从图像识别到语言翻译。但其核心只是从数据中学习模式的数学函数。
理解如何从头构建基本神经网络是掌握深度学习基础的最佳方法之一。您将确切地看到训练模型时幕后发生了什么,而不依赖隐藏细节的黑盒库。
在本教程中,我们将使用Python和NumPy逐步构建一个简单的神经网络。无需深度学习经验——只需基本的Python知识。
什么是神经网络?#
想象一下,你的大脑有数十亿个叫做神经元的微小细胞,它们相互通信。当你看到一只猫时,特定的神经元一起触发以识别模式:尖耳朵、胡须、皮毛。这种模式识别通过经验自动发生。
人工神经网络使用数学运算模仿这种想法。它由以下组成:
- 神经元:接收输入、进行数学运算并产生输出的简单处理单元
- 层:按序列排列的神经元组(输入层、隐藏层、输出层)
- 权重:确定每个输入重要性的数字(像神经元之间连接的强度)
- 偏置:帮助网络独立于输入做出决策的数字
- 激活函数:添加非线性的数学函数,允许网络学习复杂模式
[!NOTE] 神经网络本质上是将输入数据转换为预测的数学运算链。
单个神经元如何工作#
让我们从最简单的构建块开始:单个神经元。
将神经元想象成一个决策机器。它接收多个输入,将每个输入乘以权重(重要性),将它们与偏置相加,然后将结果通过激活函数以决定是否”触发”(输出值)。
数学表达式如下:
输出 = 激活(总和(输入 × 权重) + 偏置)text让我们用Python构建一个:
import numpy as np
def sigmoid(x):
"""Sigmoid激活函数:将值压缩在0和1之间"""
return 1 / (1 + np.exp(-x))
class Neuron:
def __init__(self, weights, bias):
self.weights = weights
self.bias = bias
def feedforward(self, inputs):
"""将输入传递给神经元"""
# 输入加权,添加偏置,然后应用激活
total = np.dot(self.weights, inputs) + self.bias
return sigmoid(total)
# 创建一个有2个输入的神经元
weights = np.array([0, 1]) # w1 = 0, w2 = 1
bias = 4 # b = 4
n = Neuron(weights, bias)
# 用输入[2, 3]测试
x = np.array([2, 3]) # x1 = 2, x2 = 3
print(n.feedforward(x)) # 输出: 0.9990889488055994python发生了什么?
- 输入:
[2, 3] - 加权和:
(2 × 0) + (3 × 1) + 4 = 7 - Sigmoid(7) ≈ 0.999(压缩到接近1)
Sigmoid函数只是激活函数的一种。它对分类很有用,因为它输出0到1之间的值,我们可以将其解释为概率。
构建简单神经网络#
单个神经元有限制——它只能学习简单模式。为了解决更复杂的问题,我们将多个神经元连接成层。
让我们构建一个具有以下结构的网络:
- 2个输入神经元
- 1个隐藏层,有2个神经元
- 1个输出神经元
import numpy as np
def sigmoid(x):
return 1 / (1 + np.exp(-x))
class NeuralNetwork:
def __init__(self):
# 隐藏层的权重和偏置(2输入 -> 2隐藏神经元)
self.weights1 = np.array([[0.1, 0.2], [0.3, 0.4]]) # 2x2矩阵
self.bias1 = np.array([0.1, 0.2]) # 2个偏置
# 输出层的权重和偏置(2隐藏 -> 1输出)
self.weights2 = np.array([0.5, 0.6]) # 1x2向量
self.bias2 = np.array([0.3]) # 1个偏置
def feedforward(self, x):
"""通过网络前向传播"""
# 隐藏层
hidden_sum = np.dot(x, self.weights1) + self.bias1
hidden_output = sigmoid(hidden_sum)
# 输出层
output_sum = np.dot(hidden_output, self.weights2) + self.bias2
output = sigmoid(output_sum)
return output
# 测试网络
network = NeuralNetwork()
x = np.array([0.5, 0.7])
print(network.feedforward(x)) # 输出: ~0.7python这个网络接收2个输入,通过隐藏层处理它们,并产生1个输出。但有一个问题:权重是随机的!网络不知道自己在做什么。
训练神经网络#
训练是调整权重和偏置以便网络做出准确预测的过程。它的工作原理如下:
- 前向传播:将输入传递给网络以获得预测
- 计算损失:将预测与实际答案比较(我们错了多少?)
- 反向传播:计算每个权重对错误的贡献程度
- 更新权重:稍微调整权重以减少错误
- 重复:重复多次直到网络学习
[!TIP]
- 这被称为”梯度下降”——我们正在慢慢走下山坡(错误)以找到最低点(最佳权重)。
让我们为一个简单任务实现训练:将数字分类为”小”(< 0.5)或”大”(≥ 0.5)。
import numpy as np
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def sigmoid_derivative(x):
"""Sigmoid的导数,用于反向传播"""
return x * (1 - x)
class NeuralNetwork:
def __init__(self):
# 随机初始化权重
self.weights1 = np.random.rand(2, 2)
self.bias1 = np.random.rand(2)
self.weights2 = np.random.rand(2)
self.bias2 = np.random.rand(1)
def feedforward(self, x):
self.hidden_sum = np.dot(x, self.weights1) + self.bias1
self.hidden_output = sigmoid(self.hidden_sum)
self.output_sum = np.dot(self.hidden_output, self.weights2) + self.bias2
self.output = sigmoid(self.output_sum)
return self.output
def backpropagate(self, x, y, learning_rate=0.1):
"""用一个例子训练网络"""
# 前向传播
output = self.feedforward(x)
# 计算错误
error = y - output
# 反向传播
# 输出层梯度
d_output = error * sigmoid_derivative(output)
d_weights2 = np.dot(self.hidden_output.T, d_output)
# 隐藏层梯度
d_hidden = np.dot(d_output, self.weights2) * sigmoid_derivative(self.hidden_output)
d_weights1 = np.outer(x, d_hidden)
# 更新权重和偏置
self.weights2 += learning_rate * d_weights2
self.bias2 += learning_rate * np.sum(d_output)
self.weights1 += learning_rate * d_weights1
self.bias1 += learning_rate * np.sum(d_hidden)
return np.mean(error ** 2) # 返回均方误差
# 训练数据:将数字分类为小(0)或大(1)
X = np.array([[0.1], [0.2], [0.3], [0.4], [0.6], [0.7], [0.8], [0.9]])
y = np.array([0, 0, 0, 0, 1, 1, 1, 1])
# 将X扩展为2个特征(添加第二个随机特征)
X = np.hstack([X, np.random.rand(8, 1)])
# 创建并训练网络
network = NeuralNetwork()
epochs = 10000
for epoch in range(epochs):
total_error = 0
for i in range(len(X)):
error = network.backpropagate(X[i], y[i])
total_error += error
if epoch % 1000 == 0:
print(f"Epoch {epoch}, 错误: {total_error / len(X):.4f}")
# 测试训练后的网络
test_input = np.array([[0.25, 0.5]])
print(f"0.25的预测: {network.feedforward(test_input[0]):.4f}")
test_input = np.array([[0.75, 0.5]])
print(f"0.75的预测: {network.feedforward(test_input[0]):.4f}")python训练后,网络应该对小数字预测接近0的值,对大数字预测接近1的值。
理解组件#
激活函数#
激活函数引入非线性,允许神经网络学习复杂模式。没有它们,神经网络将只是一个线性回归模型。
常见激活函数:
- Sigmoid:输出0到1之间(适合二分类)
- ReLU:负输入输出0,正输入不变通过(隐藏层中最常见)
- Softmax:将输出转换为概率(适合多分类)
损失函数#
损失函数衡量网络预测的错误程度。
- 均方误差(MSE):预测和目标之间平方差的平均值(用于回归)
- 交叉熵损失:测量预测分布和实际分布之间的差异(用于分类)
学习率#
学习率控制更新权重时的步长。
- 太高:可能超过最优解
- 太低:训练永远需要
- 典型值:0.001到0.1
转向实际应用#
从头构建神经网络非常适合学习,但在实践中,您将使用深度学习框架,如:
- TensorFlow/Keras:行业标准,很多教程
- PyTorch:研究中流行,Pythonic设计
- JAX:高性能,可组合
使用Keras的相同简单网络:
import numpy as np
from tensorflow import keras
from tensorflow.keras import layers
# 训练数据
X = np.array([[0.1, 0.5], [0.2, 0.3], [0.3, 0.7], [0.4, 0.2],
[0.6, 0.8], [0.7, 0.4], [0.8, 0.6], [0.9, 0.1]])
y = np.array([0, 0, 0, 0, 1, 1, 1, 1])
# 构建模型
model = keras.Sequential([
layers.Dense(2, activation='relu', input_shape=(2,)),
layers.Dense(1, activation='sigmoid')
])
# 编译模型
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# 训练模型
model.fit(X, y, epochs=100, verbose=0)
# 测试模型
print(model.predict(np.array([[0.25, 0.5]])))
print(model.predict(np.array([[0.75, 0.5]])))pythonKeras为您处理所有数学、优化和管理。但现在您了解了幕后发生的事情。
常见挑战#
构建神经网络时,您会遇到几个挑战:
梯度消失#
在深层网络中,梯度在反向传播期间可能变得极小,导致早期层学习非常慢。解决方案:使用ReLU激活、仔细的权重初始化或残差连接。
过拟合#
网络记忆训练数据但无法泛化到新数据。解决方案:添加dropout、使用更多训练数据、应用正则化或早期停止。
选择架构#
多少层?多少神经元?没有公式——实验是关键。从简单开始,然后根据需要添加复杂性。
下一步#
现在您了解了基础知识,您可以:
- 尝试不同的架构:尝试更深的网络、不同的激活函数
- 使用真实数据集:MNIST(手写数字)、CIFAR-10(图像)、IMDB(文本)
- 学习高级技术:用于图像的卷积神经网络(CNN)、用于序列的循环神经网络(RNN)
- 探索框架:深入TensorFlow、PyTorch或JAX
结论#
从头构建神经网络揭开了深度学习的”魔法”面纱。您已经看到,其核心只是数学——乘法、加法和函数组合——以巧妙的方式排列以从数据中学习模式。
您学到的概念——神经元、层、激活函数、前向/反向传播——是所有现代AI系统的基础。无论您是构建图像分类器、语言模型还是推荐系统,这些基础保持不变。
从简单开始,经常实验,不要害怕破坏东西。这就是学习的方式。