AI学习的数学基础与编程基础

从零开始掌握AI所需的数学和编程技能

📋 概述

本文为零基础学习者提供系统的数学和编程入门指南。不要被"数学"吓倒，我们会用最通俗的方式讲解，并且强调"够用就好"的原则——你不需要成为数学家或编程大师，只需要掌握AI开发所需的核心知识。

第一部分：数学基础

为什么需要数学？

直接回答：

神经网络本质是数学运算
理解原理需要数学语言
调试模型需要数学直觉

但是：

不需要数学博士水平
重点是理解概念，不是证明定理
很多数学库已经帮你实现了

学习策略：

先学应用，遇到不懂的数学再补
重点掌握核心概念和直觉
能看懂公式，会用工具计算即可

1. 线性代数（最重要）

1.1 为什么线性代数最重要？

神经网络的核心就是矩阵运算

# 神经网络的前向传播
output = activation(weights @ input + bias)
#                    ↑ 这是矩阵乘法

一句话总结：

向量 = 一组数
矩阵 = 向量的集合
矩阵乘法 = 神经网络的核心运算

1.2 向量（Vector）

什么是向量？

数学定义：一组有序的数

直观理解：

一维：一个数 5
二维：一对数 [3, 4]（平面上的点或箭头）
三维：三个数 [1, 2, 3]（空间中的点或箭头）
高维：更多数 [1, 2, 3, 4, 5, ...]

在AI中的意义：

# 一张图片的像素值
image = [255, 128, 64, ...]  # 向量

# 一个词的词向量表示
word_embedding = [0.2, -0.5, 0.8, ...]  # 向量

# 神经网络的输入
input_vector = [1.0, 2.5, 3.2, 0.8]  # 向量

向量运算

1. 向量加法

a = [1, 2, 3]
b = [4, 5, 6]
a + b = [5, 7, 9]  # 对应位置相加

几何意义：箭头首尾相连

AI应用：特征融合

2. 向量数乘

a = [1, 2, 3]
2 * a = [2, 4, 6]  # 每个元素乘以2

几何意义：箭头伸缩

AI应用：学习率调整

3. 点积（内积）

a = [1, 2, 3]
b = [4, 5, 6]
a · b = 1*4 + 2*5 + 3*6 = 32

几何意义：衡量两个向量的相似度

点积大 → 方向相似
点积为0 → 垂直
点积小 → 方向相反

AI应用：

计算相似度
注意力机制
神经网络计算

4. 向量长度（范数）

a = [3, 4]
||a|| = √(3² + 4²) = 5

AI应用：

归一化
正则化
梯度裁剪

Python实现

import numpy as np

# 创建向量
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 向量加法
print(a + b)  # [5 7 9]

# 向量数乘
print(2 * a)  # [2 4 6]

# 点积
print(np.dot(a, b))  # 32

# 向量长度
print(np.linalg.norm(a))  # 3.7416573867739413

1.3 矩阵（Matrix）

什么是矩阵？

数学定义：二维数组

直观理解：

A = [[1, 2, 3],
     [4, 5, 6]]

2行3列的矩阵
记作 2×3 矩阵

在AI中的意义：

# 神经网络的权重
weights = [[0.1, 0.2, 0.3],
           [0.4, 0.5, 0.6],
           [0.7, 0.8, 0.9]]

# 一批图片（batch）
images = [[img1],
          [img2],
          [img3]]  # 每行是一张图片

# 词向量矩阵
word_embeddings = [[0.1, 0.2, ...],  # 词1的向量
                   [0.3, 0.4, ...],  # 词2的向量
                   ...]

矩阵运算

1. 矩阵加法

A = [[1, 2],    B = [[5, 6],
     [3, 4]]         [7, 8]]

A + B = [[6, 8],
         [10, 12]]

规则：对应位置相加，要求形状相同

2. 矩阵数乘

A = [[1, 2],
     [3, 4]]

2 * A = [[2, 4],
         [6, 8]]

3. 矩阵乘法（重点）

规则：

A的列数必须等于B的行数
(m×n) × (n×p) = (m×p)

计算方法：

A = [[1, 2],    B = [[5, 6],
     [3, 4]]         [7, 8]]

