用 Python 学 AI：一份分阶段的自学指南

这三段代码虽然简单，但涵盖了 Python 日常编程的常见模式。这个阶段不用写大项目，每天敲几个小练习就够。

阶段 1：数据科学基础

目标：会用 NumPy 做数组运算，用 Pandas 清洗和聚合数据，用 Matplotlib/Seaborn 画图。这几乎是所有数据相关工作的起点。

NumPy 快速上手

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
# 元素级乘法与矩阵乘法
print(arr * 2)          # 每个元素乘 2
print(arr @ arr.T)      # 矩阵乘法（推荐写法）
print(np.dot(arr, arr.T))  # 等价写法

# 广播机制：自动对齐维度
a = np.array([[1, 2, 3], [4, 5, 6]])  # shape (2, 3)
b = np.array([10, 20, 30])            # shape (3,)
print(a + b)  # b 自动广播为 (2, 3)

Pandas 数据处理

import pandas as pd

df = pd.DataFrame({
    'name': ['张三', '李四', '王五', '赵六'],
    'age': [25, 30, 35, 28],
    'city': ['北京', '上海', '深圳', '杭州'],
    'salary': [15000, 20000, 25000, 18000]
})

# 筛选、分组、排序
high_salary = df[df['salary'] > 18000]
city_stats = df.groupby('city').agg({'salary': ['mean', 'max', 'count']})
df_sorted = df.sort_values('salary', ascending=False)

# 连接另一个表
df2 = pd.DataFrame({'name': ['张三', '李四'], 'department': ['技术', '产品']})
merged = pd.merge(df, df2, on='name', how='left')

数据可视化

import matplotlib.pyplot as plt
import seaborn as sns

plt.rcParams['font.sans-serif'] = ['SimHei']  # 显示中文
fig, axes = plt.subplots(2, 2, figsize=(12, 10))
axes[0, 0].bar(df['name'], df['salary'])
axes[0, 1].scatter(df['age'], df['salary'])
city_counts = df['city'].value_counts()
axes[1, 0].pie(city_counts, labels=city_counts.index, autopct='%1.1f%%')
axes[1, 1].boxplot(df['salary'])
plt.tight_layout()
plt.show()

这个阶段可以找几个公开数据集（比如 iris、titanic）练手，把上面的操作组合起来跑一遍。

阶段 2：机器学习

目标：理解常见算法的原理，能用 Scikit-learn 搭建完整的分类或回归流程。不需要手推公式，但要知道什么时候用什么模型。

常见算法分类：

• 监督学习：线性回归、逻辑回归、决策树、随机森林、XGBoost 等
• 无监督学习：K-Means、DBSCAN、PCA 等
• 强化学习：入门了解即可

线性回归完整示例

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.preprocessing import StandardScaler

# 模拟房价数据（面积、房间数、房龄）
np.random.seed(42)
X = np.random.randn(1000, 3)
X[:, 0] = X[:, 0] * 50 + 100
X[:, 1] = np.abs(X[:, 1]) * 2 + 1
X[:, 2] = np.abs(X[:, 2]) * 10 + 1
y = X[:, 0] * 1000 + X[:, 1] * 50000 - X[:, 2] * 2000 + np.random.randn(1000) * 50000

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

model = LinearRegression()
model.fit(X_train_scaled, y_train)
y_pred = model.predict(X_test_scaled)

print(f"MSE: {mean_squared_error(y_test, y_pred):.2f}")
print(f"R²: {r2_score(y_test, y_pred):.4f}")

多模型对比

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=1000, n_features=20, random_state=42)
models = {
    'LogisticRegression': LogisticRegression(max_iter=1000),
    'SVM': SVC(),
    'RandomForest': RandomForestClassifier(n_estimators=100)
}
for name, model in models.items():
    scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
    print(f"{name}: {scores.mean():.4f} ± {scores.std():.4f}")

在这个阶段，重点是把数据清洗→特征工程→模型训练→评估这个循环跑通。可以参加一次 Kaggle 的入门比赛，比单看教程效果好很多。

阶段 3：深度学习

目标：用 PyTorch 搭模型、训练、调参。建议从全连接网络做起，再接触 CNN 和简单的 Transformer。

一个基础的神经网络

import torch
import torch.nn as nn
import torch.optim as optim

