自己动手写第一个神经网络程序：零基础入门指南

内容分享3周前发布 DunLing

0 1 0

从神秘到掌握，30行代码开启你的AI之旅

在人工智能时代，神经网络已成为变革性技术的核心。许多初学者误以为构建神经网络需要深厚的数学功底和庞大的计算资源，但今天我将带你从零开始实现一个完整的神经网络程序，仅用30行Python代码。无需框架，无需GPU，只需一台普通电脑！

一、为什么选择神经网络？

神经网络模拟人脑神经元的工作方式，通过“学习”数据中的模式解决复杂问题。它能完成：

图像/语音识别（如人脸解锁、语音助手）
自然语言处理（如机器翻译、情感分析）
预测与决策（如股票预测、自动驾驶）

核心优势：能解决线性模型无法处理的非线性问题（如经典的“异或逻辑”）。

二、手把手实现神经网络

环境准备

import numpy as np  # 科学计算库
import matplotlib.pyplot as plt  # 绘图库

1. 定义神经网络类（核心代码）

class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重（小型随机数）和偏置（零）
        self.W1 = np.random.randn(input_size, hidden_size) * 0.01
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) * 0.01
        self.b2 = np.zeros((1, output_size))
    
    def sigmoid(self, x):  # 激活函数
        return 1 / (1 + np.exp(-x))
    
    def forward(self, X):  # 前向传播
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self.sigmoid(self.z1)  # 隐藏层输出
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = self.sigmoid(self.z2)  # 最终输出
        return self.a2
    
    def backward(self, X, y, output, lr=0.1):  # 反向传播
        # 计算输出层误差
        error = y - output
        delta_output = error * (output * (1 - output))  # 含Sigmoid导数
        
        # 计算隐藏层误差
        error_hidden = delta_output.dot(self.W2.T)
        delta_hidden = error_hidden * (self.a1 * (1 - self.a1))
        
        # 更新参数（学习率lr控制步长）
        self.W2 += self.a1.T.dot(delta_output) * lr
        self.b2 += np.sum(delta_output, axis=0) * lr
        self.W1 += X.T.dot(delta_hidden) * lr
        self.b1 += np.sum(delta_hidden, axis=0) * lr
    
    def train(self, X, y, epochs=10000):  # 训练循环
        losses = []
        for i in range(epochs):
            output = self.forward(X)
            loss = np.mean((y - output) ** 2)  # 均方误差
            losses.append(loss)
            self.backward(X, y, output)
        return losses

2. 训练与测试

# 准备数据：XOR问题（输入一样输出0，不同输出1）
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])

# 创建网络：2输入→4隐藏神经元→1输出
nn = NeuralNetwork(input_size=2, hidden_size=4, output_size=1)

# 训练网络（10000轮）
losses = nn.train(X, y)

# 测试效果
predictions = np.round(nn.forward(X))
print("预测结果：
", predictions)
print("实际标签：
", y)

# 可视化损失下降
plt.plot(losses)
plt.title("训练损失变化曲线")
plt.xlabel("迭代次数")
plt.ylabel("均方误差")
plt.show()

三、代码原理解析

前向传播
输入数据从输入层→隐藏层→输出层，逐层加权求和并激活（本例使用Sigmoid函数），最终生成预测值。
反向传播
通过链式法则计算误差对参数的梯度，从输出层反向传递至输入层。这是神经网络学习的核心机制。
梯度下降
根据梯度方向更新权重（W）和偏置（b），学习率（lr）控制更新幅度。过大可能导致震荡，过小则收敛缓慢。
隐藏层的必要性
若删除隐藏层（单层感知机），无法解决XOR问题，验证了深度结构的价值。

四、运行结果示例

预测结果：
 [[0]
 [1]
 [1]
 [0]]
实际标签：
 [[0] 
 [1]
 [1]
 [0]]
准确率：100%

损失曲线持续下降，表明网络有效学习！

https://example.com/loss_curve.png
训练损失随迭代次数下降示意图

五、进一步优化方向

激活函数：将Sigmoid替换为ReLU（np.maximum(0, x)），缓解梯度消失
正则化：添加Dropout层（随机屏蔽神经元），防止过拟合
批量训练：将数据分小批量（Batch）迭代，加速收敛

关键提醒：实际应用中推荐使用TensorFlow/Keras等框架（如5行代码实现MNIST识别）

：

model = keras.Sequential([ keras.layers.Dense(128, activation=’relu’, input_shape=(784,)), keras.layers.Dense(10, activation=’softmax’) ]) model.compile(optimizer=’adam’, loss=’sparse_categorical_crossentropy’)