深度学习入门

从梯度下降到神经网络学习

本次学习通过对《深度学习入门：基于Python的理论与实践》该书前四章进行理论研究，及在ai大模型协助下进行可训练神经网络框架的书写，深刻理解深度学习。以下是相关的学习成果：
1.理论问题回答

一、学习与模型(第 1 章)

Q1. 神经网络训练过程中，哪些量是已知的，哪些量是未知的?
已知量：
1.训练数据和测试数据（或监督数据和测试数据）；
2.网络结构：神经元的层数、各层神经元数量；人为设定的结构参数。
未知量：
权重参数W和偏置参数b。
学习的目标到底是什么?
通过调整未知的权重参数和偏置参数，最小化损失函数的值，让模型具备对测试数据的泛化识别能力，实现模型对未知数据的稳定预测。
二、线性模型与非线性(第 2 章)

Q2. 为什么单层感知机只能解决线性可分问题?
因为单层感知机只能表示由直线分割的线性空间，对于异或门这类非线性可分问题无法用一条直线划分两类样本。
**Q3. 为什么必须引入非线性激活函数? **
因为线性激活函数有局限性，只能等价于单层线性模型，无法学习复杂的非线性关系。为了发挥叠加层所带来的优势，激活函数必须使用非线性函数。
如果把神经网络中所有激活函数都去掉，会发生什么?
无法学习非线性模式，仅能处理线性可分问题。
三、神经网络的前向计算(第 3 章)

Q4. 神经网络的前向传播，本质上在做什么数学运算?
本质上是矩阵乘法和激活函数运算的交替执行。
先通过矩阵乘法计算输入信号与权重的加权和，并叠加偏置，再通过激活函数对结果进行非线性转换，逐层传递至输出层。
Q5. 为什么分类问题中，输出层通常使用 Softmax? Softmax 在概率意义上做了什么?
核心原因：将神经网络输出的“得分”（未归一化值）转换为概率分布，使输出值总和为1，便于直观解读类别概率，且能与交叉熵误差配合，使反向传播时梯度计算更简洁（直接得到输出与标签的差分）。
在概率上，它对于每个类别i，都计算其相对概率，既保留了各得分的相对大小关系，又将输出归一化到[0,1]区间，满足概率的基本性质（非负性、总和为1）。
四、损失函数与梯度(第 4 章 · 核心)

**Q6. 为什么“准确率”不能作为训练时的优化目标? **
因为准确率是离散指标，多数情况下梯度为0，无法引导参数更新。例如，微小调整权重可能不会改变分类结果，导致准确率不变，参数更新停滞；且准确率的变化不连续，无法反映参数变化对模型性能的连续影响。
为什么必须引入损失函数?
因为它是连续可微的函数，能量化模型预测与真实标签的差异，其梯度可指导参数沿“减小误差”的方向更新；同时，损失函数的连续变化能反映参数调整的效果，确保学习过程持续推进。
五、梯度下降的本质(第 4 章 · 灵魂)

Q7. 梯度在几何意义上代表什么?
在几何意义上，梯度是损失函数在当前参数点处的方向导数最大值方向，即函数值增长最快的方向，其模长表示增长的速率。
为什么沿着负梯度方向更新参数?
因为神经网络学习的目标是最小化损失函数，负梯度方向是损失函数值减小最快的方向，沿该方向更新参数能高效逼近损失函数的最小值（或局部最小值）。
**Q8. 学习率在梯度下降中起什么作用? **
作用：控制参数更新的步长，决定每次迭代中参数沿负梯度方向调整的幅度，是平衡学习速度与收敛效果的关键超参数。
学习率过大会怎样?过小又会怎样?
学习率过大：参数更新步长过大，可能导致损失函数值震荡不收敛，甚至发散（如参数值超出最优范围，损失函数值持续增大）。
学习率过小：参数更新步长过小，学习速度极慢，需要大量迭代才能逼近最优解；且可能陷入局部最小值或鞍点，无法抵达全局最优。
2. 完整可运行代码

1.激活函数 & 损失函数：

使用 numpy 实现：Sigmoid，ReLU，Softmax
实现：交叉熵损失（支持 batch 输入）