class SimpleNN(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super().__init__()
        self.layer1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(hidden_size, hidden_size // 2)
        self.layer3 = nn.Linear(hidden_size // 2, num_classes)
        self.dropout = nn.Dropout(0.2)

    def forward(self, x):
        x = self.relu(self.layer1(x))
        x = self.dropout(x)
        x = self.relu(self.layer2(x))
        x = self.dropout(x)
        x = self.layer3(x)
        return x

model = SimpleNN(784, 256, 10)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 模拟一个 batch
inputs = torch.randn(32, 784)
labels = torch.randint(0, 10, (32,))
outputs = model(inputs)
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()

CNN 图像分类

class CNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, padding=1)
        self.bn1 = nn.BatchNorm2d(32)
        self.conv2 = nn.Conv2d(32, 32, 3, padding=1)
        self.bn2 = nn.BatchNorm2d(32)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(32 * 14 * 14, 256)  # 假设输入 28x28，两次池化后 14x14
        self.fc2 = nn.Linear(256, num_classes)
        self.dropout = nn.Dropout(0.5)

    def forward(self, x):
        x = self.pool(torch.relu(self.bn1(self.conv1(x))))
        x = self.pool(torch.relu(self.bn2(self.conv2(x))))
        x = x.view(-1, 32 * 14 * 14)
        x = torch.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.fc2(x)
        return x

自注意力的核心实现

import math
import torch.nn.functional as F

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super().__init__()
        assert d_model % num_heads == 0
        self.d_k = d_model // num_heads
        self.num_heads = num_heads
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)

    def scaled_dot_product_attention(self, Q, K, V, mask=None):
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)
        attn = F.softmax(scores, dim=-1)
        return torch.matmul(attn, V), attn

    def forward(self, query, key, value, mask=None):
        batch_size = query.size(0)
        Q = self.W_q(query).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        K = self.W_k(key).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        V = self.W_v(value).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        out, _ = self.scaled_dot_product_attention(Q, K, V, mask)
        out = out.transpose(1, 2).contiguous().view(batch_size, -1, d_model)
        return self.W_o(out)

这个阶段比较耗时，但别被劝退。一开始可以先跑通官方示例，再慢慢改结构、加些自己的数据。

阶段 4：NLP 与 LLM 应用

目标：会调 Transformers 库里的预训练模型，能自己搭一个简单的 RAG 问答系统。

直接使用预训练模型

from transformers import pipeline

classifier = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")
texts = ["I love this product!", "This is terrible."]
for text, result in zip(texts, classifier(texts)):
    print(f"{text} -> {result['label']} ({result['score']:.2f})")

RAG 检索增强生成

from langchain.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

documents = TextLoader('knowledge_base.txt').load()
splits = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50).split_documents(documents)
embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
vectorstore = FAISS.from_documents(splits, embeddings)
qa = RetrievalQA.from_chain_type(
    llm=OpenAI(temperature=0),
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3})
)
result = qa.run("如何办理社保卡？")
print(result)

现在很多公司都在把 LLM 与实际业务结合，这个方向值得多花时间。可以从简单的文档问答做起，再慢慢引入 Agent 和工具调用。

阶段 5：实战项目

以下是一个典型项目的目录结构，可以帮助你保持工程思维：

智能文档问答系统
├── data/
│   ├── documents/
│   └── vectorstore/
├── src/
│   ├── config.py
│   ├── loader.py
│   ├── embeddings.py
│   ├── retriever.py
│   ├── generator.py
│   └── api.py
├── app.py
├── requirements.txt
└── README.md

附一个简化的 FastAPI 接口骨架：

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI(title="智能文档问答系统")

class QueryRequest(BaseModel):
    question: str
    top_k: int = 3

@app.post("/query")
async def query(request: QueryRequest):
    # 调用你的问答逻辑
    return {"answer": "示例回答", "sources": ["doc1", "doc2"]}

建议每个阶段都做一个对应的项目。可以从简单的房价预测（一两天就能跑通）开始，再到图像分类、情感分析，最后尝试把 RAG 或对话机器人部署上线。

一个端到端的机器学习项目（完整流程）

下面这个例子几乎涵盖了特征工程、模型训练、评估、可视化的所有步骤。你可以把它当作一个模板来改造。

# 项目：预测客户是否购买理财产品（模拟数据）
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score, roc_curve

plt.rcParams['font.sans-serif'] = ['SimHei']

np.random.seed(42)
n_samples = 5000
df = pd.DataFrame({
    '年龄': np.random.randint(18, 70, n_samples),
    '收入': np.random.randint(3000, 50000, n_samples),
    '存款': np.random.randint(0, 1000000, n_samples),
    '债务': np.random.randint(0, 500000, n_samples),
    '信用评分': np.random.randint(300, 850, n_samples),
    '已购买产品数': np.random.randint(0, 10, n_samples),
    '上次购买天数': np.random.randint(30, 3650, n_samples),
    '职业': np.random.choice(['学生', '上班族', '个体户', '退休', '自由职业'], n_samples),
    '婚姻状况': np.random.choice(['单身', '已婚', '离异'], n_samples),
    '学历': np.random.choice(['高中', '本科', '硕士', '博士'], n_samples),
})

# 基于特征组合生成购买概率
def calc_purchase_prob(row):
    score = 0
    if 25 <= row['年龄'] <= 55: score += 20
    if row['收入'] > 15000: score += 20
    if row['存款'] > 100000: score += 20
    if row['信用评分'] > 650: score += 15
    if row['职业'] in ['上班族', '个体户']: score += 15
    np.random.seed(int(row['年龄'] + row['收入']))
    return min(score + np.random.randint(-10, 10), 100) / 100

df['购买概率'] = df.apply(calc_purchase_prob, axis=1)
df['是否购买'] = (df['购买概率'] > 0.5).astype(int)