A × B = [[1*5+2*7, 1*6+2*8],
         [3*5+4*7, 3*6+4*8]]
      = [[19, 22],
         [43, 50]]

直观理解：

结果的第i行第j列 = A的第i行 · B的第j列

为什么重要？

# 神经网络的核心运算
output = weights @ input
#        ↑ 矩阵乘法

# 具体例子
weights = [[0.1, 0.2, 0.3],  # 3个输入 → 2个输出
           [0.4, 0.5, 0.6]]
input = [[1.0],
         [2.0],
         [3.0]]

output = weights @ input
       = [[0.1*1 + 0.2*2 + 0.3*3],
          [0.4*1 + 0.5*2 + 0.6*3]]
       = [[1.4],
          [3.2]]

4. 矩阵转置

A = [[1, 2, 3],
     [4, 5, 6]]

A^T = [[1, 4],
       [2, 5],
       [3, 6]]

规则：行变列，列变行

AI应用：

反向传播
注意力机制
权重共享

Python实现

import numpy as np

# 创建矩阵
A = np.array([[1, 2, 3],
              [4, 5, 6]])
B = np.array([[7, 8],
              [9, 10],
              [11, 12]])

# 矩阵形状
print(A.shape)  # (2, 3)

# 矩阵乘法
C = A @ B  # 或 np.dot(A, B)
print(C)
# [[ 58  64]
#  [139 154]]

# 矩阵转置
print(A.T)
# [[1 4]
#  [2 5]
#  [3 6]]

# 逐元素乘法（不是矩阵乘法）
D = np.array([[1, 2],
              [3, 4]])
E = np.array([[5, 6],
              [7, 8]])
print(D * E)  # 逐元素相乘
# [[ 5 12]
#  [21 32]]

1.4 特殊矩阵

1. 单位矩阵（Identity Matrix）

I = [[1, 0, 0],
     [0, 1, 0],
     [0, 0, 1]]

对角线为1，其余为0
性质：A × I = A（类似数字中的1）

2. 零矩阵

O = [[0, 0],
     [0, 0]]

所有元素为0
性质：A + O = A

3. 对角矩阵

D = [[2, 0, 0],
     [0, 3, 0],
     [0, 0, 4]]

只有对角线有值
计算高效

1.5 线性代数在AI中的应用

1. 神经网络前向传播

# 单层神经网络
output = activation(W @ input + b)
#                   ↑ 矩阵乘法

2. 批量处理

# 一次处理多个样本
inputs = [[x1],  # 样本1
          [x2],  # 样本2
          [x3]]  # 样本3

outputs = inputs @ weights  # 一次计算所有样本

3. 注意力机制

# Transformer的自注意力
attention_scores = Q @ K.T  # Query × Key转置
attention_weights = softmax(attention_scores / sqrt(d_k))
output = attention_weights @ V  # 加权求和Value

4. 降维（PCA）

# 主成分分析
# 找到数据变化最大的方向（特征向量）
# 投影到低维空间

1.6 线性代数学习资源

视频课程

📺 3Blue1Brown《线性代数的本质》（强烈推荐）
- 可视化讲解，直觉理解
- B站有中文字幕

书籍

📚 《程序员的数学3：线性代数》
- 面向程序员，实用导向
📚 《线性代数及其应用》
- 经典教材

实践

用NumPy实现所有运算
从零实现简单神经网络
可视化矩阵变换

2. 微积分

2.1 为什么需要微积分？

一句话：训练神经网络就是用梯度下降优化参数，而梯度就是导数。

核心应用：

反向传播算法
梯度下降优化
理解模型训练过程

2.2 导数（Derivative）

什么是导数？

直观理解：函数的变化率

例子：

位置-时间关系：s(t) = t²
速度 = 位置的变化率 = ds/dt = 2t

几何意义：曲线的切线斜率

数学定义：

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

常见函数的导数

# 1. 常数函数
f(x) = c
f'(x) = 0

# 2. 幂函数
f(x) = x^n
f'(x) = n·x^(n-1)

# 例子：
f(x) = x²  →  f'(x) = 2x
f(x) = x³  →  f'(x) = 3x²

# 3. 指数函数
f(x) = e^x
f'(x) = e^x

