工欲善其事 —— Python 与数据科学三剑客

为什么 AI 届独宠 Python？因为它简单到像英语一样。
但对 AI 来说，Python 本身太慢了。所以我们给它装上了三个“外挂”：Numpy（算得快）、Pandas（读得快）、Matplotlib（看得清）。

2.1 Python 极速通关（只讲 AI 必须懂的）

如果你有其他语言基础，这部分可以 5 分钟看完。

1. 基础容器：List vs Dictionary

  • 列表 (List) []：就像一个有序的货架。

    Python

    scores = [0.1, 0.5, 0.9]
# AI 场景：通常用来存一轮训练后的 Loss 历史，方便最后画图。
  • 字典 (Dictionary) {}：就像一本带索引的词典。

    Python

    config = {"lr": 0.001, "batch_size": 32, "model_name": "resnet"}
# AI 场景：用来存模型的超参数配置。

2. 核心逻辑：类与对象 (Class & Object)
这是很多脚本党最头疼的地方，但在 PyTorch 里躲不掉。
因为每一个神经网络模型，本质上都是一个类。

  • 为什么要用类？
    神经网络不仅仅是一堆代码，它还需要保存状态（比如训练好的权重参数 w 和 b）。类 = 代码 + 状态。
  • PyTorch 模板代码（背下来）：

    Python

    class MyAI(object): # 假设这是 PyTorch 的基类 nn.Module
    def __init__(self):
        # 初始化：在这里定义你的“脑子”长什么样（几层？每层多少神经元？）
        self.layer1 = "Linear Layer" 
        
    def forward(self, x):
        # 前向传播：数据 x 进来，怎么一步步变成结果？
        x = self.layer1(x)
        return x
        
# 实例化：造出一个具体的 AI
model = MyAI()
    你必须理解 __init__ 是造零件的地方，forward 是拼装零件的地方。
2.2 Numpy：数值计算的瑞士军刀

Python 的列表 [1, 2, 3] 虽好，但它太慢且不能做数学运算（你不能把列表直接乘以 2）。
Numpy 的出现就是为了解决这个问题。它底层是 C 语言写的，快到飞起。

核心概念：ndarray (N维数组)

Python

import numpy as np

# 1. 创建数组：把 Python 列表变成 Numpy 数组
data = np.array([1, 2, 3, 4]) 

# 2. 魔法运算（广播机制 Broadcasting）
# 在 Python 里你需要写循环，在 Numpy 里直接算
print(data * 10) 
# 输出：[10, 20, 30, 40] -> 这就是并行计算的雏形！

# 3. 维度变换（AI 最常用的操作）
# 把一条线 (4,) 变成 矩阵 (2, 2)
matrix = data.reshape(2, 2)
print(matrix.shape) # 输出 (2, 2)

AI 场景：
当你读取一张图片时，它就是一个 (Height, Width, 3) 的 Numpy 数组。所有的图像预处理（裁剪、旋转、变色）都是在操作这个数组。

2.3 Pandas：AI 界的 Excel

在现实世界中，数据往往是脏乱差的 CSV 表格。Pandas 就是用来清洗它们的。

核心概念：DataFrame (数据框)

Python

import pandas as pd

# 1. 读取数据（就像打开 Excel）
df = pd.read_csv("titanic.csv")

# 2. 偷看一眼数据
print(df.head()) # 看前5行

# 3. 数据清洗（最重要的一步！）
# AI 怕空值。如果年龄那一列有空缺，我们填上平均值。
df['Age'] = df['Age'].fillna(df['Age'].mean())

# 4. 选择数据
# 挑选出所有活下来的人
survivors = df[df['Survived'] == 1]

AI 场景：
训练模型前，90% 的时间都在跟 Pandas 打交道：删掉没用的列、填补空缺值、把“男/女”这种文字转换成“0/1”这种数字。

2.4 Matplotlib：把枯燥的数据可视化

训练 AI 就像盲人摸象。如果你不画图，你永远不知道 Loss 是在下降还是在震荡。

Python

import matplotlib.pyplot as plt

# 假设这是训练过程中的 Loss 变化
losses = [0.9, 0.7, 0.5, 0.3, 0.1]

# 画折线图
plt.plot(losses)
plt.title("Model Training Loss")
plt.xlabel("Epoch (Time)")
plt.ylabel("Error")
plt.show()

AI 场景：

  • Loss 曲线： 必须画，看看模型有没有学傻（过拟合）。
  • 混淆矩阵： 看看 AI 到底把猫错认成了狗，还是错认成了兔子。