# 编码分类特征
le = LabelEncoder()
df['职业编码'] = le.fit_transform(df['职业'])
df['婚姻编码'] = le.fit_transform(df['婚姻状况'])
df['学历编码'] = le.fit_transform(df['学历'])
df['债务收入比'] = df['债务'] / (df['收入'] * 12 + 1)
df['存款收入比'] = df['存款'] / (df['收入'] * 12 + 1)

feature_cols = ['年龄', '收入', '存款', '债务', '信用评分', '已购买产品数',
                '上次购买天数', '职业编码', '婚姻编码', '学历编码',
                '债务收入比', '存款收入比']
X = df[feature_cols]
y = df['是否购买']

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

models = {
    '逻辑回归': LogisticRegression(max_iter=1000),
    '随机森林': RandomForestClassifier(n_estimators=100),
    '梯度提升': GradientBoostingClassifier()
}
for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    y_proba = model.predict_proba(X_test)[:, 1]
    print(f"{name}: Acc {model.score(X_test, y_test):.4f}, AUC {roc_auc_score(y_test, y_proba):.4f}")

# 可视化特征重要性（以随机森林为例）
rf = models['随机森林']
importances = pd.DataFrame({'feature': feature_cols, 'importance': rf.feature_importances_})
importances = importances.sort_values('importance', ascending=False)
plt.figure(figsize=(10, 6))
plt.barh(importances['feature'], importances['importance'])
plt.tight_layout()
plt.show()

这个例子用的都是模拟数据，但流程和真实任务几乎一样。你可以换成自己手头的数据，感受一下。

资源推荐

在线课程

经典书籍

• 《Python 编程：从入门到实践》、《流畅的 Python》
• 《利用 Python 进行数据分析》
• 《机器学习》（西瓜书）、《统计学习方法》
• 《动手学深度学习》
• Transformer 相关论文和博客

常用工具

• 开发：Jupyter Lab, VS Code, Colab
• 数据处理：NumPy, Pandas, Polars
• 机器学习：Scikit-learn, XGBoost, LightGBM
• 深度学习：PyTorch, Transformers, LangChain
• 部署：FastAPI, Docker, Gradio

常见问题

没编程基础能学吗？
可以。Python 对新手友好，先花几周把基础语法和文件操作弄熟，然后直接进入数据分析，边做边补课。

数学不好怎么办？
用到了再补。初期只需要知道导数、矩阵乘法和概率分布的基本含义，不会的搜一下，完全够用。当你需要优化模型时自然会深入。

多久能找到工作？
因人而异。每天抽 2-3 小时，坚持 8-12 个月，并积累 2-3 个能拿得出手的项目，大概率能拿到初级 AI 工程师的面试机会。经验远比证书重要。

GPU 不够用？
免费方案：Google Colab 提供 T4 GPU，Kaggle Notebook 也有免费额度。如果训练大模型，可以先用混合精度和梯度累积减少显存占用。

如何跟上技术更新？
关注 arXiv 上的趋势论文、Hugging Face 的新模型、Twitter/X 上一些活跃研究者的动态。每月做一个小项目把新东西试一遍，比被动阅读效果好。

学习时间线（参考）

• 2025-01 ~ 2025-02：Python 基础，写小脚本
• 2025-03 ~ 2025-04：NumPy/Pandas + 数据可视化，完成第一个数据分析项目
• 2025-05 ~ 2025-06：机器学习理论与 Scikit-learn 实战，尝试 Kaggle
• 2025-07 ~ 2025-08：PyTorch 基础，搭建 CNN / Transformer
• 2025-09 ~ 2025-10：NLP 与 LLM 应用，做 RAG 或对话机器人

时间不绝对，按自己节奏调整就行。

附录：环境搭建与检查清单

Python 环境一键配置

# 创建虚拟环境
conda create -n ai_env python=3.10
conda activate ai_env

# 安装常用库
pip install numpy pandas matplotlib seaborn scikit-learn xgboost lightgbm
pip install torch torchvision torchaudio transformers langchain
pip install jupyter lab

各阶段检查清单

阶段 0

• 理解数据类型和结构
• 能写函数和类
• 会处理文件、异常

阶段 1

• 熟练用 NumPy 做数组运算
• 能用 Pandas 做数据清洗、分组聚合
• 会画折线图、直方图、散点图

阶段 2

• 了解常见机器学习算法
• 能用 Scikit-learn 完成分类/回归
• 会特征工程基础

阶段 3

• 掌握 PyTorch 基础操作
• 能搭建全连接、CNN 网络
• 理解训练循环和梯度下降

阶段 4

• 会调用 Hugging Face 预训练模型
• 能实现基本的 RAG 流程
• 了解 Agent 概念

每个阶段都动手做一个小项目，这样才能真正内化。不用等到所有都学完才开始做，从阶段 1 就可以边学边做。

以上是我整理的一份自学路线，希望能帮你少走些弯路。最重要的还是坚持写代码、多折腾，很多时候踩过的坑才是记得最牢的。