# 4. 对数函数
f(x) = ln(x)
f'(x) = 1/x

# 5. 三角函数
f(x) = sin(x)  →  f'(x) = cos(x)
f(x) = cos(x)  →  f'(x) = -sin(x)

求导法则

1. 加法法则

(f + g)' = f' + g'

2. 乘法法则

(f · g)' = f'·g + f·g'

3. 链式法则（最重要）

(f(g(x)))' = f'(g(x)) · g'(x)

例子：

f(x) = (x² + 1)³

设 u = x² + 1，则 f = u³
f'(x) = 3u² · 2x = 6x(x² + 1)²

为什么重要？

神经网络是复合函数
反向传播就是链式法则的应用

2.3 偏导数（Partial Derivative）

什么是偏导数？

场景：函数有多个变量

例子：

f(x, y) = x² + 2xy + y²

偏导数：

对x求偏导：把y当常数
```
∂f/∂x = 2x + 2y
```
对y求偏导：把x当常数
```
∂f/∂y = 2x + 2y
```

在AI中：

# 损失函数
Loss(w₁, w₂, ..., wₙ)

# 需要计算每个参数的偏导数
∂Loss/∂w₁, ∂Loss/∂w₂, ..., ∂Loss/∂wₙ

2.4 梯度（Gradient）

什么是梯度？

定义：所有偏导数组成的向量

数学表示：

∇f = [∂f/∂x₁, ∂f/∂x₂, ..., ∂f/∂xₙ]

例子：

f(x, y) = x² + y²

∇f = [∂f/∂x, ∂f/∂y] = [2x, 2y]

几何意义：

指向函数增长最快的方向
长度表示增长的速度

在AI中的应用：

# 梯度下降
weights = weights - learning_rate * gradient
#                                   ↑ 梯度

2.5 梯度下降（Gradient Descent）

核心思想

目标：找到函数的最小值

方法：沿着梯度的反方向走

类比：

你在山上，想下到山谷（最低点）
看看周围哪个方向最陡（梯度）
往相反方向走（负梯度）
重复直到到达谷底

算法步骤

# 1. 初始化参数
w = random_value

# 2. 循环直到收敛
while not converged:
    # 3. 计算梯度
    gradient = compute_gradient(loss, w)
    
    # 4. 更新参数
    w = w - learning_rate * gradient
    
    # 5. 计算新的损失
    loss = compute_loss(w)

学习率（Learning Rate）

作用：控制每次更新的步长

w = w - α * gradient
#           ↑ 学习率

选择：

太大：可能越过最优点，震荡
太小：收敛太慢
合适：稳定快速收敛

典型值：0.001, 0.01, 0.1

可视化理解

损失函数曲线：

Loss
 ↑
 |     ╱╲
 |    ╱  ╲
 |   ╱    ╲
 |  ╱      ╲___
 | ╱           ╲
 |╱_____________╲____→ w
    ↑         ↑
   起点    最优点

梯度下降过程：
起点 → 计算梯度 → 更新参数 → 计算梯度 → ... → 最优点

2.6 链式法则与反向传播

神经网络是复合函数

# 两层神经网络
z1 = W1 @ x + b1
a1 = relu(z1)
z2 = W2 @ a1 + b2
y = softmax(z2)
loss = cross_entropy(y, target)

函数嵌套：

loss = f₅(f₄(f₃(f₂(f₁(x)))))

反向传播 = 链式法则

目标：计算 ∂loss/∂W1

链式法则：

∂loss/∂W1 = ∂loss/∂z2 · ∂z2/∂a1 · ∂a1/∂z1 · ∂z1/∂W1

反向传播过程：

1. 前向传播：计算输出和损失
2. 反向传播：从后往前计算梯度
   loss → z2 → a1 → z1 → W1
3. 更新参数：使用计算出的梯度

为什么叫"反向"？

前向：输入 → 输出
反向：输出 → 输入（传递梯度）

2.7 微积分学习资源

视频课程

📺 3Blue1Brown《微积分的本质》
📺 Khan Academy 微积分课程

书籍

📚 《程序员的数学2：概率统计》
📚 《深度学习的数学》

实践