1. import numpy as np
3. def sigmoid(x):
4. """
5. Sigmoid 激活函数：
6. 公式: h(x) = 1 / (1 + exp(-x))
7. 参数:
8. x: 输入数据
9. 返回:
10. Sigmoid 输出
11. """
12. return 1 / (1 + np.exp(-x))
14. def relu(x):
15. """
16. ReLU 激活函数：
17. 公式: h(x) = max(0, x)
18. 参数:
19. x: 输入数据 (numpy array)
20. 返回:
21. ReLU 输出
22. """
23. return np.maximum(0, x)
25. def softmax(x):
26. """
27. Softmax 激活函数：
28. 公式: y_k = exp(a_k) / sum(exp(a_i))
29. 参数:
30. x: 输入数据 (numpy array)
31.    如果是 1D 数组，视为单个样本。
32.    如果是 2D 数组，视为 batch 样本。
33. 返回:
34. Softmax 输出
35. """
36. if x.ndim == 2:
37.     # Batch 处理
38.     x = x.T
39.     x = x - np.max(x, axis=0) # 稳定性优化（减去最大值，防止 exp 溢出）
40.     y = np.exp(x) / np.sum(np.exp(x), axis=0)
41.     return y.T
43. # 单个样本处理
44. x = x - np.max(x)
45. return np.exp(x) / np.sum(np.exp(x))
47. def cross_entropy_error(y, t):
48. """
49. 交叉熵损失函数：
50. 公式: E = -sum(t_k * log(y_k))
52. 参数:
53. y: 神经网络的输出 (概率分布)，经过 Softmax
54. t: 监督数据 (标签)
55.    可以是 one-hot 向量 (例如 [0, 1, 0, 0, ...])
56.    也可以是标签索引 (例如 1)
57. 返回:
58. 损失值 (标量)
59. """
60. if y.ndim == 1:
61.     t = t.reshape(1, t.size)
62.     y = y.reshape(1, y.size)
63.    
64. # 如果 t 是 one-hot 向量，转换为标签索引
65. if t.size == y.size:
66.     t = t.argmax(axis=1)
67.    
68. batch_size = y.shape[0]
70. # 添加一个微小值 delta 防止 log(0)
71. delta = 1e-7
72. return -np.sum(np.log(y[np.arange(batch_size), t] + delta)) / batch_size

复制代码

2.数值梯度

1. import numpy as np
3. def numerical_gradient(f, x):
4. """
5. 数值梯度计算函数
6. 使用中心差分法近似计算梯度: (f(x+h) - f(x-h)) / 2h
7. 参数:
8. f: 目标函数
9. x: 输入变量 (numpy array)
10. 返回:
11. 梯度 (与 x 形状相同)
12. """
13. h = 1e-4 #设置一个很小的数
14. grad = np.zeros_like(x) # 生成和 x 形状相同的数组，用于存放梯度
15. #遍历x的每一个元素
16. it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
18. while not it.finished:
19.     idx = it.multi_index
20.     tmp_val = x[idx]
21.    
22.     # 计算 f(x+h)
23.     x[idx] = float(tmp_val) + h
24.     fxh1 = f(x)
25.    
26.     # 计算 f(x-h)
27.     x[idx] = float(tmp_val) - h
28.     fxh2 = f(x)
29.    
30.     # 计算梯度
31.     grad[idx] = (fxh1 - fxh2) / (2*h)
32.    
33.     # 还原值
34.     x[idx] = tmp_val
35.     it.iternext()
36.    
37. return grad

复制代码

3.搭建网络

层与反向传播

