现在位置: 首页 / 深度学习 / MNIST / 正文

深度学习入门教程：从感知机到神经网络实战

1. 前言：为什么2026年要学习深度学习？

深度学习是人工智能最核心、最热门的领域。从ChatGPT到Midjourney，从自动驾驶到AlphaFold，每一次AI的突破背后都是深度学习技术的演进。2026年，深度学习已经渗透到各行各业：医疗影像诊断、金融量化交易、智能推荐系统、语音助手、人脸识别……

什么是深度学习？
深度学习是机器学习的一个分支，它通过模拟人脑的神经网络结构，让计算机能够从海量数据中自动学习特征和模式。简单来说，深度学习就是多层次的神经网络。

本教程能带给你什么？
✅ 零基础理解神经网络的核心原理
✅ 掌握深度学习框架PyTorch的基本使用
✅ 从零实现一个简单的神经网络
✅ 实战图像分类项目——手写数字识别
✅ 为进阶大模型和AIGC打下坚实基础

本教程假设你已有Python基础（变量、函数、循环），不需要高深的数学知识，只需要一颗好奇的心！

2. 深度学习核心概念速览

在动手写代码之前，我们先理解几个核心概念，这会让后面的实战事半功倍。

2.1 神经网络的基本组成

  • 神经元（Neuron）：神经网络的基本计算单元，接收输入、加权求和、经过激活函数输出
  • 层（Layer）：多个神经元组成一层，常见的层有输入层、隐藏层、输出层
  • 权重（Weight）和偏置（Bias）：神经网络需要学习的参数
  • 激活函数（Activation Function）：引入非线性，让神经网络能学习复杂模式（如ReLU、Sigmoid）

2.2 神经网络如何学习？

  • 前向传播（Forward Propagation）：输入数据经过网络得到预测结果
  • 损失函数（Loss Function）：衡量预测结果与真实答案的差距
  • 反向传播（Backpropagation）：计算损失对每个参数的梯度
  • 优化器（Optimizer）：根据梯度更新参数，逐步减小损失（如SGD、Adam）

2.3 深度学习的“深度”意味着什么？

“深度”指神经网络的隐藏层数量。浅层网络（1-2个隐藏层）只能学习简单模式；深层网络（几十甚至上百层）可以学习非常复杂的特征，从边缘→纹理→物体局部→完整物体。

3. 环境搭建：安装深度学习框架

2026年最流行的深度学习框架是PyTorch和TensorFlow。本教程使用PyTorch，它更贴近Python风格，适合学习和研究。

3.1 安装PyTorch

访问 PyTorch官网，根据你的操作系统选择安装命令：

pip install torch torchvision torchaudio

如果有NVIDIA显卡（CUDA加速），选择对应CUDA版本的命令：

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

3.2 安装其他辅助库

pip install numpy matplotlib jupyter scikit-learn

3.3 验证安装

python -c "import torch; print(f'PyTorch版本：{torch.__version__}'); print(f'CUDA可用：{torch.cuda.is_available()}')"

4. 从零实现一个神经元

在接触高级框架之前，我们先手动实现一个最简单的神经元，理解底层原理。

import numpy as np
import matplotlib.pyplot as plt
class Neuron:
    def __init__(self, input_size):
        self.weights = np.random.randn(input_size) * 0.01
        self.bias = 0
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))
    def forward(self, inputs):
        self.inputs = inputs
        self.z = np.dot(inputs, self.weights) + self.bias
        self.output = self.sigmoid(self.z)
        return self.output
    def backward(self, d_output, learning_rate=0.1):
        d_z = d_output * self.output * (1 - self.output)
        d_weights = np.dot(self.inputs, d_z)
        d_bias = d_z
        self.weights -= learning_rate * d_weights
        self.bias -= learning_rate * d_bias
        return d_z
neuron = Neuron(input_size=2)
print("训练前：")
test_input = np.array([0.5, 0.3])
print(f"输入：{test_input}，输出：{neuron.forward(test_input):.4f}")
target = 1
for epoch in range(100):
    output = neuron.forward(test_input)
    loss = (output - target) ** 2
    d_output = 2 * (output - target)
    neuron.backward(d_output)
    if epoch % 20 == 0:
        print(f"Epoch {epoch}, Loss: {loss:.6f}, Output: {output:.4f}")
print(f"\n训练后输出：{neuron.forward(test_input):.4f}")

5. PyTorch入门：张量与自动求导

PyTorch的核心是张量（Tensor）和自动求导（Autograd）。

5.1 张量基础操作

import torch
a = torch.tensor([[1, 2], [3, 4]])
b = torch.randn(2, 2)
c = torch.zeros(3, 3)
print(f"a: {a}")
print(f"a的形状：{a.shape}")
if torch.cuda.is_available():
    a_gpu = a.cuda()
    print("张量已移动到GPU")

5.2 自动求导

x = torch.tensor([2.0], requires_grad=True)
y = x ** 2 + 3 * x + 1
y.backward()
print(f"x的梯度：{x.grad}")
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
y = (x ** 2).sum()
y.backward()
print(f"每个x的梯度：{x.grad}")

6. 使用PyTorch构建第一个神经网络