手动计算简单函数的导数
用NumPy验证梯度计算
从零实现反向传播

3. 概率统计

3.1 为什么需要概率？

AI处理的是不确定性

应用场景：

分类问题：输出概率分布
生成模型：采样生成数据
贝叶斯推理：更新信念
模型评估：理解不确定性

3.2 基础概念

概率（Probability）

定义：事件发生的可能性

范围：0 ≤ P(A) ≤ 1

例子：

抛硬币：P(正面) = 0.5
抛骰子：P(6) = 1/6

条件概率

定义：在B发生的条件下，A发生的概率

符号：P(A|B)

例子：

P(下雨|阴天) = 0.7
P(下雨|晴天) = 0.1

计算公式：

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

独立事件

定义：一个事件不影响另一个事件

数学表示：

P(A∩B) = P(A) · P(B)

例子：

独立：两次抛硬币
不独立：不放回抽卡

3.3 概率分布

离散分布

1. 伯努利分布（Bernoulli）

场景：二分类（0或1）

例子：

抛硬币（正/反）
邮件分类（垃圾/正常）

参数：p（成功概率）

P(X=1) = p
P(X=0) = 1-p

2. 分类分布（Categorical）

场景：多分类

例子：

图像分类（猫/狗/鸟）
下一个词预测

参数：p₁, p₂, ..., pₖ（各类别概率）

P(X=i) = pᵢ
Σpᵢ = 1

连续分布

正态分布（高斯分布）

最重要的分布！

公式：

N(μ, σ²)
μ：均值（中心位置）
σ²：方差（分散程度）

概率密度函数：

f(x) = (1/√(2πσ²)) · e^(-(x-μ)²/(2σ²))

特点：

钟形曲线
对称
68-95-99.7规则

在AI中的应用：

权重初始化：N(0, 0.01)
噪声建模
变分自编码器（VAE）

Python实现：

import numpy as np
import matplotlib.pyplot as plt

# 生成正态分布数据
data = np.random.normal(loc=0, scale=1, size=1000)
#                       ↑均值  ↑标准差  ↑样本数

# 可视化
plt.hist(data, bins=30, density=True)
plt.show()

3.4 期望和方差

期望（Expected Value）

定义：平均值

离散：

E[X] = Σ xᵢ · P(xᵢ)

连续：

E[X] = ∫ x · f(x) dx

例子：

抛骰子的期望：
E[X] = 1·(1/6) + 2·(1/6) + ... + 6·(1/6) = 3.5

方差（Variance）

定义：偏离期望的程度

公式：

Var[X] = E[(X - E[X])²]
       = E[X²] - (E[X])²

标准差：

σ = √Var[X]

在AI中：

数据标准化
批归一化（Batch Normalization）
权重初始化

3.5 贝叶斯定理

公式

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

各部分名称：

P(A|B)：后验概率（我们要求的）
P(B|A)：似然（likelihood）
P(A)：先验概率
P(B)：证据

直观理解

例子：疾病诊断

已知：
- P(患病) = 0.01（先验：1%的人患病）
- P(阳性|患病) = 0.99（灵敏度）
- P(阳性|健康) = 0.05（假阳性率）

问题：检测阳性，真的患病的概率？

解答：
P(患病|阳性) = P(阳性|患病) · P(患病) / P(阳性)

P(阳性) = P(阳性|患病)·P(患病) + P(阳性|健康)·P(健康)
        = 0.99·0.01 + 0.05·0.99
        = 0.0594

P(患病|阳性) = 0.99·0.01 / 0.0594 ≈ 0.167

结论：即使阳性，只有16.7%真患病！

启示：

直觉常常错误
需要考虑先验概率
贝叶斯推理很有用

在AI中的应用

朴素贝叶斯分类器

# 垃圾邮件分类
P(垃圾|邮件内容) = P(邮件内容|垃圾) · P(垃圾) / P(邮件内容)

贝叶斯优化

超参数调优
高效搜索最优参数

变分推断

近似贝叶斯推理
VAE的理论基础

3.6 最大似然估计（MLE）

核心思想

问题：给定数据，估计模型参数

方法：找到最可能产生观测数据的参数

例子：

抛硬币10次，8次正面，2次反面
估计正面概率p？