小结：
  1. 用 Pandas 打开 CSV 文件，把脏数据洗干净。
  2. 用 Numpy 把清洗好的数据转换成矩阵。
  3. 用 Python Class 定义神经网络模型。
  4. 训练完后，用 Matplotlib 画张图，发给老板看：“瞧，准确率又提升了！”

经典武器库 —— Scikit-Learn (sklearn)

如果说 PyTorch 是造火箭（灵活但复杂），那么 Scikit-Learn 就是微波炉（简单，好用，插电即热）。

它封装了过去几十年所有的经典机器学习算法。你不需要懂背后的数学原理，只需要会调包。

1. 为什么还要学传统 ML？

你可能会问：“现在不都是深度学习时代了吗？”
别急，原因有三：

  1. 数据少时它更强： 如果你只有几百条数据，深度学习会过拟合（死记硬背），而传统算法（如 SVM、随机森林）效果往往更好。
  2. 解释性强： 老板问你“为什么 AI 拒绝了这笔贷款？”
    • 神经网络：黑盒，不知道。
    • 决策树：因为它年收入 < 5万且无房。
  3. 基准线 (Baseline)： 做任何 AI 项目，先用最简单的算法跑一遍，知道最低能考多少分，再去搞复杂的模型。
2. Sklearn 的“三板斧”

Scikit-Learn 的设计哲学极其统一。不管你用什么算法（逻辑回归、支持向量机、随机森林），代码永远只有三行：

  1. Instantiate (实例化)： 选个模型。
  2. Fit (拟合)： 喂数据训练。
  3. Predict (预测)： 考试。

实战：用 KNN (K-近邻算法) 做分类
任务：根据鸢尾花 (Iris) 的花瓣大小，判断它是哪个品种。

Python

# 0. 导包
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# 1. 准备数据
data = load_iris()
X = data.data  # 特征 (花瓣长宽等)
y = data.target # 标签 (品种 0, 1, 2)

# 切分试卷：80% 拿来练习 (train)，20% 拿来考试 (test)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# --- 核心代码开始 ---

# 2. 实例化模型
# n_neighbors=3 意思是：看离我最近的 3 个邻居是谁，我就跟谁一伙
model = KNeighborsClassifier(n_neighbors=3)

# 3. 拟合 (训练)
model.fit(X_train, y_train)

# 4. 预测 (考试)
predictions = model.predict(X_test)

# --- 核心代码结束 ---

# 5. 算分
accuracy = accuracy_score(y_test, predictions)
print(f"准确率: {accuracy * 100:.2f}%")

看到没有？哪怕你不懂 KNN 的数学原理，照着写也能跑出一个 AI。

3. 兵器谱：你应该选哪个算法？

Sklearn 里有几十种算法，怎么选？这里有一份速查表：

  • 分类问题 (Yes/No, Cat/Dog)：
    • 简单线性问题 →→ Logistic Regression (逻辑回归) （名字叫回归，其实是分类！）
    • 复杂非线性问题 →→ SVM (支持向量机) 或 Random Forest (随机森林)
  • 回归问题 (预测房价/气温)：
    • 简单趋势 →→ Linear Regression (线性回归)
    • 复杂波动 →→ Decision Tree Regressor (决策树回归)
  • 聚类问题 (把用户分成几堆，且没有标签)：
    • K-Means (K均值聚类)
4. 特征工程 (Preprocessing)：Sklearn 的隐形翅膀

数据往往不是拿来就能用的。Sklearn 提供了强大的数据预处理工具。

  • 归一化 (Scaler)：
    房价是 5000000，卧室数是 3。这两个数字差了百万倍，会让模型跑偏。
    StandardScaler 可以把它们都压缩到 0 附近。

    Python

    from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

  • 独热编码 (One-Hot)：
    电脑看不懂“红色、绿色”。
    OneHotEncoder 把它们变成 [1, 0] 和 [0, 1]。

小结

Scikit-Learn 是 AI 工程师的基本功。
在深度学习之前，先用 sklearn 跑个 Demo，往往能帮你理清数据的逻辑，甚至直接解决问题。

