当前位置：

社区首页

图书音像

图书杂志

科学技术

文章详情

深度学习数学基础

线性代数

1. 标量、向量、矩阵、张量

标量（Scalar）

一个单独的数字，如 5, 3.14

向量（Vector）

一维数组，表示空间中的点或方向

import numpy as np # 列向量 v = np.array([1, 2, 3]) print(v.shape) # (3,) # 在深度学习中，向量代表： # - 单个样本的特征 # - 神经网络某一层的激活值

几何意义：向量是空间中的箭头，有方向和长度

矩阵（Matrix）

二维数组

# 2x3 矩阵 A = np.array([[1, 2, 3], [4, 5, 6]]) print(A.shape) # (2, 3) # 在深度学习中，矩阵代表： # - 一批样本的特征（每行是一个样本） # - 神经网络的权重

张量（Tensor）

多维数组（≥3维）

# 3D张量：批次大小 x 高度 x 宽度 images = np.random.rand(32, 28, 28) # 32张28x28的图片 print(images.shape) # (32, 28, 28) # 4D张量：批次 x 通道 x 高度 x 宽度 rgb_images = np.random.rand(32, 3, 224, 224) print(rgb_images.shape) # (32, 3, 224, 224)

2. 向量与矩阵运算

向量加法和数乘

a = np.array([1, 2, 3]) b = np.array([4, 5, 6]) # 向量加法 c = a + b # [5, 7, 9] # 数乘 d = 2 * a # [2, 4, 6]

点积（内积）

# 点积：a·b = a₁b₁ + a₂b₂ + a₃b₃ dot_product = np.dot(a, b) # 1*4 + 2*5 + 3*6 = 32 # 几何意义：测量两个向量的相似度 # 点积越大，越相似（角度越小）

深度学习应用：计算神经元的加权和

# 神经元计算 weights = np.array([0.5, -0.3, 0.8]) # 权重 inputs = np.array([1.0, 2.0, 3.0]) # 输入 bias = 0.5 output = np.dot(weights, inputs) + bias # = 0.5*1 + (-0.3)*2 + 0.8*3 + 0.5 = 2.8

矩阵乘法

# A(m×n) × B(n×p) = C(m×p) A = np.array([[1, 2], [3, 4]]) # 2x2 B = np.array([[5, 6], [7, 8]]) # 2x2 C = np.dot(A, B) # [[1*5+2*7, 1*6+2*8], [[19, 22], # [3*5+4*7, 3*6+4*8]] = [43, 50]]

深度学习应用：批量计算多个样本

# X: 批次大小 x 特征数 (100 x 784) # W: 特征数 x 神经元数 (784 x 128) # Y: 批次大小 x 神经元数 (100 x 128) X = np.random.rand(100, 784) # 100个样本 W = np.random.rand(784, 128) # 权重矩阵 Y = np.dot(X, W) # 一次计算所有样本 print(Y.shape) # (100, 128)

3. 矩阵转置

A = np.array([[1, 2, 3], [4, 5, 6]]) A_T = A.T # [[1, 4], # [2, 5], # [3, 6]] # 性质：(AB)ᵀ = BᵀAᵀ

4. 单位矩阵和逆矩阵

单位矩阵

I = np.eye(3) # 3x3单位矩阵 # [[1, 0, 0], # [0, 1, 0], # [0, 0, 1]] # 性质：AI = IA = A

逆矩阵

A = np.array([[4, 7], [2, 6]]) A_inv = np.linalg.inv(A) print(np.dot(A, A_inv)) # 约等于单位矩阵 # 性质：AA⁻¹ = A⁻¹A = I

5. 范数（Norm）

L2范数（欧几里得距离）

v = np.array([3, 4]) l2_norm = np.linalg.norm(v) # √(3² + 4²) = 5 # 深度学习应用：L2正则化 # Loss = 原始损失 + λ * ||W||₂²

L1范数

l1_norm = np.sum(np.abs(v)) # |3| + |4| = 7 # 深度学习应用：L1正则化（产生稀疏权重）

6. 特征值和特征向量

A = np.array([[2, 1], [1, 2]]) eigenvalues, eigenvectors = np.linalg.eig(A) print(eigenvalues) # [3., 1.] print(eigenvectors) # [[ 0.707, 0.707], # [ 0.707, -0.707]] # 含义：Av = λv # v是特征向量，λ是特征值

应用：主成分分析（PCA）降维

微积分

