数学基础入门
课程介绍
本模块聚焦AI开发中最常用的数学概念和工具。通过实际的AI应用案例，帮助你建立直观的数学认识，为后续的深度学习和大模型开发打下坚实基础。
学习目标
完成本模块学习后，你将能够：
- 理解AI中的核心数学概念
- 使用Python实现数学运算
- 掌握数学工具在AI中的应用
- 具备基本的数学直觉
1. 线性代数基础
1.1 向量运算
# 🔢 实战案例：词向量运算
import numpy as np
# 创建词向量
king = np.array([0.0, 0.7, 0.3, 0.2])
man = np.array([0.1, 0.4, 0.8, 0.3])
woman = np.array([0.1, 0.4, 0.2, 0.8])
# 向量运算：king - man + woman ≈ queen
queen = king - man + woman
# 计算相似度
def cosine_similarity(v1, v2):
return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
print(f"相似度: {cosine_similarity(queen, np.array([0.0, 0.7, 0.2, 0.7])):.2f}")1.2 矩阵运算
# 📊 实战案例：图像转换
def rotate_image(image, angle):
"""使用矩阵旋转图像"""
# 创建旋转矩阵
theta = np.radians(angle)
rotation_matrix = np.array([
[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)]
])
# 应用旋转
return np.dot(image, rotation_matrix)2. 微积分要点
2.1 梯度下降
# 📉 实战案例：简单神经网络训练
def gradient_descent(X, y, learning_rate=0.01, epochs=100):
"""使用梯度下降优化线性模型"""
w = np.random.randn(X.shape[1])
for epoch in range(epochs):
# 前向传播
predictions = np.dot(X, w)
# 计算梯度
gradient = np.dot(X.T, (predictions - y)) / len(y)
# 更新权重
w -= learning_rate * gradient
# 计算损失
loss = np.mean((predictions - y) ** 2)
if epoch % 10 == 0:
print(f"Epoch {epoch}, Loss: {loss:.4f}")
return w2.2 链式法则
# 🔗 实战案例：反向传播
class SimpleNeuron:
def __init__(self):
self.w = np.random.randn()
self.b = np.random.randn()
def forward(self, x):
self.x = x
self.y = self.w * x + self.b
return self.y
def backward(self, grad_y):
# 使用链式法则计算梯度
grad_w = grad_y * self.x
grad_b = grad_y
grad_x = grad_y * self.w
return grad_x, grad_w, grad_b3. 概率统计基础
3.1 概率分布
# 📊 实战案例：生成对抗网络中的分布
import torch.nn as nn
class Generator(nn.Module):
def __init__(self):
super().__init__()
self.model = nn.Sequential(
# 从正态分布生成潜在向量
nn.Linear(100, 256),
nn.ReLU(),
nn.Linear(256, 784),
nn.Sigmoid()
)
def forward(self, z):
# z是从标准正态分布采样的噪声
return self.model(z)3.2 期望与方差
# 📈 实战案例：Batch Normalization
def batch_norm(x, eps=1e-5):
"""手动实现批量归一化"""
# 计算均值
mean = np.mean(x, axis=0)
# 计算方差
var = np.var(x, axis=0)
# 归一化
x_norm = (x - mean) / np.sqrt(var + eps)
return x_norm4. 信息论基础
4.1 熵与互信息
# 🔍 实战案例：特征选择
from scipy.stats import entropy
def mutual_information(X, y):
"""计算特征与标签之间的互信息"""
# 计算联合概率分布
joint_dist = np.histogram2d(X, y)[0]
# 计算边缘分布
p_x = np.sum(joint_dist, axis=1)
p_y = np.sum(joint_dist, axis=0)
# 计算互信息
mi = np.sum(joint_dist * np.log(joint_dist / np.outer(p_x, p_y)))
return mi4.2 交叉熵
# 💡 实战案例：分类模型损失函数
def cross_entropy_loss(y_true, y_pred):
"""计算交叉熵损失"""
epsilon = 1e-15
y_pred = np.clip(y_pred, epsilon, 1 - epsilon)
return -np.sum(y_true * np.log(y_pred)) / len(y_true)实战项目：图像分类器
项目描述
构建一个简单的图像分类器，综合运用本模块学习的数学概念。
项目代码框架
class SimpleClassifier:
def __init__(self, input_dim, num_classes):
self.W = np.random.randn(input_dim, num_classes) * 0.01
self.b = np.zeros(num_classes)
def forward(self, X):
# 线性变换
scores = np.dot(X, self.W) + self.b
# Softmax激活
exp_scores = np.exp(scores)
probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)
return probs
def train(self, X, y, learning_rate=1e-3, epochs=100):
for epoch in range(epochs):
# 前向传播
probs = self.forward(X)
# 计算梯度
dW = np.dot(X.T, (probs - y)) / len(y)
db = np.sum(probs - y, axis=0) / len(y)
# 更新参数
self.W -= learning_rate * dW
self.b -= learning_rate * db
# 计算损失
loss = cross_entropy_loss(y, probs)
if epoch % 10 == 0:
print(f"Epoch {epoch}, Loss: {loss:.4f}")练习与作业
- 实现PCA降维算法
- 编写Mini-batch梯度下降
- 计算不同激活函数的梯度
扩展阅读
小测验
- 为什么需要归一化处理？
- 梯度下降的原理是什么？
- 交叉熵在机器学习中的作用？
下一步学习
- 机器学习算法
- 深度学习基础
- 优化技术
常见问题解答
Q: 为什么需要学习这些数学知识？ A: 这些数学概念是理解和优化AI模型的基础，能帮助你更好地理解模型行为和调优过程。
Q: 如何提高数学直觉？ A: 多做实践练习，将数学概念与实际的AI应用结合起来，通过可视化和实验加深理解。
1. 线性代数基础
1.1 向量基础
import numpy as np
# 向量的创建与基本运算
v1 = np.array([1, 2, 3])
v2 = np.array([4, 5, 6])
# 向量加减法
v_sum = v1 + v2
v_diff = v1 - v2
# 点积
dot_product = np.dot(v1, v2)
# L1和L2范数
l1_norm = np.sum(np.abs(v1)) # L1范数
l2_norm = np.sqrt(np.sum(v1**2)) # L2范数
# 向量的应用示例：文本向量化
from sklearn.feature_extraction.text import TfidfVectorizer
texts = [
"机器学习很有趣",
"深度学习是机器学习的子集",
"神经网络是深度学习的基础"
]
vectorizer = TfidfVectorizer()
text_vectors = vectorizer.fit_transform(texts)1.2 矩阵运算
# 矩阵的创建与基本运算
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
# 矩阵加减法
C = A + B
D = A - B
# 矩阵乘法
E = np.dot(A, B) # 或 A @ B
# 矩阵转置
A_T = A.T
# 特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(A)
# 矩阵分解
U, S, V = np.linalg.svd(A) # SVD分解2. 微积分基础
2.1 导数与梯度
# 使用numpy实现数值导数
def numerical_derivative(f, x, h=1e-7):
return (f(x + h) - f(x)) / h
# 简单的梯度下降示例
def gradient_descent(f, df, x0, learning_rate=0.01, n_iterations=100):
x = x0
history = [x]
for _ in range(n_iterations):
gradient = df(x)
x = x - learning_rate * gradient
history.append(x)
return x, history
# 示例：最小化函数 f(x) = x^2
def f(x): return x**2
def df(x): return 2*x
minimum, path = gradient_descent(f, df, x0=2.0)2.2 偏导数与链式法则
# 神经网络中的反向传播示例
class SimpleNeuron:
def __init__(self):
self.w = np.random.randn()
self.b = np.random.randn()
def forward(self, x):
return x * self.w + self.b
def backward(self, x, grad_output):
# 链式法则
grad_w = x * grad_output
grad_b = grad_output
grad_x = self.w * grad_output
return grad_w, grad_b, grad_x3. 概率统计基础
3.1 概率分布
import scipy.stats as stats
# 正态分布
mu, sigma = 0, 1
x = np.linspace(-3, 3, 100)
pdf = stats.norm.pdf(x, mu, sigma)
# 二项分布
n, p = 10, 0.5
k = np.arange(0, n+1)
pmf = stats.binom.pmf(k, n, p)
# 泊松分布
lambda_ = 2
k = np.arange(0, 10)
pmf_poisson = stats.poisson.pmf(k, lambda_)3.2 统计推断
# 假设检验示例
from scipy import stats
# 生成两组数据
group1 = np.random.normal(0, 1, 1000)
group2 = np.random.normal(0.5, 1, 1000)
# t检验
t_stat, p_value = stats.ttest_ind(group1, group2)
# 置信区间
confidence_interval = stats.t.interval(0.95, len(group1)-1,
loc=np.mean(group1),
scale=stats.sem(group1))4. 信息论基础
4.1 熵与互信息
from scipy.stats import entropy
# 计算熵
def calculate_entropy(p):
return entropy(p)
# 示例：计算二进制序列的熵
p = np.array([0.3, 0.7]) # 概率分布
H = calculate_entropy(p)
# 计算KL散度
def kl_divergence(p, q):
return np.sum(p * np.log(p/q))
# 计算互信息
def mutual_information(joint_prob, marginal_x, marginal_y):
return kl_divergence(joint_prob,
np.outer(marginal_x, marginal_y))4.2 交叉熵与损失函数
def cross_entropy(y_true, y_pred):
"""计算交叉熵损失"""
return -np.sum(y_true * np.log(y_pred + 1e-15))
# 简单分类器示例
class SimpleClassifier:
def __init__(self, input_dim, num_classes):
self.W = np.random.randn(input_dim, num_classes) * 0.01
self.b = np.zeros(num_classes)
def forward(self, X):
scores = np.dot(X, self.W) + self.b
exp_scores = np.exp(scores)
probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)
return probs
def loss(self, X, y):
probs = self.forward(X)
N = X.shape[0]
loss = -np.sum(np.log(probs[np.arange(N), y])) / N
return loss常见问题解答
Q: 为什么需要学习这些数学基础？ A: 这些数学概念是理解和实现AI算法的基础。例如，线性代数用于数据表示和运算，微积分用于优化算法，概率统计用于模型评估和预测。
Q: 如何提高数学直觉？ A: 多动手实践，将数学概念与实际的AI应用结合起来。通过可视化和编程实现来加深理解。
Q: 需要掌握到什么程度？ A: 重点是理解核心概念和它们在AI中的应用。不需要掌握所有数学证明，但要能够运用这些工具解决实际问题。