似然函数：
L(p) = p⁸ · (1-p)²

最大似然估计：
p̂ = argmax L(p) = 0.8

在神经网络中

训练 = 最大似然估计

# 分类问题
# 最大化正确类别的概率
max Π P(yᵢ|xᵢ, θ)

# 等价于最小化负对数似然
min -Σ log P(yᵢ|xᵢ, θ)
    ↑ 交叉熵损失

3.7 概率统计学习资源

书籍

📚 《概率论与数理统计》
📚 《统计学习方法》（李航）

视频

📺 Khan Academy 概率统计
📺 StatQuest 统计学视频

实践

用NumPy生成各种分布
实现朴素贝叶斯分类器
可视化概率分布

第二部分：Python编程基础

为什么选择Python？

AI领域的首选语言

优势：

语法简洁，易学易用
丰富的AI库（TensorFlow、PyTorch）
强大的数据处理能力（NumPy、Pandas）
活跃的社区和资源

学习目标：

掌握Python基础语法
熟练使用NumPy、Pandas
能够读懂和编写AI代码

1. Python基础语法

1.1 变量和数据类型

# 数字
age = 25
price = 19.99

# 字符串
name = "Alice"
message = 'Hello, World!'

# 布尔值
is_student = True
has_passed = False

# 列表（可变）
numbers = [1, 2, 3, 4, 5]
mixed = [1, "two", 3.0, True]

# 元组（不可变）
coordinates = (10, 20)

# 字典
person = {
    "name": "Alice",
    "age": 25,
    "city": "Beijing"
}

# 集合
unique_numbers = {1, 2, 3, 3, 4}  # {1, 2, 3, 4}

1.2 运算符

# 算术运算
a = 10 + 5   # 15
b = 10 - 5   # 5
c = 10 * 5   # 50
d = 10 / 5   # 2.0
e = 10 // 3  # 3 (整除)
f = 10 % 3   # 1 (取余)
g = 2 ** 3   # 8 (幂运算)

# 比较运算
10 == 10  # True
10 != 5   # True
10 > 5    # True
10 <= 10  # True

# 逻辑运算
True and False  # False
True or False   # True
not True        # False

1.3 控制流

# if语句
score = 85
if score >= 90:
    print("优秀")
elif score >= 60:
    print("及格")
else:
    print("不及格")

# for循环
for i in range(5):
    print(i)  # 0, 1, 2, 3, 4

for item in [1, 2, 3]:
    print(item)

# while循环
count = 0
while count < 5:
    print(count)
    count += 1

# 列表推导式（重要！）
squares = [x**2 for x in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

even_squares = [x**2 for x in range(10) if x % 2 == 0]
# [0, 4, 16, 36, 64]

1.4 函数

# 定义函数
def greet(name):
    return f"Hello, {name}!"

# 调用函数
message = greet("Alice")
print(message)  # Hello, Alice!

# 默认参数
def power(x, n=2):
    return x ** n

print(power(3))     # 9
print(power(3, 3))  # 27

# 多个返回值
def min_max(numbers):
    return min(numbers), max(numbers)

minimum, maximum = min_max([1, 2, 3, 4, 5])

# Lambda函数（匿名函数）
square = lambda x: x**2
print(square(5))  # 25

# 常用于map、filter
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))

1.5 类和对象

# 定义类
class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def bark(self):
        return f"{self.name} says Woof!"
    
    def get_age_in_dog_years(self):
        return self.age * 7

# 创建对象
my_dog = Dog("Buddy", 3)
print(my_dog.bark())  # Buddy says Woof!
print(my_dog.get_age_in_dog_years())  # 21

# 继承
class Puppy(Dog):
    def __init__(self, name, age, favorite_toy):
        super().__init__(name, age)
        self.favorite_toy = favorite_toy
    
    def play(self):
        return f"{self.name} plays with {self.favorite_toy}"

2. NumPy - 数值计算

2.1 为什么需要NumPy？

问题：Python列表效率低

# Python列表
a = [1, 2, 3]
b = [4, 5, 6]
# a + b = [1, 2, 3, 4, 5, 6]  # 拼接，不是相加！

# 要逐元素相加，需要循环
c = [a[i] + b[i] for i in range(len(a))]

