人工智能数学基础：线性代数、微积分与概率统计

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import numpy as np
from sklearn.decomposition import PCA

# 示例数据
X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])

# 手动实现PCA
# 1. 数据中心化
X_centered = X - np.mean(X, axis=0)

# 2. 计算协方差矩阵
cov_matrix = np.cov(X_centered.T)

# 3. 特征值分解
eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)

# 4. 选择主成分
principal_components = eigenvectors[:, np.argmax(eigenvalues)]

print("特征值:", eigenvalues)
print("特征向量:", eigenvectors)
print("主成分:", principal_components)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import numpy as np

# 示例矩阵
A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# SVD分解
U, S, Vt = np.linalg.svd(A)

print("U矩阵:")
print(U)
print("\n奇异值:")
print(S)
print("\nV转置矩阵:")
print(Vt)

# 重构矩阵
A_reconstructed = U @ np.diag(S) @ Vt
print("\n重构矩阵:")
print(A_reconstructed)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import numpy as np

# 系数矩阵
A = np.array([[2, 3], [4, -1]])
# 常数向量
b = np.array([8, 2])

# 方法1：使用numpy求解
x = np.linalg.solve(A, b)
print("解:", x)

# 方法2：矩阵求逆
A_inv = np.linalg.inv(A)
x_inv = A_inv @ b
print("逆矩阵解:", x_inv)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

import numpy as np
import matplotlib.pyplot as plt

def gradient_descent(f, grad_f, x0, alpha=0.01, max_iter=1000, tol=1e-6):
    """
    梯度下降算法实现
    """
    x = x0.copy()
    history = [x.copy()]
    
    for i in range(max_iter):
        gradient = grad_f(x)
        x_new = x - alpha * gradient
        
        # 检查收敛
        if np.linalg.norm(x_new - x) < tol:
            break
            
        x = x_new
        history.append(x.copy())
    
    return x, history

# 示例：最小化函数 f(x) = x^2 + 2x + 1
f = lambda x: x**2 + 2*x + 1
grad_f = lambda x: 2*x + 2

# 初始点
x0 = np.array([5.0])

# 执行梯度下降
x_opt, history = gradient_descent(f, grad_f, x0, alpha=0.1)

print(f"最优解: x = {x_opt[0]:.6f}")
print(f"函数值: f(x) = {f(x_opt[0]):.6f}")
print(f"迭代次数: {len(history)}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

# 正态分布参数
mu, sigma = 0, 1

# 生成数据点
x = np.linspace(-4, 4, 100)
y = norm.pdf(x, mu, sigma)

# 绘图
plt.figure(figsize=(10, 6))
plt.plot(x, y, 'b-', linewidth=2, label=f'N({mu}, {sigma}²)')
plt.fill_between(x, y, alpha=0.3)
plt.title('正态分布概率密度函数')
plt.xlabel('x')
plt.ylabel('概率密度')
plt.legend()
plt.grid(True)
plt.show()

# 计算概率
prob_1sigma = norm.cdf(1) - norm.cdf(-1)  # P(-1 < X < 1)
prob_2sigma = norm.cdf(2) - norm.cdf(-2)  # P(-2 < X < 2)

print(f"P(-1 < X < 1) = {prob_1sigma:.4f}")
print(f"P(-2 < X < 2) = {prob_2sigma:.4f}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import numpy as np
from scipy import stats

# 生成示例数据
np.random.seed(42)
group1 = np.random.normal(100, 15, 30)  # 均值100，标准差15
group2 = np.random.normal(110, 15, 30)  # 均值110，标准差15

# 执行t检验
t_stat, p_value = stats.ttest_ind(group1, group2)

print(f"组1均值: {np.mean(group1):.2f}")
print(f"组2均值: {np.mean(group2):.2f}")
print(f"t统计量: {t_stat:.4f}")
print(f"p值: {p_value:.4f}")

# 决策
alpha = 0.05
if p_value < alpha:
    print("拒绝零假设：两组均值有显著差异")
else:
    print("无法拒绝零假设：两组均值无显著差异")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

import numpy as np
from scipy.optimize import minimize
import matplotlib.pyplot as plt

def normal_log_likelihood(params, data):
    """正态分布的对数似然函数"""
    mu, sigma = params
    n = len(data)
    
    # 避免sigma为负
    if sigma <= 0:
        return -np.inf
    
    # 对数似然函数
    log_likelihood = -n/2 * np.log(2*np.pi*sigma**2) - 1/(2*sigma**2) * np.sum((data - mu)**2)
    
    # 最小化负对数似然
    return -log_likelihood

# 生成示例数据
np.random.seed(42)
true_mu, true_sigma = 5, 2
data = np.random.normal(true_mu, true_sigma, 100)

# 初始参数猜测
initial_params = [0, 1]

# 最大似然估计
result = minimize(normal_log_likelihood, initial_params, args=(data,), method='L-BFGS-B', bounds=[(None, None), (1e-6, None)])

mu_mle, sigma_mle = result.x

print(f"真实参数: μ={true_mu}, σ={true_sigma}")
print(f"MLE估计: μ={mu_mle:.4f}, σ={sigma_mle:.4f}")
print(f"样本均值: {np.mean(data):.4f}, 样本标准差: {np.std(data, ddof=1):.4f}")

# 可视化拟合结果
x = np.linspace(true_mu - 3*true_sigma, true_mu + 3*true_sigma, 100)
y_true = 1/(true_sigma*np.sqrt(2*np.pi)) * np.exp(-0.5*((x-true_mu)/true_sigma)**2)
y_mle = 1/(sigma_mle*np.sqrt(2*np.pi)) * np.exp(-0.5*((x-mu_mle)/sigma_mle)**2)

plt.figure(figsize=(10, 6))
plt.hist(data, bins=20, density=True, alpha=0.7, label='数据直方图')
plt.plot(x, y_true, 'r-', linewidth=2, label='真实分布')
plt.plot(x, y_mle, 'b--', linewidth=2, label='MLE拟合')
plt.legend()
plt.title('最大似然估计示例')
plt.xlabel('x')
plt.ylabel('概率密度')
plt.show()