1. 导数基础

定义

导数衡量函数在某点的变化率

f'(x) = lim[h→0] (f(x+h) - f(x)) / h

几何意义

函数曲线在某点的切线斜率

常用导数

# f(x) = xⁿ → f'(x) = nxⁿ⁻¹ # f(x) = eˣ → f'(x) = eˣ # f(x) = ln(x) → f'(x) = 1/x # f(x) = sin(x) → f'(x) = cos(x)

Python数值计算导数

def f(x): return x**2 def numerical_derivative(f, x, h=1e-5): return (f(x + h) - f(x)) / h # f(x) = x², f'(x) = 2x print(numerical_derivative(f, 3)) # ≈ 6.0 (理论值 = 2*3 = 6)

2. 链式法则（Chain Rule）

这是反向传播的核心！

如果 y = f(u) 且 u = g(x)，则：

dy/dx = dy/du × du/dx

示例

# y = (3x + 2)² # 令 u = 3x + 2, y = u² # dy/dx = dy/du × du/dx = 2u × 3 = 6(3x + 2) x = 1 u = 3*x + 2 # u = 5 dy_du = 2*u # 10 du_dx = 3 dy_dx = dy_du * du_dx # 30

深度学习应用

# 简单神经网络：x → z=wx+b → a=σ(z) → L(a) # 求 dL/dw # 使用链式法则： # dL/dw = dL/da × da/dz × dz/dw def sigmoid(z): return 1 / (1 + np.exp(-z)) def sigmoid_derivative(z): s = sigmoid(z) return s * (1 - s) # 前向传播 x = 2.0 w = 0.5 b = 1.0 z = w * x + b # 2.0 a = sigmoid(z) # 0.88 # 假设真实标签 y=1，损失 L = (a - y)² y = 1.0 L = (a - y) ** 2 # 反向传播 dL_da = 2 * (a - y) # -0.24 da_dz = sigmoid_derivative(z) # 0.105 dz_dw = x # 2.0 dL_dw = dL_da * da_dz * dz_dw # -0.050

3. 偏导数（Partial Derivative）

多元函数对某一个变量求导，其他变量视为常数

# f(x, y) = x²y + y³ # ∂f/∂x = 2xy (把y当常数) # ∂f/∂y = x² + 3y² (把x当常数) def f(x, y): return x**2 * y + y**3 # 数值计算偏导数 def partial_x(f, x, y, h=1e-5): return (f(x+h, y) - f(x, y)) / h def partial_y(f, x, y, h=1e-5): return (f(x, y+h) - f(x, y)) / h x, y = 2, 3 print(partial_x(f, x, y)) # ≈ 12 (2*2*3) print(partial_y(f, x, y)) # ≈ 31 (4 + 27)

4. 梯度（Gradient）

梯度是所有偏导数组成的向量

# f(x, y, z) = x² + 2y² + z³ # ∇f = [∂f/∂x, ∂f/∂y, ∂f/∂z] = [2x, 4y, 3z²] def f(params): x, y, z = params return x**2 + 2*y**2 + z**3 def gradient(f, params, h=1e-5): grad = np.zeros_like(params) for i in range(len(params)): params_plus = params.copy() params_plus[i] += h grad[i] = (f(params_plus) - f(params)) / h return grad params = np.array([1.0, 2.0, 3.0]) print(gradient(f, params)) # ≈ [2, 8, 27]

几何意义：梯度指向函数增长最快的方向

深度学习应用：梯度下降

# 最小化函数 f(x) = x² def f(x): return x**2 def gradient_descent(f, x_init, learning_rate=0.1, iterations=20): x = x_init for i in range(iterations): grad = numerical_derivative(f, x) x = x - learning_rate * grad # 沿着梯度反方向移动 print(f"迭代 {i+1}: x={x:.4f}, f(x)={f(x):.4f}") return x # 从 x=10 开始寻找最小值 result = gradient_descent(f, x_init=10.0) # 会逐渐接近 x=0（最小值点）

5. 雅可比矩阵和Hessian矩阵

雅可比矩阵（向量值函数的导数）

# f: R² → R² # f(x,y) = [x²y, xy²] # 雅可比矩阵 J = [[∂f₁/∂x, ∂f₁/∂y], # [∂f₂/∂x, ∂f₂/∂y]] # = [[2xy, x²], # [y², 2xy]]

Hessian矩阵（二阶导数矩阵）