NumPy的优势：

高效的数组运算
向量化操作（无需循环）
底层C实现，速度快
AI计算的基础

2.2 创建数组

import numpy as np

# 从列表创建
a = np.array([1, 2, 3, 4, 5])
print(a)  # [1 2 3 4 5]

# 二维数组（矩阵）
b = np.array([[1, 2, 3],
              [4, 5, 6]])
print(b.shape)  # (2, 3)

# 特殊数组
zeros = np.zeros((3, 4))  # 全0数组
ones = np.ones((2, 3))    # 全1数组
identity = np.eye(3)      # 单位矩阵

# 随机数组
random = np.random.rand(3, 4)  # [0, 1)均匀分布
normal = np.random.randn(3, 4)  # 标准正态分布

# 序列
arange = np.arange(0, 10, 2)  # [0, 2, 4, 6, 8]
linspace = np.linspace(0, 1, 5)  # [0, 0.25, 0.5, 0.75, 1]

2.3 数组运算

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 逐元素运算（向量化）
print(a + b)  # [5 7 9]
print(a * b)  # [4 10 18]
print(a ** 2)  # [1 4 9]

# 广播（Broadcasting）
c = np.array([[1, 2, 3],
              [4, 5, 6]])
print(c + 10)  # 每个元素加10
# [[11 12 13]
#  [14 15 16]]

# 矩阵乘法
A = np.array([[1, 2],
              [3, 4]])
B = np.array([[5, 6],
              [7, 8]])
C = A @ B  # 或 np.dot(A, B)
print(C)
# [[19 22]
#  [43 50]]

# 转置
print(A.T)
# [[1 3]
#  [2 4]]

2.4 索引和切片

import numpy as np

a = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

# 索引
print(a[0])   # 0
print(a[-1])  # 9

# 切片
print(a[2:5])    # [2 3 4]
print(a[:5])     # [0 1 2 3 4]
print(a[5:])     # [5 6 7 8 9]
print(a[::2])    # [0 2 4 6 8]

# 二维数组
b = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

print(b[0, 0])    # 1
print(b[1, :])    # [4 5 6]
print(b[:, 1])    # [2 5 8]
print(b[0:2, 1:3])  # [[2 3]
                     #  [5 6]]

# 布尔索引
mask = a > 5
print(a[mask])  # [6 7 8 9]

# 一行实现
print(a[a > 5])  # [6 7 8 9]

2.5 常用函数

import numpy as np

a = np.array([1, 2, 3, 4, 5])

# 统计函数
print(np.sum(a))     # 15
print(np.mean(a))    # 3.0
print(np.std(a))     # 1.4142135623730951
print(np.min(a))     # 1
print(np.max(a))     # 5
print(np.argmin(a))  # 0 (最小值的索引)
print(np.argmax(a))  # 4 (最大值的索引)

# 数学函数
print(np.sqrt(a))    # 平方根
print(np.exp(a))     # e^x
print(np.log(a))     # 自然对数
print(np.sin(a))     # 正弦

# 矩阵操作
b = np.array([[1, 2],
              [3, 4]])
print(np.linalg.det(b))  # 行列式
print(np.linalg.inv(b))  # 逆矩阵
eigenvalues, eigenvectors = np.linalg.eig(b)  # 特征值和特征向量

2.6 形状操作

import numpy as np

a = np.array([[1, 2, 3],
              [4, 5, 6]])

print(a.shape)  # (2, 3)

# 重塑
b = a.reshape(3, 2)
print(b)
# [[1 2]
#  [3 4]
#  [5 6]]

# 展平
c = a.flatten()
print(c)  # [1 2 3 4 5 6]

# 添加维度
d = np.array([1, 2, 3])
print(d.shape)  # (3,)
e = d[np.newaxis, :]  # 添加行维度
print(e.shape)  # (1, 3)
f = d[:, np.newaxis]  # 添加列维度
print(f.shape)  # (3, 1)

# 拼接
a1 = np.array([[1, 2]])
a2 = np.array([[3, 4]])
print(np.vstack([a1, a2]))  # 垂直拼接
# [[1 2]
#  [3 4]]
print(np.hstack([a1, a2]))  # 水平拼接
# [[1 2 3 4]]