1. import numpy as np
2. from src.functions import softmax,
3. cross_entropy_error
5. class Relu:
6. """
7. ReLU 层
8. 前向传播: out = x (x > 0), 0 (x <= 0)
9. 反向传播: dx = dout (x > 0), 0 (x <= 0)
10. """
11. def __init__(self):
12.     self.mask = None # 用于记录 x 中小于等于 0 的位置
14. def forward(self, x):
15.     """
16.     前向传播
17.     """
18.     self.mask = (x <= 0)
19.     out = x.copy()
20.     out[self.mask] = 0
21.     return out
23. def backward(self, dout):
24.     """
25.     反向传播
26.     dout: 上一层传下来的梯度
27.     """
28.     dout[self.mask] = 0
29.     dx = dout
30.     return dx
32. class Affine:
33. """
34. Affine 层 (全连接层)
35. 前向传播: out = np.dot(x, W) + b
36. """
37. def __init__(self, W, b):
38.     self.W = W # 权重
39.     self.b = b # 偏置
40.     self.x = None # 保存输入，用于反向传播
41.     self.dW = None # 权重的梯度
42.     self.db = None # 偏置的梯度
44. def forward(self, x):
45.     # 如果输入是张量 (N, C, H, W)，需要展平为 (N, D)
46.     self.original_x_shape = x.shape
47.     x = x.reshape(x.shape[0], -1)
48.     self.x = x
49.    
50.     out = np.dot(self.x, self.W) + self.b
51.     return out
53. def backward(self, dout):
54.     dx = np.dot(dout, self.W.T)
55.     self.dW = np.dot(self.x.T, dout)
56.     self.db = np.sum(dout, axis=0)
57.    
58.     dx = dx.reshape(*self.original_x_shape) # 还原输入形状
59.     return dx
61. class SoftmaxWithLoss:
62. """
63. SoftmaxWithLoss 层
64. 结合了 Softmax 激活函数和 Cross Entropy Loss
65. """
66. def __init__(self):
67.     self.loss = None
68.     self.y = None # Softmax 的输出
69.     self.t = None # 监督数据 (One-hot 或 标签索引)
71. def forward(self, x, t):
72.     self.t = t
73.     self.y = softmax(x)
74.     self.loss = cross_entropy_error(self.y, self.t)
75.     return self.loss
77. def backward(self, dout=1):
78.     batch_size = self.t.shape[0]
79.    
80.     # 处理 one-hot 编码和标签索引两种情况
81.     if self.t.size == self.y.size: # one-hot
82.         dx = (self.y - self.t) / batch_size
83.     else:
84.         dx = self.y.copy()
85.         dx[np.arange(batch_size), self.t] -= 1
86.         dx = dx / batch_size
87.         
88.     return dx

复制代码

4.数据加载及主训练循环

数据加载

1. import numpy as np
2. from collections import OrderedDict
3. from src.layers import *
4. from src.gradient import numerical_gradient
6. class TwoLayerNet:
7. """
8. 两层神经网络
9. 结构: Input -> Affine -> ReLU -> Affine -> SoftmaxWithLoss
10. """
12. def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):
13.     """
14.     初始化网络权重
15.     参数:
16.     input_size: 输入层神经元数量
17.     hidden_size: 隐藏层神经元数量
18.     output_size: 输出层神经元数量
19.     weight_init_std: 权重初始化标准差
20.     """
21.     # 初始化权重
22.     self.params = {}
23.     self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
24.     self.params['b1'] = np.zeros(hidden_size)
25.     self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size)
26.     self.params['b2'] = np.zeros(output_size)
28.     # 生成层
29.     self.layers = OrderedDict()
30.     self.layers['Affine1'] = Affine(self.params['W1'], self.params['b1'])
31.     self.layers['Relu1'] = Relu()
32.     self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2'])
34.     self.lastLayer = SoftmaxWithLoss()
35.    
36. def predict(self, x):
37.     """
38.     前向传播 (预测)
39.     """
40.     for layer in self.layers.values():
41.         x = layer.forward(x)
42.     return x
43.    
44. def loss(self, x, t):
45.     """
46.     计算损失函数值
47.    
48.     参数:
49.     x: 输入数据
50.     t: 监督数据 (标签)
51.     """
52.     y = self.predict(x)
53.     return self.lastLayer.forward(y, t)
55. def accuracy(self, x, t):
56.     """
57.     计算精度
58.     """
59.     y = self.predict(x)
60.     y = np.argmax(y, axis=1)
61.     if t.ndim != 1 : t = np.argmax(t, axis=1)
62.    
63.     accuracy = np.sum(y == t) / float(x.shape[0])
64.     return accuracy
65.    
66. def numerical_gradient(self, x, t):
67.     """
68.     使用数值微分计算梯度 (速度较慢，用于验证)
69.     """
70.     loss_W = lambda W: self.loss(x, t)
71.    
72.     grads = {}
73.     grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
74.     grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
75.     grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
76.     grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
77.    
78.     return grads
79.    
80. def gradient(self, x, t):
81.     """
82.     使用误差反向传播法计算梯度 (速度快)
83.     """
84.     # 1. 前向传播
85.     self.loss(x, t)
87.     # 2. 反向传播
88.     dout = 1
89.     dout = self.lastLayer.backward(dout)
90.    
91.     layers = list(self.layers.values())
92.     layers.reverse()
93.     for layer in layers:
94.         dout = layer.backward(dout)
96.     # 3. 收集梯度
97.     grads = {}
98.     grads['W1'] = self.layers['Affine1'].dW
99.     grads['b1'] = self.layers['Affine1'].db
100.     grads['W2'] = self.layers['Affine2'].dW
101.     grads['b2'] = self.layers['Affine2'].db
103.     return grads