import torch
import torch.nn as nn
import torch.optim as optim
class SimpleNet(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleNet, self).__init__()
        self.layer1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(hidden_size, output_size)
        self.softmax = nn.Softmax(dim=1)
    def forward(self, x):
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)
        x = self.softmax(x)
        return x
input_size = 4
hidden_size = 8
output_size = 3
model = SimpleNet(input_size, hidden_size, output_size)
print(model)
total_params = sum(p.numel() for p in model.parameters())
print(f"总参数数量：{total_params}")
X = torch.randn(100, input_size)
y = torch.randint(0, output_size, (100,))
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)
num_epochs = 100
for epoch in range(num_epochs):
    outputs = model(X)
    loss = criterion(outputs, y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if (epoch + 1) % 20 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

7. 实战项目：MNIST手写数字识别

MNIST被称为深度学习的“Hello World”，包含0-9的手写数字图片（28×28像素）。

7.1 加载数据集

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])
train_dataset = torchvision.datasets.MNIST(
    root='./data', train=True, transform=transform, download=True
)
test_dataset = torchvision.datasets.MNIST(
    root='./data', train=False, transform=transform, download=True
)
batch_size = 64
train_loader = torch.utils.data.DataLoader(
    train_dataset, batch_size=batch_size, shuffle=True
)
test_loader = torch.utils.data.DataLoader(
    test_dataset, batch_size=batch_size, shuffle=False
)
print(f"训练集大小：{len(train_dataset)}")
print(f"测试集大小：{len(test_dataset)}")
images, labels = next(iter(train_loader))
fig, axes = plt.subplots(1, 5, figsize=(10, 3))
for i in range(5):
    axes[i].imshow(images[i][0], cmap='gray')
    axes[i].set_title(f'Label: {labels[i].item()}')
    axes[i].axis('off')
plt.tight_layout()
plt.show()

7.2 定义神经网络模型

class MNISTNet(nn.Module):
    def __init__(self):
        super(MNISTNet, self).__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.2)
    def forward(self, x):
        x = x.view(-1, 784)
        x = self.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.relu(self.fc2(x))
        x = self.dropout(x)
        x = self.fc3(x)
        return x
model = MNISTNet()
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
print(f"使用设备：{device}")

7.3 训练模型

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
num_epochs = 10
train_losses = []
print("开始训练...")
for epoch in range(num_epochs):
    running_loss = 0.0
    for i, (images, labels) in enumerate(train_loader):
        images, labels = images.to(device), labels.to(device)
        outputs = model(images)
        loss = criterion(outputs, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    avg_loss = running_loss / len(train_loader)
    train_losses.append(avg_loss)
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {avg_loss:.4f}')
plt.figure(figsize=(8, 5))
plt.plot(range(1, num_epochs+1), train_losses, marker='o')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('训练损失曲线')
plt.grid(True)
plt.show()

7.4 评估模型

model.eval()
correct = 0
total = 0
with torch.no_grad():
    for images, labels in test_loader:
        images, labels = images.to(device), labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
accuracy = 100 * correct / total
print(f'测试集准确率：{accuracy:.2f}%')
images, labels = next(iter(test_loader))
images, labels = images.to(device), labels.to(device)
outputs = model(images)
_, predictions = torch.max(outputs, 1)
fig, axes = plt.subplots(1, 5, figsize=(12, 3))
for i in range(5):
    axes[i].imshow(images[i].cpu().squeeze(), cmap='gray')
    axes[i].set_title(f'True: {labels[i].item()}\nPred: {predictions[i].item()}')
    axes[i].axis('off')
plt.tight_layout()
plt.show()

8. 深度学习进阶概念速览

8.1 卷积神经网络（CNN）

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)
    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 64 * 7 * 7)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

8.2 常见优化技巧

  • 学习率调度：训练过程中动态调整学习率
  • 正则化（Dropout、BatchNorm）：防止过拟合
  • 数据增强：旋转、翻转、裁剪图像，扩大训练集
  • 早停（Early Stopping）：验证集损失不再下降时停止训练

9. 学习路径与资源推荐

恭喜你完成了深度学习入门教程！你已经掌握了：
✅ 神经网络的核心原理（前向传播、反向传播）
✅ PyTorch框架的基础使用
✅ 从零实现神经元和简单网络
✅ 实战MNIST手写数字识别项目

9.1 进阶学习路径

  • 深度学习数学基础：线性代数、微积分、概率论
  • 经典论文阅读：AlexNet、VGG、ResNet、Transformer
  • 计算机视觉（CV）：图像分类、目标检测、语义分割
  • 自然语言处理（NLP）：Transformer、BERT、GPT系列
  • 生成式AI（AIGC）：扩散模型、Stable Diffusion、LLM微调

9.2 推荐免费资源

  • PyTorch官方教程：pytorch.org/tutorials
  • 李沐《动手学深度学习》：课本+视频，经典必读
  • Fast.ai：实用的深度学习课程
  • Kaggle竞赛：在实际问题中锻炼模型能力

9.3 最后的建议

深度学习是一个需要大量实践的领域。刚开始时，模型不收敛、准确率上不去、过拟合等问题都会遇到，这完全正常。建议先跑通MNIST代码，然后动手修改参数观察变化。2026年，深度学习正在从“少数人的魔法”变成“每个人的工具”，祝你学习顺利！

版权声明：本文为原创教程，欢迎分享转发。如有任何问题，欢迎留言交流。