2.7 NumPy在AI中的应用

import numpy as np

# 1. 数据标准化
data = np.array([1, 2, 3, 4, 5])
normalized = (data - np.mean(data)) / np.std(data)

# 2. One-hot编码
def one_hot(labels, num_classes):
    n = len(labels)
    one_hot_labels = np.zeros((n, num_classes))
    one_hot_labels[np.arange(n), labels] = 1
    return one_hot_labels

labels = np.array([0, 2, 1, 0])
print(one_hot(labels, 3))
# [[1. 0. 0.]
#  [0. 0. 1.]
#  [0. 1. 0.]
#  [1. 0. 0.]]

# 3. Softmax函数
def softmax(x):
    exp_x = np.exp(x - np.max(x))  # 数值稳定性
    return exp_x / np.sum(exp_x)

logits = np.array([2.0, 1.0, 0.1])
probs = softmax(logits)
print(probs)  # [0.659 0.242 0.099]

# 4. 简单神经网络前向传播
def forward(X, W1, b1, W2, b2):
    # 第一层
    z1 = X @ W1 + b1
    a1 = np.maximum(0, z1)  # ReLU
    
    # 第二层
    z2 = a1 @ W2 + b2
    a2 = softmax(z2)
    
    return a2

3. Pandas - 数据处理

3.1 为什么需要Pandas？

NumPy的局限：

只能处理数值数据
没有列名、行名
缺少高级数据操作

Pandas的优势：

表格数据处理
支持多种数据类型
强大的数据清洗和分析功能
类似Excel，但更强大

3.2 Series（一维数据）

import pandas as pd

# 创建Series
s = pd.Series([1, 2, 3, 4, 5])
print(s)
# 0    1
# 1    2
# 2    3
# 3    4
# 4    5

# 带索引的Series
s = pd.Series([100, 200, 300], index=['A', 'B', 'C'])
print(s)
# A    100
# B    200
# C    300

# 访问
print(s['A'])  # 100
print(s[0])    # 100

3.3 DataFrame（二维数据）

import pandas as pd

# 从字典创建
data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'city': ['Beijing', 'Shanghai', 'Guangzhou']
}
df = pd.DataFrame(data)
print(df)
#       name  age       city
# 0    Alice   25    Beijing
# 1      Bob   30   Shanghai
# 2  Charlie   35  Guangzhou

# 查看数据
print(df.head())      # 前5行
print(df.tail())      # 后5行
print(df.info())      # 数据信息
print(df.describe())  # 统计摘要

# 访问列
print(df['name'])
print(df.name)  # 也可以

# 访问行
print(df.loc[0])      # 按标签
print(df.iloc[0])     # 按位置

# 访问特定元素
print(df.loc[0, 'name'])  # Alice

3.4 数据读取和保存

import pandas as pd

# 读取CSV
df = pd.read_csv('data.csv')

# 读取Excel
df = pd.read_excel('data.xlsx')

# 读取JSON
df = pd.read_json('data.json')

# 保存
df.to_csv('output.csv', index=False)
df.to_excel('output.xlsx', index=False)

3.5 数据选择和过滤

import pandas as pd

df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David'],
    'age': [25, 30, 35, 40],
    'score': [85, 90, 78, 92]
})

# 选择列
print(df[['name', 'age']])

# 过滤行
print(df[df['age'] > 30])
# name  age  score
# 2  Charlie   35     78
# 3    David   40     92

# 多条件过滤
print(df[(df['age'] > 25) & (df['score'] > 80)])

# 排序
print(df.sort_values('age', ascending=False))

# 选择特定行和列
print(df.loc[df['age'] > 30, ['name', 'score']])

3.6 数据清洗

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'A': [1, 2, np.nan, 4],
    'B': [5, np.nan, np.nan, 8],
    'C': [9, 10, 11, 12]
})

# 检查缺失值
print(df.isnull())
print(df.isnull().sum())

# 删除缺失值
df_dropped = df.dropna()  # 删除包含NaN的行
df_dropped_col = df.dropna(axis=1)  # 删除包含NaN的列