记住：能用简单模型解决的问题，千万别上神经网络。 (Occam's Razor 奥卡姆剃刀原理)

    倚天剑与屠龙刀 —— PyTorch vs TensorFlow

    如果说 Numpy 是手工打造零件，那么深度学习框架（Deep Learning Framework）就是全自动机床。它们帮我们解决了最难的两件事：

    1. 自动求导 (Autograd)： 你再也不用手算微积分了。
    2. GPU 加速： 一行代码就能把计算任务扔给显卡。
    1. 历史的尘埃：Caffe, Theano, MXNet

    在深度学习的石器时代（2015 年之前），我们用 Caffe 写代码就像在写配置文件，用 Theano 就像在解数学题。它们虽然伟大，但因为难用、调试反人类，最终都成了历史的尘埃。

    记住它们的名字，是对先驱的致敬，但请不要去学它们。

    2. 工业界的霸主：TensorFlow (Google) —— 屠龙刀
    • 地位： 由 Google 撑腰，曾经是绝对的统治者（TensorFlow 1.x 时代）。
    • 特点（曾经）：
      • 静态图 (Static Graph)： 你得先像画电路图一样，把整个网络结构画好，锁定，然后才能通电（喂数据）跑起来。
      • 优点： 一旦画好，部署到服务器或手机上非常稳定、高效。适合工业级产品落地。
      • 缺点： 调试是噩梦。如果代码报错了，你根本不知道是哪一层错了，因为它还没跑起来。
    • 现状（TensorFlow 2.x）： 被 PyTorch 逼得不得不改版，现在的 TF 2.0 抄了很多 PyTorch 的设计（Keras 接口），变得好用多了，但在学术界已经失宠。
    3. 学术界的宠儿：PyTorch (Meta/Facebook) —— 倚天剑
    • 地位： 后起之秀，目前在顶会论文（CVPR/ICLR）中的使用率超过 80%。本书将全程使用 PyTorch。
    • 特点：
      • 动态图 (Dynamic Graph)： 所见即所得。 它的代码写起来就像普通的 Python 代码一样。你可以随时用 print() 打印中间变量，甚至在神经网络里写 if-else 循环。
      • 优点： 极其灵活，极其符合 Python 程序员的直觉。最适合学习、研究和快速原型开发。
      • 缺点： 早期版本部署稍显麻烦（现在已有 TorchScript 解决）。

    比喻：

    • TensorFlow 1.x 就像造桥。你必须先把图纸画得一丝不苟，审批通过后才能动工。桥造好了很稳，但中间想改图纸？没门。
    • PyTorch 就像搭积木。你边搭边看，觉得不满意拆了重搭，随时可以停下来检查这一块积木对不对。
    4. [实战对比] 为什么我们选 PyTorch？

    让我们通过实现一个最简单的操作：矩阵相乘，来看看两者的区别。

    PyTorch 写法（Python 原生风格）：

    Python

    import torch

# 1. 定义两个张量（类似 Numpy，但在 GPU 上）
x = torch.tensor([1.0, 2.0])
y = torch.tensor([3.0, 4.0])

# 2. 直接乘，就像 Python 算术一样
z = x * y 

# 3. 随时可以打印结果调试
print(z) 
# 输出: tensor([3., 8.])

    TensorFlow 1.x 写法（反人类风格 - 仅作鉴赏）：

    Python

    import tensorflow as tf

# 1. 定义“占位符”（像电路插座）
x = tf.placeholder(tf.float32)
y = tf.placeholder(tf.float32)

# 2. 定义计算图（此时并没有计算！）
z = x * y 

# 3. 开启一个会话（Session），通电
with tf.Session() as sess:
    # 4. 喂数据进去，才能拿到结果
    result = sess.run(z, feed_dict={x: [1.0, 2.0], y: [3.0, 4.0]})
    print(result)

    看到区别了吗？PyTorch 的代码是命令式的（做一步算一步），而老版 TensorFlow 是符号式的（先定义后执行）。对于初学者来说，PyTorch 的学习曲线要平缓得多。

    5. 其他值得关注的框架

    虽然 PyTorch 是主角，但还有几个配角值得了解：

    • Keras： 它是 TensorFlow 的“高级皮肤”。它把复杂的代码封装成了极简的接口（model.fit() 一键训练）。适合小白入门，但不够灵活。
    • JAX (Google)： 谷歌的“备胎”或“秘密武器”。深受数学极客喜爱，速度极快，在某些前沿科研领域（如 AlphaFold）正在取代 PyTorch。如果你已经是大牛，可以关注它；如果是小白，先忽略。
    • Hugging Face Transformers： 这不是一个底层框架，而是一个大模型仓库。它基于 PyTorch，让你能用 3 行代码调用最先进的 BERT、GPT 模型。它是 AI 应用开发的必修课。

    总结：你的选择

    在本书中，我们将坚定地站在 PyTorch 这一边。
    因为它不仅是现在学术界的通用语，也是通往大模型（LLM）开发的必经之路（绝大多数开源大模型都是用 PyTorch 训练的）。

    学会了 PyTorch，你就能看懂 arXiv 上最新的论文，就能修改 GitHub 上最火的项目。

    PyTorch 五步法 —— 神经网络的“流水线”

    不管你是写一个简单的“手写数字识别”，还是训练一个复杂的“ChatGPT”，在 PyTorch 里，代码结构永远都是这五个步骤：

    1. 数据准备 (Data)： 把数据变成张量 (Tensor)。
    2. 模型搭建 (Model)： 用积木搭出网络结构。
    3. 定义标准 (Loss & Optimizer)： 怎么算分？怎么改进？
    4. 训练循环 (Training Loop)： 喂数据 -> 算误差 -> 改参数。
    5. 保存模型 (Save)： 把练好的丹药存起来。

    让我们一步步拆解。

    1. Tensor (张量)：PyTorch 的原子

    PyTorch 里的一切都是 Tensor。它长得和 Numpy 数组一模一样，唯一的区别是：它能被送到显卡 (GPU) 上去。

    Python

    import torch

# 创建 Tensor
x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])