复制代码

}

1. import os
2. import gzip
3. import numpy as np
4. import urllib.request
6. # MNIST 数据集下载链接
7. url_base = 'https://ossci-        datasets.s3.amazonaws.com/mnist/'
8. key_file = {
9. 'train_img': 'train-images-idx3-ubyte.gz',
10. 'train_label': 'train-labels-idx1-ubyte.gz',
11. 'test_img': 't10k-images-idx3-ubyte.gz',
12. 'test_label': 't10k-labels-idx1-ubyte.gz'

复制代码

主训练循环

1. dataset_dir = os.path.dirname(os.path.abspath(__file__))
2. save_file = dataset_dir + "/mnist.pkl"
4. train_num = 60000
5. test_num = 10000
6. img_dim = (1, 28, 28)
7. img_size = 784
9. def _download(file_name):
10. file_path = dataset_dir + "/" + file_name
12. if os.path.exists(file_path):
13.     return
15. print("Downloading " + file_name + " ... ")
16. # 使用 header 模拟浏览器，防止某些服务器拒绝
17. headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
18. req = urllib.request.Request(url_base + file_name, headers=headers)
20. try:
21.     with urllib.request.urlopen(req) as response, open(file_path, 'wb') as out_file:
22.         data = response.read()
23.         out_file.write(data)
24.     print("Done")
25. except Exception as e:
26.     print(f"Failed to download {file_name}: {e}")
27.     # 如果下载失败，尝试备用镜像或提示用户
28.     print("Please try to download manually and place in: ", dataset_dir)
30. def download_mnist():
31. for v in key_file.values():
32.     _download(v)
34. def _load_label(file_name):
35. file_path = dataset_dir + "/" + file_name
37. print("Converting " + file_name + " to NumPy Array ...")
38. with gzip.open(file_path, 'rb') as f:
39.     labels = np.frombuffer(f.read(), np.uint8, offset=8)
40. print("Done")
42. return labels
44. def _load_img(file_name):
45. file_path = dataset_dir + "/" + file_name
47. print("Converting " + file_name + " to NumPy Array ...")
48. with gzip.open(file_path, 'rb') as f:
49.     data = np.frombuffer(f.read(), np.uint8, offset=16)
50. data = data.reshape(-1, img_size)
51. print("Done")
53. return data
55. def _convert_numpy():
56. dataset = {}
57. dataset['train_img'] =  _load_img(key_file['train_img'])
58. dataset['train_label'] = _load_label(key_file['train_label'])   
59. dataset['test_img'] = _load_img(key_file['test_img'])
60. dataset['test_label'] = _load_label(key_file['test_label'])
62. return dataset
64. def init_mnist():
65. download_mnist()
66. dataset = _convert_numpy()
67. print("Creating pickle file ...")
68. import pickle
69. with open(save_file, 'wb') as f:
70.     pickle.dump(dataset, f, -1)
71. print("Done!")
73. def load_mnist(normalize=True, flatten=True, one_hot_label=False):
74. """
75. 读入 MNIST 数据集
76. Parameters
77. normalize : 将图像的像素值正规化为 0.0~1.0
78. one_hot_label :
79.     False -> 7, 2, ...
80.     True -> [0,0,0,0,0,0,0,1,0,0], [0,0,1,0,0,0,0,0,0,0], ...
81. flatten : 是否将图像展开为一维数组
83. Returns
84. (训练图像, 训练标签), (测试图像, 测试标签)
85. """
86. if not os.path.exists(save_file):
87.     init_mnist()
88.    
89. import pickle
90. with open(save_file, 'rb') as f:
91.     dataset = pickle.load(f)
93. if normalize:
94.     for key in ('train_img', 'test_img'):
95.         dataset[key] = dataset[key].astype(np.float32)
96.         dataset[key] /= 255.0
97.         
98. if one_hot_label:
99.     dataset['train_label'] = _change_one_hot_label(dataset['train_label'])
100.     dataset['test_label'] = _change_one_hot_label(dataset['test_label'])
102. if not flatten:
103.     for key in ('train_img', 'test_img'):
104.         dataset[key] = dataset[key].reshape(-1, 1, 28, 28)
106. return (dataset['train_img'], dataset['train_label']), (dataset['test_img'], dataset['test_label'])
108. def _change_one_hot_label(X):
109. T = np.zeros((X.size, 10))
110. for idx, row in enumerate(T):
111.     row[X[idx]] = 1
112.    
113. return T

复制代码

注：关于MNIST数据集在代码中使用：

1. import numpy as np
2. import matplotlib.pyplot as plt
3. from src.dataset import load_mnist
4. from src.network import TwoLayerNet
5. # 1. 读入数据
6. print("正在加载 MNIST 数据集...")
7. (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)
8. print(f"训练数据形状: {x_train.shape}")
9. print(f"测试数据形状: {x_test.shape}")
11. # 2. 超参数设置
12. iters_num = 10000  # 适当设定循环的次数
13. train_size = x_train.shape[0]
14. batch_size = 100
15. learning_rate = 0.1
17. train_loss_list = []
18. train_acc_list = []
19. test_acc_list = []
21. # 平均每个 epoch 的重复次数
22. iter_per_epoch = max(train_size / batch_size, 1)
24. # 3. 初始化网络
25. # 输入层 784 (28x28), 隐藏层 50, 输出层 10 (0-9)
26. network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)
28. print("开始训练...")
30. for i in range(iters_num):
31.     # 获取 mini-batch
32.     batch_mask = np.random.choice(train_size, batch_size)
33.     x_batch = x_train[batch_mask]
34.     t_batch = t_train[batch_mask]
35.    
36. # 计算梯度
37. # 推荐: 使用反向传播 (Task 4 实现)
38. grad = network.gradient(x_batch, t_batch)
40. # 也可以使用数值梯度 (Task 3 实现)，但速度非常慢，不建议在实际训练中使用
41. # grad = network.numerical_gradient(x_batch, t_batch)
43. # 更新参数 (SGD - Task 5)
44. for key in ('W1', 'b1', 'W2', 'b2'):
45.     network.params[key] -= learning_rate * grad[key]
47. # 记录学习过程
48. loss = network.loss(x_batch, t_batch)
49. train_loss_list.append(loss)
51. # 计算每个 epoch 的识别精度
52. if i % iter_per_epoch == 0:
53.     train_acc = network.accuracy(x_train, t_train)
54.     test_acc = network.accuracy(x_test, t_test)
55.     train_acc_list.append(train_acc)
56.     test_acc_list.append(test_acc)
57.     print(f"epoch: {int(i/iter_per_epoch)}, loss: {loss:.4f}, train acc: {train_acc:.4f}, test acc: {test_acc:.4f}")
59. print("训练结束!")
61. # 4. 绘图 (Task 6)
62. # 绘制损失函数变化
63. plt.figure(figsize=(12, 5))
64. plt.subplot(1, 2, 1)
65. plt.plot(train_loss_list)
66. plt.title("Loss Function History")
67. plt.xlabel("Iterations")
68. plt.ylabel("Loss")
70. # 绘制精度变化
71. plt.subplot(1, 2, 2)
72. markers = {'train': 'o', 'test': 's'}
73. x = np.arange(len(train_acc_list))
74. plt.plot(x, train_acc_list, label='train acc')
75. plt.plot(x, test_acc_list, label='test acc', linestyle='--')
76. plt.xlabel("Epochs")
77. plt.ylabel("Accuracy")
78. plt.ylim(0, 1.0)
79. plt.legend(loc='lower right')
80. plt.title("Accuracy History")
82. plt.tight_layout()
83. plt.savefig("training_result.png")
84. print("结果已保存至 training_result.png")
85. # plt.show()

复制代码

运行：1.安装依赖

1. from src.dataset import load_mnist
2.     # 第一次运行时会自动下载并生成 mnist.pkl 缓存文件
3.     (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=True)
5. print(x_train.shape) # (60000, 784)
6. print(t_train.shape) # (60000, 10)

复制代码

2.运行训练

1. pip install -r requirements.txt

复制代码

3. 简单实验记录（loss 曲线或日志）

以上是该次学习的基本内容。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

新版吗？好像是停更了吧。