# 填充缺失值
df_filled = df.fillna(0)  # 用0填充
df_filled = df.fillna(df.mean())  # 用均值填充

# 删除重复行
df_unique = df.drop_duplicates()

# 替换值
df_replaced = df.replace(np.nan, -1)

3.7 数据转换

import pandas as pd

df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'score1': [85, 90, 78],
    'score2': [88, 92, 80]
})

# 添加新列
df['average'] = (df['score1'] + df['score2']) / 2

# 应用函数
df['grade'] = df['average'].apply(lambda x: 'A' if x >= 90 else 'B' if x >= 80 else 'C')

# 分组聚合
grouped = df.groupby('grade')['average'].mean()

# 数据透视
pivot = df.pivot_table(values='average', columns='grade', aggfunc='mean')

3.8 Pandas在AI中的应用

import pandas as pd
import numpy as np

# 1. 加载数据集
df = pd.read_csv('train.csv')

# 2. 探索性数据分析
print(df.head())
print(df.info())
print(df.describe())
print(df.isnull().sum())

# 3. 特征工程
# 处理缺失值
df['age'].fillna(df['age'].median(), inplace=True)

# 编码分类变量
df['gender_encoded'] = df['gender'].map({'M': 0, 'F': 1})

# One-hot编码
df_encoded = pd.get_dummies(df, columns=['category'])

# 4. 数据划分
from sklearn.model_selection import train_test_split

X = df[['feature1', 'feature2', 'feature3']]
y = df['target']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 5. 特征缩放
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

4. Matplotlib - 数据可视化

4.1 基础绘图

import matplotlib.pyplot as plt
import numpy as np

# 折线图
x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.figure(figsize=(10, 6))
plt.plot(x, y)
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Sine Wave')
plt.grid(True)
plt.show()

# 散点图
x = np.random.randn(100)
y = np.random.randn(100)

plt.scatter(x, y, alpha=0.5)
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Scatter Plot')
plt.show()

# 柱状图
categories = ['A', 'B', 'C', 'D']
values = [25, 40, 30, 55]

plt.bar(categories, values)
plt.xlabel('Category')
plt.ylabel('Value')
plt.title('Bar Chart')
plt.show()

# 直方图
data = np.random.randn(1000)

plt.hist(data, bins=30, edgecolor='black')
plt.xlabel('Value')
plt.ylabel('Frequency')
plt.title('Histogram')
plt.show()

4.2 多子图

import matplotlib.pyplot as plt
import numpy as np

fig, axes = plt.subplots(2, 2, figsize=(12, 10))

# 子图1
x = np.linspace(0, 10, 100)
axes[0, 0].plot(x, np.sin(x))
axes[0, 0].set_title('Sine')

# 子图2
axes[0, 1].plot(x, np.cos(x))
axes[0, 1].set_title('Cosine')

# 子图3
axes[1, 0].scatter(np.random.randn(100), np.random.randn(100))
axes[1, 0].set_title('Scatter')

# 子图4
axes[1, 1].hist(np.random.randn(1000), bins=30)
axes[1, 1].set_title('Histogram')

plt.tight_layout()
plt.show()

4.3 AI中的可视化

import matplotlib.pyplot as plt
import numpy as np

# 1. 训练曲线
epochs = range(1, 51)
train_loss = np.exp(-np.linspace(0, 3, 50)) + np.random.rand(50) * 0.1
val_loss = np.exp(-np.linspace(0, 2.5, 50)) + np.random.rand(50) * 0.15

plt.figure(figsize=(10, 6))
plt.plot(epochs, train_loss, label='Train Loss')
plt.plot(epochs, val_loss, label='Val Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training History')
plt.legend()
plt.grid(True)
plt.show()

# 2. 混淆矩阵
import seaborn as sns

confusion_matrix = np.array([[50, 2, 3],
                              [1, 45, 4],
                              [2, 3, 48]])

plt.figure(figsize=(8, 6))
sns.heatmap(confusion_matrix, annot=True, fmt='d', cmap='Blues')
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()

# 3. 特征分布
features = np.random.randn(1000, 3)

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
for i in range(3):
    axes[i].hist(features[:, i], bins=30)
    axes[i].set_title(f'Feature {i+1}')
plt.tight_layout()
plt.show()