# 用于优化算法（如牛顿法） # H = [[∂²f/∂x², ∂²f/∂x∂y], # [∂²f/∂y∂x, ∂²f/∂y²]]

概率统计

1. 概率基础

基本概念

# 抛硬币实验 np.random.seed(42) n_trials = 10000 outcomes = np.random.choice(['正', '反'], size=n_trials) prob_heads = np.sum(outcomes == '正') / n_trials print(f"P(正) ≈ {prob_heads:.3f}") # ≈ 0.5

条件概率

P(A|B) = P(A ∩ B) / P(B)

贝叶斯定理

P(A|B) = P(B|A) × P(A) / P(B)

深度学习应用：贝叶斯推断、朴素贝叶斯分类器

2. 随机变量与概率分布

离散分布：伯努利分布

# 单次抛硬币 p = 0.7 # 正面概率 result = np.random.binomial(n=1, p=p) # 0或1

连续分布：正态分布（高斯分布）

# N(μ, σ²) mu, sigma = 0, 1 samples = np.random.normal(mu, sigma, 10000) import matplotlib.pyplot as plt plt.hist(samples, bins=50, density=True) plt.title('标准正态分布') plt.show()

概率密度函数（PDF）：

def gaussian_pdf(x, mu, sigma): return (1 / (sigma * np.sqrt(2*np.pi))) * np.exp(-0.5 * ((x - mu) / sigma)**2) x = np.linspace(-4, 4, 1000) y = gaussian_pdf(x, mu=0, sigma=1) plt.plot(x, y)

3. 期望与方差

期望（均值）

# E[X] = Σ x·P(x) (离散) # E[X] = ∫ x·f(x)dx (连续) data = np.random.normal(5, 2, 1000) mean = np.mean(data) print(f"均值: {mean:.2f}") # ≈ 5

方差

# Var(X) = E[(X - E[X])²] variance = np.var(data) std_dev = np.std(data) print(f"方差: {variance:.2f}, 标准差: {std_dev:.2f}")

4. 协方差与相关系数

# 两个变量的线性关系 x = np.random.rand(100) y = 2*x + np.random.randn(100)*0.1 # y与x正相关 # 协方差 cov = np.cov(x, y)[0, 1] print(f"协方差: {cov:.3f}") # 相关系数（-1到1） corr = np.corrcoef(x, y)[0, 1] print(f"相关系数: {corr:.3f}") # 接近1，强正相关

5. 最大似然估计（MLE）

找到使观测数据出现概率最大的参数

# 示例：估计正态分布的参数 data = np.array([1.2, 2.3, 1.8, 2.1, 1.9]) # MLE估计 mu_mle = np.mean(data) # 1.86 sigma_mle = np.std(data, ddof=0) # 0.38 print(f"MLE: μ={mu_mle:.2f}, σ={sigma_mle:.2f}")

深度学习应用：训练神经网络就是最大化似然函数（最小化负对数似然）

6. 信息论基础

熵（Entropy）

衡量不确定性

def entropy(probs): # H(X) = -Σ P(x)log₂P(x) return -np.sum(probs * np.log2(probs + 1e-10)) # 均匀分布：熵最大（不确定性最大） p_uniform = np.array([0.25, 0.25, 0.25, 0.25]) print(f"均匀分布熵: {entropy(p_uniform):.2f}") # 2.0 # 确定性分布：熵最小 p_certain = np.array([1.0, 0.0, 0.0, 0.0]) print(f"确定分布熵: {entropy(p_certain):.2f}") # 0.0

交叉熵（Cross-Entropy）

def cross_entropy(p, q): # H(p, q) = -Σ p(x)log(q(x)) return -np.sum(p * np.log(q + 1e-10)) # 真实分布 p_true = np.array([0.1, 0.2, 0.7]) # 预测分布 p_pred = np.array([0.2, 0.3, 0.5]) ce = cross_entropy(p_true, p_pred) print(f"交叉熵: {ce:.3f}")

深度学习应用：分类问题的损失函数

# 二分类交叉熵 def binary_cross_entropy(y_true, y_pred): return -np.mean(y_true * np.log(y_pred + 1e-10) + (1 - y_true) * np.log(1 - y_pred + 1e-10)) y_true = np.array([1, 0, 1, 1]) y_pred = np.array([0.9, 0.1, 0.8, 0.7]) loss = binary_cross_entropy(y_true, y_pred) print(f"BCE Loss: {loss:.3f}")