# 【关键】把数据送到 GPU 上（如果有的话）
device = "cuda" if torch.cuda.is_available() else "cpu"
x = x.to(device) 

print(f"数据在哪里: {x.device}")
# 如果你有显卡，会输出: cuda:0
    2. nn.Module：搭建乐高积木

    在 PyTorch 中，所有的神经网络都要继承 nn.Module 这个类。你只需要关心两件事：

    • __init__：仓库里有什么零件？
    • forward：这些零件怎么拼起来？

    实战：造一个最简单的神经网络

    Python

    import torch.nn as nn

class MySimpleAI(nn.Module):
    def __init__(self):
        super().__init__()
        # 定义两层全连接层 (Linear)
        # 第一层：输入 10 个特征 -> 变成 20 个特征
        self.layer1 = nn.Linear(10, 20) 
        # 激活函数：ReLU (给网络加点非线性，不然就是一堆线性方程)
        self.relu = nn.ReLU()
        # 第二层：20 个特征 -> 输出 1 个结果
        self.layer2 = nn.Linear(20, 1)

    def forward(self, x):
        # 数据流向：Layer1 -> ReLU -> Layer2
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)
        return x

# 实例化模型，并移到 GPU
model = MySimpleAI().to(device)
    3. Loss & Optimizer：裁判与教练
    • Loss Function (损失函数)： 裁判。它告诉你模型错得有多离谱。
      • 做回归任务（预测房价）用 MSELoss (均方误差)。
      • 做分类任务（猜猫狗）用 CrossEntropyLoss (交叉熵)。
    • Optimizer (优化器)： 教练。它根据裁判的打分，去调整模型的参数。
      • 最常用的教练叫 SGD (随机梯度下降) 和 Adam (自适应优化器，目前最强)。

    Python

    # 定义裁判
criterion = nn.MSELoss() 

# 定义教练
# 告诉教练：你要训练在这个 model 里的参数 (parameters)
# lr=0.01 是学习率，步子迈多大
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
    4. Training Loop：炼丹的核心仪式

    这一步是初学者最容易晕的地方，请背诵这**“训练四部曲”**：

    1. 清零 (Zero Grad)： 把上一步算的梯度倒掉，不然会累积。
    2. 前向 (Forward)： 模型做题，算出预测值。
    3. 反向 (Backward)： 算出误差，求导（算梯度）。
    4. 更新 (Step)： 教练根据梯度，调整参数。

    Python

    # 假设我们要训练 100 轮 (Epoch)
for epoch in range(100):
    # 1. 准备假数据 (Batch Size=32)
    inputs = torch.randn(32, 10).to(device)
    targets = torch.randn(32, 1).to(device)

    # === 训练四部曲 ===
    
    # Step 1: 梯度清零
    optimizer.zero_grad()
    
    # Step 2: 前向传播 (模型预测)
    outputs = model(inputs)
    
    # Step 3: 计算 Loss 并反向传播
    loss = criterion(outputs, targets)
    loss.backward() # 这就在自动求导
    
    # Step 4: 更新参数
    optimizer.step()
    
    # 打印一下 Loss 看看有没有变小
    if epoch % 10 == 0:
        print(f"Epoch {epoch}, Loss: {loss.item()}")
    5. Save & Load：存档与读档

    训练这事儿可能要跑好几天，一定要记得存档。

    Python

    # 存档：只保存模型的“参数字典” (state_dict)，不保存整个模型结构，这样文件最小
torch.save(model.state_dict(), "my_ai_model.pth")

# 读档
model.load_state_dict(torch.load("my_ai_model.pth"))
model.eval() # 切换到评估模式 (关闭 Dropout 等训练专用功能)

    小结

    这就是 PyTorch 的全部心法：
    把数据丢进 GPU →→ optimizer.zero_grad() →→ loss.backward() →→ optimizer.step()

    无论多复杂的 AI，哪怕是 GPT-4，它的训练代码底层逻辑也跑不出这个 for 循环。这就是我们掌握力量的起点。

      1. Numpy：砖块与水泥（地基）

      • 角色：最底层的原材料供应商。
      • 关系：
        • 它是所有人的爸爸。 Pandas、Scikit-Learn、PyTorch、TensorFlow 的底层核心计算逻辑，全都借鉴或依赖 Numpy。
        • 它负责把所有数据变成数字矩阵（砖块）。
        • 不管你用什么高级框架，最后输进去的数据，往往都要先变成 Numpy 数组（ndarray）。
      • 一句话：没有它，Python 做不了数学题。

      2. Pandas：设计图与施工队（数据处理）

      • 角色：原材料加工厂。
      • 关系：
        • 它是 Numpy 的高级封装。Numpy 只有冰冷的数字，Pandas 给数字加上了表头、索引、时间戳，变成了 Excel 表格。
        • 负责脏活累活：盖楼前，要把运来的烂泥巴（脏数据）清洗干净，筛选出合格的砖块，然后交给下游。
        • 承上启下：它处理好的数据，通常转化为 Numpy 数组，再喂给 Scikit-Learn 或 PyTorch。
      • 一句话：它是 Excel 的 Python 版，专门负责洗菜。

      3. Scikit-Learn：活动板房搭建器（传统 ML）

      • 角色：轻量级建筑公司。
      • 关系：
        • 它直接吃 Numpy 或 Pandas 的数据。
        • 它和 PyTorch/TF 是竞争关系（但赛道不同）。
        • 它负责盖小房子（传统机器学习模型，如逻辑回归、决策树）。
        • 如果你只要盖个狗窝（简单预测），用它最快，不用动用重型机械。
      • 一句话：它是工具箱，里面有现成的锤子和钉子，拿来就能用。

      4. PyTorch & TensorFlow：摩天大楼重型机械（深度学习）

      • 角色：重型建筑集团。
      • 关系：
        • 它俩是死对头（竞品）。 你通常只需要二选一（现在推荐选 PyTorch）。
        • 它们是 Numpy 的“威力加强版”。 它们的 Tensor（张量）和 Numpy 的 Array 很像，但有两个超能力：
          1. 能送到 GPU 上跑（Numpy 只能在 CPU 上跑）。
          2. 能自动求导（Numpy 只能做算术）。
        • 它们负责盖摩天大楼（深度神经网络、大语言模型）。
      • 一句话：它们是全自动造楼机，专门用来造核电站这种复杂的东西。

      总结图谱

      数据流向 (Workflow)：

      1. 原始数据 (CSV/Excel)
        ↓↓
      2. Pandas (清洗、筛选、填补空缺)
        ↓↓
      3. Numpy (把表格变成纯数字矩阵)
        ↓↓
      4. 分岔路口：
        • 任务简单？数据少？ →→ 喂给 Scikit-Learn (秒出结果)
        • 任务复杂？做图像/NLP？ →→ 喂给 PyTorch (转化为 Tensor，丢进 GPU 炼丹)

      层级关系：

      • L0 (基石): Python
      • L1 (数学): Numpy
      • L2 (工具): Pandas (数据), Matplotlib (画图)
      • L3 (应用): Scikit-Learn (传统 ML), PyTorch/TensorFlow (深度 DL)
      # python # 开发语言 # 人工智能
      Logo
      2048 AI社区

      有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

      更多推荐

      cover

      【IO】 IO核心机制全解析

      avatar 2048 AI社区

      【7】工程项目生成【第一篇】

      现在很多前端工程化项目都是使用 Vue 或 React 框架，结合 Vite 等打包构建工具，再加上 ESLint 之类的代码规范校验库来实现的。根据lanhChain4j的工具开发方法，新建一个文件写入工具类，编写writeFile方法，并给方法打上@tool工具注解，尽量给工具和每个参数添加描述以减轻工具幻觉。由于不知道要生成多少个文件、以及文件的层级组织关系，需要使用工具调用来写入文件。以提

      avatar 2048 AI社区
      cover

      CSDN农业知识专栏（开箱即用版）

      avatar 2048 AI社区