AI 智能体开发第一月 · Week 1 逐小时执行手册

主题：LLM 基础概念------从"听过"到"真的懂"

目标：7 天后你能用自己的话解释 LLM 怎么工作，跑通 6 个实验脚本，写出一篇可发布的笔记

每日时间 ：工作日 1.5-2 小时，周六 3-4 小时，周日 2-3 小时，共约 16 小时

前置条件：Python 基础语法、任意一个大模型 API Key（推荐 DeepSeek，便宜免梯子）

本周知识地图

复制代码

AI 全景认知
  └─ LLM 是什么、GPT 演进史、关键术语
       └─ Transformer 架构
            └─ Attention 机制、Encoder vs Decoder、GPT 是 Decoder-only
                 └─ Token / Embedding / Context Window
                      └─ Token 计数实验、语义相似度实验
                           └─ 模型对比与选择
                                └─ GPT-4o / DeepSeek / Qwen 实测
                                     └─ 采样参数
                                          └─ Temperature / Top-P 实验
                                               └─ 综合实验 + 写笔记

核心原则：本周不写 Agent 代码，只打地基。概念不清楚，后面每一步都会卡。

Day 1（周一）--- AI 全景认知 + 开发环境搭建

总时长 ：90 分钟 | 难度：入门 | 产出：环境就绪 + Hello World

19:00-19:25 ｜概念层次（25 分钟）

读这部分时，拿张纸画一张包含关系图：

复制代码

AI（人工智能）
 └─ ML（机器学习）：从数据中学习规律
     └─ DL（深度学习）：用神经网络
         └─ NLP（自然语言处理）：处理语言
             └─ LLM（大语言模型）：超大规模语言模型

三个必须理解的概念：

概念	一句话解释	通俗比喻
预训练（Pre-training）	用海量文本让模型学会语言能力	读完整个图书馆
微调（Fine-tuning）	用特定数据让模型学会跟随指令	做模拟题学会考试格式
RLHF	用人类反馈让模型"说人话"	老师批改作文，学会怎么写好

GPT 演进时间线（建立感觉就行，不用背）：

年份	模型	参数量	关键突破
2018	GPT-1	1.17 亿	证明预训练+微调可行
2019	GPT-2	15 亿	零样本能力初现
2020	GPT-3	1750 亿	In-context learning 涌现
2022	ChatGPT	---	RLHF，模型"说人话"
2023	GPT-4	---	多模态，推理提升
2024	GPT-4o	---	实时多模态
2025-26	o1/o3 系列	---	推理模型，慢思考

自测：能回答以下问题就过关------

LLM 和传统 NLP 有什么区别？（答：LLM 预训练+规模化的涌现能力，传统 NLP 靠人工设计特征）
为什么 ChatGPT 比 GPT-3 更"好用"？（答：RLHF 让模型输出对齐了人类偏好）

19:25-19:45 ｜环境搭建（20 分钟）

逐步执行，每步完成后确认输出：

bash 复制代码

# 步骤 1：确认 Python 版本（需 3.10+）
python --version
# 预期输出: Python 3.10.x 或更高

# 步骤 2：创建项目目录
mkdir ai-agent-learning
cd ai-agent-learning

# 步骤 3：创建虚拟环境
python -m venv ai-agent-env

# 步骤 4：激活虚拟环境
# Windows (Git Bash):
source ai-agent-env/Scripts/activate
# macOS/Linux:
# source ai-agent-env/bin/activate

# 激活后命令行前面会出现 (ai-agent-env)

常见报错处理：

报错	原因	解决
`python: command not found`	Windows 上 Python 可能叫 `python3`	试 `python3 --version`
激活失败	路径有中文或空格	移到纯英文路径
`pip` 很慢	默认用国外源	换源（见下方）

bash 复制代码

# pip 换国内源（推荐）
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

bash 复制代码

# 步骤 5：安装依赖
pip install openai python-dotenv tiktoken numpy

# 预期：看到 Successfully installed openai-x.x.x ...

19:45-20:00 ｜注册 API Key + 项目结构（15 分钟）

获取 API Key（选一个就行）：

平台	注册地址	特点	价格
DeepSeek	https://platform.deepseek.com/	国内直连，便宜	约 ¥1/百万 token
OpenAI	https://platform.openai.com/	需梯子，最全	约 ¥18/百万 token
阿里百炼	https://bailian.console.aliyun.com/	国内直连，中文好	约 ¥4/百万 token

创建项目结构：

复制代码

ai-agent-learning/
├── .env                 # API Key（必须加入 .gitignore！）
├── .gitignore
├── notes/               # 每日笔记
│   └── day1.md
├── code/                # 代码练习
│   └── hello_llm.py
└── README.md

.env 文件内容（注意：永远不要把 .env 传到 GitHub）：

复制代码

# 如果用 DeepSeek
DEEPSEEK_API_KEY=sk-你的key
# 如果用 OpenAI
OPENAI_API_KEY=sk-你的key

.gitignore 内容：

复制代码

.env
ai-agent-env/
__pycache__/
*.pyc

20:00-20:30 ｜ Hello World------第一次调用 LLM（30 分钟）

python 复制代码

# code/hello_llm.py
"""第一个 LLM 程序：验证 API 可用"""
import os
from dotenv import load_dotenv
from openai import OpenAI

# 加载 .env 中的环境变量
load_dotenv()

# === 如果你用 DeepSeek ===
client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com"
)
MODEL = "deepseek-chat"

# === 如果你用 OpenAI，注释掉上面，取消下面注释 ===
# client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
# MODEL = "gpt-4o"

# 第一次对话
print("正在调用 LLM...")
response = client.chat.completions.create(
    model=MODEL,
    messages=[
        {"role": "user", "content": "用一句话解释什么是大语言模型"}
    ]
)

# 打印结果
print(f"\n回答: {response.choices[0].message.content}")
print(f"\n--- Token 用量 ---")
print(f"输入: {response.usage.prompt_tokens} tokens")
print(f"输出: {response.usage.completion_tokens} tokens")
print(f"总计: {response.usage.total_tokens} tokens")

运行：

bash 复制代码

python code/hello_llm.py

预期输出（内容会不同，但格式一样）：

复制代码

正在调用 LLM...

回答: 大语言模型是一种通过海量文本数据训练的超大规模AI模型，能够理解和生成人类语言。

--- Token 用量 ---
输入: 14 tokens
输出: 32 tokens
总计: 46 tokens

如果报错：

报错	解决
`AuthenticationError`	API Key 没填对，检查 .env
`APIConnectionError`	DeepSeek 检查网络；OpenAI 需要梯子
`RateLimitError`	免费额度用完了，换平台注册
`ModuleNotFoundError: No module named 'openai'`	虚拟环境没激活，或没装包

今日笔记模板

在 notes/day1.md 中写：

markdown 复制代码

# Day 1 笔记

## 今天学到的 3 件事
1. 
2. 
3. 

## 我对 AI 全景的理解（200 字内）


## API 调用踩的坑


## 明天的问题
-

Day 1 验收清单

能说出 AI > ML > DL > NLP > LLM 的包含关系
知道预训练、微调、RLHF 分别是什么
虚拟环境创建成功，依赖安装完成
API Key 获取成功，.env 配置正确
hello_llm.py 运行成功，看到 LLM 回复
notes/day1.md 写完

Day 2（周二）--- Transformer 架构直觉理解

总时长 ：60 分钟 | 难度：中等（有概念理解） | 产出：能用自己的话解释 Attention

19:00-19:20 ｜为什么需要 Attention（20 分钟）

先理解问题：在 Transformer 之前，处理文本用 RNN/LSTM，它们逐词处理：

复制代码

RNN 处理 "The cat sat on the mat because it was tired"

处理到 "it" 时：
- RNN 记住了前面所有词的信息，但越早的词越模糊
- "it" 指代 "cat" 还是 "mat"？RNN 很难判断

Attention 的核心思想：处理每个词时，直接"看"句子中所有其他词，动态决定关注哪些。

通俗比喻：

你在聚会上听朋友说话（当前词）
同时你能感知周围其他人的对话（所有词）
你的注意力会自动聚焦到和你朋友说话相关的人身上（Attention 权重）
不相关的对话被过滤掉

19:20-19:50 ｜ Self-Attention 机制（30 分钟）

Q、K、V 三个概念（这是本周最难的部分，慢慢看）：

概念	全称	通俗解释	搜索引擎类比
Q	Query	当前词在"找"什么信息	你输入的搜索词
K	Key	每个词"能提供"什么信息	网页的标题/关键词
V	Value	每个词的实际信息内容	网页的正文内容

计算过程（不背公式，理解流程）：

复制代码

输入: "我 喜欢 编程"

处理 "编程" 这个词时：
1. "编程" 生成自己的 Q（我在找什么？找和编程相关的语义）
2. "我"、"喜欢"、"编程" 各自生成 K（我能提供什么）
3. 用 Q 和每个 K 算相似度 → 得到权重
   - "我" 的 K 和 "编程" 的 Q 相似度低 → 权重小
   - "喜欢" 的 K 和 "编程" 的 Q 相似度高 → 权重大
4. 用权重对所有 V 加权求和 → "编程" 的新表示包含了上下文信息

多头注意力（Multi-Head Attention）：

复制代码

一个 "头" 关注一种关系：
- Head 1: 关注语法关系（主语-谓语）
- Head 2: 关注语义关系（同义词）
- Head 3: 关注指代关系（"it" 指代什么）
- ...
多个头并行 → 模型同时从多个维度理解文本

19:50-20:00 ｜ Transformer 整体结构（10 分钟）

复制代码

输入文本 "Hello"
    ↓
Token 化 → [15496]           # 文本转数字
    ↓
Embedding → [0.1, -0.3, ...]  # 数字转向量
    ↓
┌─ Layer 1 ─────────────────┐
│  Self-Attention            │
│  Feed Forward Network      │
└────────────────────────────┘
    ↓
┌─ Layer 2 ─────────────────┐
│  Self-Attention            │
│  Feed Forward Network      │
└────────────────────────────┘
    ↓  ... (重复 N 层，GPT-4 有近百层)
输出概率分布 → 预测下一个 Token

关键区别：

架构	代表模型	特点
Encoder-only	BERT	理解输入，适合分类、搜索
Decoder-only	GPT 系列	生成输出，适合对话、写作
Encoder-Decoder	T5, BART	翻译、摘要

GPT 就是 Decoder-only：给它前面的词，它预测下一个词，一个一个往后生成。这就是你看到 ChatGPT 一个字一个字蹦出来的原因。

资源	时长	价值
3Blue1Brown「But what is a GPT?」	15 min	直觉理解最佳，YouTube
Jay Alammar「The Illustrated Transformer」	文章	图解最清晰，jalammar.github.io
Karpathy「Let's build GPT from scratch」	2h	硬核，可选看前 30 分钟

今日笔记

markdown 复制代码

# Day 2 笔记

## Attention 机制（我的理解，300 字内）


## Q/K/V 的关系


## GPT 为什么是 Decoder-only


## 还不清楚的点
-

Day 2 验收清单

能解释为什么 RNN 处理长文本有问题
能用自己的话说 Q、K、V 分别是什么
知道 GPT 是 Decoder-only，BERT 是 Encoder-only
知道"预测下一个词"是 GPT 的核心机制
notes/day2.md 写完

Day 3（周三）--- Token、Embedding、Context Window

总时长 ：90 分钟 | 难度：中等 | 产出：2 个实验脚本 + 语义搜索初体验

这天最关键------Token 和 Embedding 是后面所有内容的基础。

19:00-19:35 ｜ Part 1: Token（35 分钟）

概念（10 分钟）：

Token 是 LLM 处理文本的最小单位。它不是"词"也不是"字"，而是介于两者之间的碎片。

语言	大约比例	例子
英文	1 token ≈ 4 字符 ≈ 0.75 词	"hello" = 1 token, "tokenization" = 2-3 tokens
中文	1 汉字 ≈ 1-2 token	"你好" ≈ 2-4 tokens

为什么 Token 重要：

费用：API 按 token 计费，中文比英文贵 2-3 倍
限制：Context Window 是 token 数，不是字数
速度：生成速度 = tokens/秒，token 越多越慢

动手实验（25 分钟）：

python 复制代码

# code/token_experiment.py
"""Token 计数实验：理解中英文的 Token 消耗差异"""
import tiktoken

# GPT-4o / DeepSeek 使用的分词器
# 注意：不同模型分词器不同，tiktoken 是 OpenAI 的
enc = tiktoken.encoding_for_model("gpt-4o")

print("=" * 60)
print("实验 1: 中英文 Token 对比")
print("=" * 60)

texts = [
    ("Hello, world!", "英文短句"),
    ("你好，世界！", "中文短句"),
    ("I am learning AI agent development.", "英文长句"),
    ("我正在学习 AI 智能体开发。", "中文长句"),
    ("Artificial intelligence is transforming the world.", "英文更长"),
    ("人工智能正在改变世界。", "中文更长"),
]

print(f"{'文本':<35} {'字符数':>5} {'Token数':>7} {'比值':>6}")
print("-" * 60)
for text, desc in texts:
    tokens = enc.encode(text)
    ratio = len(tokens) / len(text)
    print(f"{text:<35} {len(text):>5} {len(tokens):>7} {ratio:>5.2f}")

print(f"\n结论：中文的 token/字符比更高，写 Prompt 时用英文更省 token。")

print("\n" + "=" * 60)
print("实验 2: Token 到底长什么样")
print("=" * 60)

# 看 token 的具体内容
text = "Hello, 世界！I love 编程"
tokens = enc.encode(text)
print(f"\n原文: {text}")
print(f"Token 数: {len(tokens)}")
print(f"\n逐个 Token 展示:")
for i, token_id in enumerate(tokens):
    token_text = enc.decode([token_id])
    print(f"  [{i}] ID={token_id:>6}  内容='{token_text}'")

print("\n" + "=" * 60)
print("实验 3: 压缩 Prompt 的 Token 节省")
print("=" * 60)

# 同一个意思，不同写法
variants = [
    ("啰嗦版", "请你帮我写一个函数，这个函数的功能是实现两个数字的相加，然后返回它们的和。"),
    ("正常版", "写一个加法函数，返回两数之和。"),
    ("极简版", "实现 add(a, b) 返回 a+b"),
]

print(f"\n{'版本':<8} {'文本':<55} {'Token':>5}")
print("-" * 70)
for label, text in variants:
    tokens = enc.encode(text)
    print(f"{label:<8} {text:<55} {len(tokens):>5}")

print(f"\n结论：精简 Prompt 语句可以显著节省 Token。")

运行：

bash 复制代码

python code/token_experiment.py

实验后回答：

"你好，世界！"用多少 token？（记下数字）
中文和英文表达同一意思，token 差几倍？
压缩 Prompt 语句能省多少 token？

19:35-20:10 ｜ Part 2: Embedding（35 分钟）

概念（10 分钟）：

Embedding 是把文本变成一串数字（向量），让计算机能算"语义相似度"。

复制代码

"我喜欢吃苹果" → [0.12, -0.34, 0.56, ..., 0.78]  (1536 维向量)
"我爱吃水果"   → [0.15, -0.31, 0.52, ..., 0.75]  (很接近)
"今天天气真好" → [-0.20, 0.45, -0.12, ..., 0.03]  (差很远)

怎么算相似度：余弦相似度（Cosine Similarity），两个向量方向越一致，相似度越高。

为什么重要：这是 RAG（检索增强生成）的基础。第 4 个月会深入，今天先感受一下。

动手实验（25 分钟）：

python 复制代码

# code/embedding_experiment.py
"""Embedding 实验：让计算机理解语义相似度"""
import os
import numpy as np
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

# 用 DeepSeek 的话换配置
client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com"
)

# DeepSeek 暂不支持 Embedding，如果用 DeepSeek 需要 OpenAI 或阿里
# 如果只有 DeepSeek，可以用阿里的 Embedding：
# client = OpenAI(
#     api_key=os.getenv("DASHSCOPE_API_KEY"),
#     base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
# )
# 然后模型用 "text-embedding-v3"

def get_embedding(text):
    """获取文本的 Embedding 向量"""
    response = client.embeddings.create(
        model="text-embedding-3-small",  # OpenAI 的 Embedding 模型
        input=text
    )
    return response.data[0].embedding

def cosine_similarity(a, b):
    """计算两个向量的余弦相似度（-1 到 1，越接近 1 越相似）"""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# 实验文本对
pairs = [
    ("我喜欢吃苹果", "我爱吃水果", "近义句"),
    ("我喜欢吃苹果", "苹果是一家科技公司", "同词不同义"),
    ("我喜欢吃苹果", "今天天气真好", "完全不相关"),
    ("AI 改变世界", "人工智能改变世界", "中英文混用近义"),
    ("Python 是编程语言", "Java 是编程语言", "同类概念"),
    ("Python 是编程语言", "我喜欢吃面条", "不相关"),
]

print("=" * 60)
print("语义相似度实验")
print("=" * 60)

print("\n正在计算 Embedding（需要调用 API）...\n")

for text1, text2, desc in pairs:
    emb1 = get_embedding(text1)
    emb2 = get_embedding(text2)
    sim = cosine_similarity(emb1, emb2)
    
    bar = "█" * int(sim * 30)  # 简单的可视化条
    print(f"[{desc}]")
    print(f"  '{text1}'")
    print(f"  '{text2}'")
    print(f"  相似度: {sim:.4f} {bar}")
    print()

print("分析:")
print("1. 近义句相似度 > 0.8")
print("2. 同词不同义（苹果）相似度低")
print("3. 完全不相关相似度接近 0")
print("4. 这就是 RAG 的基础：用相似度找到最相关的知识")

运行：

bash 复制代码

python code/embedding_experiment.py

预期输出：

复制代码

[近义句]
  '我喜欢吃苹果'
  '我爱吃水果'
  相似度: 0.8732 ██████████████████████████

[同词不同义]
  '我喜欢吃苹果'
  '苹果是一家科技公司'
  相似度: 0.6521 ███████████████████

...

实验后回答：

"我喜欢吃苹果"和"我爱吃水果"的相似度是多少？
"苹果"在水果语境和公司语境下，相似度差异明显吗？
你能想到 Embedding 还能用来做什么？（提示：搜索、推荐、分类）

20:10-20:30 ｜ Part 3: Context Window（20 分钟）

概念（10 分钟）：

Context Window = 模型一次能处理的最多 Token 数（输入 + 输出）。

模型	Context Window	约等于
GPT-4o	128K tokens	~10 万字中文
Claude 3.5	200K tokens	~15 万字中文
Gemini 1.5	1M tokens	~70 万字中文
DeepSeek	64K tokens	~5 万字中文

超过限制怎么办：

截断：丢掉最早的消息（最简单）
摘要：把早期对话压缩成摘要（第 3 周会实现）
RAG：只检索相关片段（第 4 个月深入）

思考题（10 分钟），写在笔记里：

一个 128K 上下文的模型，能一次读完一本 30 万字的小说吗？
- 答：30 万字 ≈ 40-60 万 token，超过 128K，不能。
Context Window 越大就越好吗？
- 不是。窗口越大：成本越高（按 token 计费）、延迟越长、模型在长文本中可能"走神"。
如果对话历史越来越长，怎么控制成本？
- 裁剪旧消息、用摘要替代、限制对话轮数。

Day 3 验收清单

理解 Token 是什么，知道中英文 Token 消耗差异
理解 Embedding 是什么，知道它能算语义相似度
理解 Context Window 是什么，知道超出怎么办
token_experiment.py 运行成功，记录了实验数据
embedding_experiment.py 运行成功，看到了相似度数值
notes/day3.md 写完，包含 3 个思考题的答案

Day 4（周四）--- 主流大模型对比与选择

总时长 ：90 分钟 | 难度：低 | 产出：模型选择决策表 + 对比实验

19:00-19:25 ｜主流模型对比（25 分钟）

2026 年主流模型一览（价格随时变，以官方为准）：

模型	厂商	上下文	特点	输入价/百万token	输出价/百万token
GPT-4o	OpenAI	128K	综合最强，多模态	~$2.5 (~¥18)	~$10 (~¥72)
GPT-4o-mini	OpenAI	128K	轻量，便宜 30 倍	~$0.15 (~¥1)	~$0.6 (~¥4)
Claude 3.5 Sonnet	Anthropic	200K	代码强，长文本	~$3 (~¥22)	~$15 (~¥108)
DeepSeek-V3	DeepSeek	64K	性价比极高	~¥1	~¥2
Qwen-Plus	阿里	128K	中文好	~¥0.8	~¥2
GLM-4	智谱	128K	中文理解强	~¥5	~¥5

选模型决策框架（记下来，以后直接用）：

复制代码

你的需求是什么？
├─ 任务复杂度高（推理、代码）→ GPT-4o / Claude 3.5
├─ 成本敏感（大量调用）→ DeepSeek / Qwen
├─ 需要中文好 → DeepSeek / Qwen / GLM
├─ 需要长文本 → Claude 3.5 (200K)
├─ 需要本地部署 → Llama / Qwen 开源版
├─ 需要多模态（图片）→ GPT-4o / Claude 3.5
└─ 快速原型/低延迟 → GPT-4o-mini / DeepSeek

模型命名规则：

gpt-4o：o = Omni，多模态
gpt-4o-mini：轻量版，适合简单任务
claude-3-5-sonnet：Sonnet = 中档（还有 Haiku 轻量、Opus 旗舰）
deepseek-chat vs deepseek-reasoner：对话 vs 推理（类似 o1）

19:25-19:45 ｜同一 Prompt 三模型实测（20 分钟）

测试 Prompt（精心设计，能测出模型差异）：

复制代码

请用 Python 实现一个二分查找函数，要求：
1. 支持查找目标值的位置
2. 如果找不到返回 -1
3. 添加完整的类型注解和文档字符串
4. 写 3 个测试用例

操作步骤：

打开 3 个平台的 Playground/控制台
粘贴同一个 Prompt
截图保存结果

对比维度（填表）：

维度	GPT-4o	DeepSeek	Qwen
代码能跑吗？
有类型注解？
有文档字符串？
有测试用例？
测试用例覆盖全？
响应速度（秒）
Token 消耗
综合评分 /10

19:45-20:30 ｜用代码做自动化对比（45 分钟）

python 复制代码

# code/model_comparison.py
"""自动化模型对比：同一 Prompt 跑多个模型"""
import os
import time
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

# 配置多个模型
models_config = {
    "DeepSeek": {
        "client": OpenAI(
            api_key=os.getenv("DEEPSEEK_API_KEY"),
            base_url="https://api.deepseek.com"
        ),
        "model": "deepseek-chat"
    },
    # 如果有 OpenAI key，取消注释
    # "GPT-4o": {
    #     "client": OpenAI(api_key=os.getenv("OPENAI_API_KEY")),
    #     "model": "gpt-4o"
    # },
    # "GPT-4o-mini": {
    #     "client": OpenAI(api_key=os.getenv("OPENAI_API_KEY")),
    #     "model": "gpt-4o-mini"
    # },
}

test_prompt = """请用 Python 实现一个二分查找函数，要求：
1. 支持查找目标值的位置
2. 如果找不到返回 -1
3. 添加完整的类型注解和文档字符串
4. 写 3 个测试用例

只输出代码，不要解释。"""

print("=" * 60)
print("模型对比实验")
print("=" * 60)

results = {}

for name, config in models_config.items():
    print(f"\n--- 测试 {name} ---")
    
    start_time = time.time()
    
    try:
        response = config["client"].chat.completions.create(
            model=config["model"],
            messages=[{"role": "user", "content": test_prompt}],
            temperature=0,  # 用 0 温度，对比公平
            max_tokens=1000
        )
        
        elapsed = time.time() - start_time
        content = response.choices[0].message.content
        tokens = response.usage
        
        results[name] = {
            "content": content,
            "time": elapsed,
            "prompt_tokens": tokens.prompt_tokens,
            "completion_tokens": tokens.completion_tokens,
            "total_tokens": tokens.total_tokens,
        }
        
        print(f"耗时: {elapsed:.2f}s")
        print(f"Token: {tokens.prompt_tokens} + {tokens.completion_tokens} = {tokens.total_tokens}")
        print(f"\n输出:")
        print(content[:200] + "..." if len(content) > 200 else content)
        
    except Exception as e:
        print(f"错误: {e}")
        results[name] = {"error": str(e)}

# 汇总对比
print("\n" + "=" * 60)
print("对比汇总")
print("=" * 60)
print(f"{'模型':<15} {'耗时':>8} {'输入Token':>10} {'输出Token':>10} {'总Token':>10}")
print("-" * 55)
for name, r in results.items():
    if "error" not in r:
        print(f"{name:<15} {r['time']:>7.2f}s {r['prompt_tokens']:>10} {r['completion_tokens']:>10} {r['total_tokens']:>10}")
    else:
        print(f"{name:<15} {'ERROR':>8}")

运行后：

把每个模型的代码输出复制出来
在本地跑一下，看能不能运行
检查测试用例是否通过
记录到 notes/day4.md

Day 4 验收清单

能说出至少 4 个主流模型的特点和适用场景
有自己的"模型选择决策表"
model_comparison.py 运行成功
记录了至少 2 个模型的代码输出对比
notes/day4.md 写完

Day 5（周五）--- 温度、Top-P 与采样策略

总时长 ：90 分钟 | 难度：中等 | 产出：参数对比实验

19:00-19:15 ｜ Temperature（15 分钟）

核心概念：Temperature 控制输出的"随机性/创意度"。

复制代码

模型生成下一个词时，每个词都有一个概率：
"今天天气很" → 好(0.8) / 棒(0.1) / 差(0.05) / 冷(0.03) ...

Temperature 的作用：
- T=0：永远选概率最高的 → "好"（确定性输出）
- T=0.7：按概率随机选 → 大多选"好"，偶尔选"棒"（平衡）
- T=1.5：概率分布被拉平 → 可能选"冷"（创意但不稳定）

选参建议（背下来）：

场景	推荐 Temperature	理由
代码生成	0 - 0.3	需要准确，不要创意
数据提取/分类	0	完全确定性
对话/摘要	0.5 - 0.7	自然但可控
创意写作	0.8 - 1.2	需要多样性
头脑风暴	1.0 - 1.5	越发散越好

19:15-19:25 ｜ Top-P 和其他参数（10 分钟）

Top-P（核采样）：只从概率累计达到 P 的候选词中采样。

复制代码

P=0.1：只考虑概率最高的少数词 → 输出保守
P=0.9：考虑更多候选词 → 输出多样

注意：通常只调 Temperature 或 Top-P 中的一个，不要同时调。一般用 Temperature 就够了。

其他参数：

max_tokens：最大输出长度（硬限制）
frequency_penalty（-2 到 2）：正值减少重复，负值增加重复
presence_penalty（-2 到 2）：正值鼓励引入新话题
stop：遇到指定字符串时停止生成

19:25-20:30 ｜参数对比实验（65 分钟）

python 复制代码

# code/parameter_experiment.py
"""参数对比实验：同一 Prompt，不同参数组合"""
import os
import time
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com"
)
MODEL = "deepseek-chat"

# 实验设计
prompt = "写一段关于秋天的描写，100 字左右。"

experiments = [
    {"temperature": 0.0, "top_p": 1.0, "label": "T=0 完全确定性", "runs": 3},
    {"temperature": 0.3, "top_p": 1.0, "label": "T=0.3 低随机性", "runs": 3},
    {"temperature": 0.7, "top_p": 1.0, "label": "T=0.7 平衡(默认)", "runs": 3},
    {"temperature": 1.2, "top_p": 1.0, "label": "T=1.2 高创意", "runs": 3},
    {"temperature": 0.7, "top_p": 0.1, "label": "Top-P=0.1 保守", "runs": 2},
    {"temperature": 0.7, "top_p": 0.9, "label": "Top-P=0.9 宽松", "runs": 2},
]

print("=" * 60)
print("参数对比实验")
print("=" * 60)
print(f"Prompt: {prompt}\n")

for exp in experiments:
    print(f"\n{'='*60}")
    print(f"参数: {exp['label']} (T={exp['temperature']}, P={exp['top_p']})")
    print(f"{'='*60}")
    
    outputs = []
    for i in range(exp["runs"]):
        try:
            response = client.chat.completions.create(
                model=MODEL,
                messages=[{"role": "user", "content": prompt}],
                temperature=exp["temperature"],
                top_p=exp["top_p"],
                max_tokens=200,
            )
            content = response.choices[0].message.content
            outputs.append(content)
            print(f"\n--- 第 {i+1} 次 ---")
            print(content)
            print(f"[Token: {response.usage.total_tokens}]")
            
            time.sleep(0.5)  # 避免 API 限流
            
        except Exception as e:
            print(f"错误: {e}")
    
    # 分析输出差异
    if exp["runs"] > 1:
        unique = len(set(outputs))
        print(f"\n>>> {exp['runs']} 次输出中，{unique} 次内容不同")
        if exp["temperature"] == 0.0:
            print(">>> T=0 理论上应该完全相同（可能因 API 实现有微小差异）")

# 场景化参数选择实验
print(f"\n\n{'='*60}")
print("场景化参数选择实验")
print(f"{'='*60}\n")

scenarios = [
    {
        "name": "代码生成",
        "prompt": "写一个 Python 函数，判断一个字符串是否是回文。",
        "temps": [0.0, 0.3, 0.7],
        "advice": "代码需要准确，推荐 T=0-0.3"
    },
    {
        "name": "营销文案",
        "prompt": "为一款智能手表写一句广告语。",
        "temps": [0.5, 0.8, 1.2],
        "advice": "文案需要创意，推荐 T=0.8-1.2"
    },
    {
        "name": "信息提取",
        "prompt": "从'张三，男，28岁，北京人，程序员'中提取姓名、年龄、职业。",
        "temps": [0.0, 0.3, 0.7],
        "advice": "提取需要准确，推荐 T=0"
    },
]

for scenario in scenarios:
    print(f"\n--- 场景: {scenario['name']} ---")
    print(f"建议: {scenario['advice']}\n")
    
    for temp in scenario["temps"]:
        response = client.chat.completions.create(
            model=MODEL,
            messages=[{"role": "user", "content": scenario["prompt"]}],
            temperature=temp,
            max_tokens=200,
        )
        print(f"T={temp}: {response.choices[0].message.content[:100]}...")
        time.sleep(0.5)
    
    print()

运行：

bash 复制代码

python code/parameter_experiment.py

实验后填写：

场景	T=0 效果	T=0.3 效果	T=0.7 效果	T=1.2 效果	最佳选择
代码生成
营销文案
信息提取

Day 5 验收清单

理解 Temperature 控制什么，知道不同场景的推荐值
理解 Top-P 控制什么，知道它和 Temperature 的关系
parameter_experiment.py 运行成功
看到了 T=0 和 T=1.2 输出的明显差异
notes/day5.md 写完，包含场景化选参建议

Day 6（周六）--- 综合实验日（3-4 小时）

目标：把本周学到的所有概念串起来，做 4 组系统实验 + 一个语义搜索 Demo。

09:00-09:45 ｜实验 1: Token 优化（45 分钟）

python 复制代码

# code/token_optimization.py
"""Token 优化实验：怎么用最少的 Token 达到最好效果"""
import tiktoken

enc = tiktoken.encoding_for_model("gpt-4o")

# 实验 1: 中英文 Prompt 的 Token 对比
print("=" * 60)
print("实验 1: 中英文 Prompt Token 对比")
print("=" * 60)

prompts = [
    ("中文", "你是一个专业的翻译助手。请将用户输入的中文翻译成英文。翻译时请注意保持原文的语气和风格，专业术语要准确翻译。"),
    ("英文", "You are a professional translation assistant. Please translate the user's Chinese input into English. Maintain the original tone and style, and translate technical terms accurately."),
    ("中英混合", "You are a 翻译助手. Translate 用户输入 to English. 保持原文语气, 专业术语要准确."),
]

for label, text in prompts:
    tokens = enc.encode(text)
    print(f"\n[{label}]")
    print(f"  文本: {text[:50]}...")
    print(f"  字符数: {len(text)}")
    print(f"  Token数: {len(tokens)}")

# 实验 2: Prompt 压缩
print(f"\n{'='*60}")
print("实验 2: Prompt 压缩对比")
print("=" * 60)

compression_examples = [
    {
        "label": "啰嗦版",
        "prompt": "请你扮演一个资深的Python开发工程师的角色，我需要你帮我写一段代码，这段代码的功能是实现一个快速排序算法，要求代码要有完整的注释说明，并且需要包含错误处理机制，最后还要写几个测试用例来验证代码的正确性。"
    },
    {
        "label": "正常版",
        "prompt": "你是 Python 开发者。写一个快速排序函数，包含注释、错误处理和测试用例。"
    },
    {
        "label": "极简版",
        "prompt": "Write quicksort in Python with comments, error handling, and tests."
    },
]

print(f"\n{'版本':<8} {'Token':>6} {'字符':>6} {'节省':>8}")
print("-" * 35)
base_tokens = None
for ex in compression_examples:
    tokens = enc.encode(ex["prompt"])
    if base_tokens is None:
        base_tokens = len(tokens)
    saved = (1 - len(tokens) / base_tokens) * 100
    print(f"{ex['label']:<8} {len(tokens):>6} {len(ex['prompt']):>6} {saved:>7.1f}%")

# 实验 3: System Prompt 的 Token 开销
print(f"\n{'='*60}")
print("实验 3: System Prompt Token 开销")
print("=" * 60)

system_prompts = [
    ("无", ""),
    ("简单", "你是助手。"),
    ("中等", "你是一个专业的编程助手，擅长 Python。请给出简洁、准确的回答。"),
    ("复杂", """你是一个资深的全栈开发工程师，拥有 10 年以上经验。
你的专长包括 Python、JavaScript、Go、Rust。
回答时请遵循以下规则：
1. 代码必须有类型注解
2. 必须包含错误处理
3. 必须有文档字符串
4. 必须包含测试用例
5. 解释要简洁明了
6. 如果不确定，明确说明"""),
]

for label, sp in system_prompts:
    tokens = enc.encode(sp) if sp else [0]
    print(f"  [{label:<4}] {len(tokens):>4} tokens  | {sp[:40]}...")

实验记录：

中文 Prompt 比英文贵多少倍 token？
压缩 Prompt 能省多少？
复杂 System Prompt 的 token 开销值得吗？

09:45-10:30 ｜实验 2: 模型能力边界（45 分钟）

python 复制代码

# code/model_limits.py
"""模型能力边界测试：什么任务模型擅长，什么不擅长"""
import os
import time
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com"
)
MODEL = "deepseek-chat"

def ask(prompt, temp=0):
    """简单调用"""
    response = client.chat.completions.create(
        model=MODEL,
        messages=[{"role": "user", "content": prompt}],
        temperature=temp,
        max_tokens=500
    )
    return response.choices[0].message.content

# 测试任务列表
tests = [
    {
        "category": "数学计算",
        "prompt": "计算 1234 × 5678 = ?",
        "expected": "7006652",
        "note": "大数乘法，模型可能算错"
    },
    {
        "category": "字符计数",
        "prompt": "在以下文本中，字母 'e' 出现了多少次？\n\n'The quick brown fox jumps over the lazy dog'",
        "expected": "3",
        "note": "字符计数是 LLM 的弱项"
    },
    {
        "category": "逻辑推理",
        "prompt": "小明比小红高，小红比小华高，小华比小明高。这个说法有问题吗？如果有，问题在哪？",
        "expected": "有矛盾，传递性不成立",
        "note": "简单逻辑推理"
    },
    {
        "category": "常识",
        "prompt": "如果把一块冰放在太阳下，会发生什么？",
        "expected": "融化",
        "note": "基本常识"
    },
    {
        "category": "代码理解",
        "prompt": "以下代码的输出是什么？\n\n```python\nx = [1, 2, 3]\ny = x\ny.append(4)\nprint(x)\n```",
        "expected": "[1, 2, 3, 4]",
        "note": "Python 引用语义"
    },
    {
        "category": "长文本记忆",
        "prompt": "记住这个数字：8392。现在从1数到10。数完后，告诉我你记住的数字。",
        "expected": "8392",
        "note": "测试注意力机制"
    },
]

print("=" * 60)
print("模型能力边界测试")
print("=" * 60)

for test in tests:
    print(f"\n--- {test['category']} ---")
    print(f"问题: {test['prompt'][:60]}...")
    print(f"预期: {test['expected']}")
    print(f"说明: {test['note']}")
    
    answer = ask(test["prompt"])
    print(f"回答: {answer}")
    
    time.sleep(0.5)

print(f"\n{'='*60}")
print("分析总结")
print("=" * 60)
print("""
记录你的发现：
1. 模型在哪些任务上可靠？
2. 模型在哪些任务上容易出错？
3. 出错时怎么弥补？（提示：Function Calling、外部工具）
""")

10:30-11:30 ｜实验 3: 语义搜索 Demo（60 分钟）

这是本周最重要的实验------它是 RAG 的雏形，第 4 个月会深入。

python 复制代码

# code/semantic_search_demo.py
"""简易语义搜索：用 Embedding 实现文本检索（RAG 雏形）"""
import os
import numpy as np
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

# 需要用支持 Embedding 的 API
# 方案 A: OpenAI
# client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
# EMBEDDING_MODEL = "text-embedding-3-small"

# 方案 B: 阿里百炼（国内推荐）
client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)
EMBEDDING_MODEL = "text-embedding-v3"

def get_embedding(text):
    """获取文本的 Embedding 向量"""
    resp = client.embeddings.create(model=EMBEDDING_MODEL, input=text)
    return resp.data[0].embedding

def cosine_sim(a, b):
    """余弦相似度"""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# 知识库：20 条关于编程的句子
knowledge_base = [
    "Python 是一种解释型高级编程语言，以简洁易读著称",
    "JavaScript 是网页交互的核心语言，运行在浏览器中",
    "Java 是面向对象的跨平台语言，广泛用于企业级开发",
    "Git 是分布式版本控制系统，用于跟踪代码变更",
    "Docker 是容器化部署工具，实现环境一致性",
    "REST API 使用 HTTP 协议进行通信，是无状态的",
    "SQL 是关系型数据库的查询语言",
    "React 是 Facebook 开发的前端 UI 框架",
    "Kotlin 是 Android 官方推荐的编程语言",
    "Rust 注重内存安全和并发性能，无垃圾回收",
    "机器学习是让计算机从数据中学习模式",
    "深度学习使用多层神经网络进行学习",
    "自然语言处理研究计算机理解和生成人类语言",
    "计算机视觉让机器能看懂图片和视频",
    "强化学习通过奖励信号学习最优策略",
    "向量数据库专门存储和检索高维向量，如 Pinecone",
    "微服务架构将应用拆分为独立的小服务",
    "CI/CD 是持续集成和持续部署的缩写",
    "函数式编程强调纯函数和不可变性",
    "敏捷开发是迭代增量的软件开发方法",
]

# 预计算知识库 Embedding
print("正在计算知识库 Embedding...")
kb_embeddings = []
for text in knowledge_base:
    emb = get_embedding(text)
    kb_embeddings.append((text, emb))
    print(f"  ✓ {text[:30]}...")

print(f"\n完成！共 {len(kb_embeddings)} 条知识\n")

# 交互式搜索
print("=" * 60)
print("语义搜索引擎（输入 q 退出）")
print("=" * 60)

test_queries = [
    "怎么管理代码版本",
    "手机 App 开发用什么语言",
    "AI 相关的技术",
    "数据库查询",
    "怎么部署应用",
]

# 先跑预设查询
for query in test_queries:
    print(f"\n搜索: '{query}'")
    print("-" * 50)
    
    query_emb = get_embedding(query)
    results = [(text, cosine_sim(query_emb, emb)) for text, emb in kb_embeddings]
    results.sort(key=lambda x: x[1], reverse=True)
    
    for i, (text, score) in enumerate(results[:3], 1):
        bar = "█" * int(score * 30)
        print(f"  {i}. [{score:.4f}] {bar}")
        print(f"     {text}")

# 交互搜索
print("\n" + "=" * 60)
while True:
    query = input("\n输入搜索词（q 退出）: ").strip()
    if query.lower() == 'q' or not query:
        break
    
    query_emb = get_embedding(query)
    results = [(text, cosine_sim(query_emb, emb)) for text, emb in kb_embeddings]
    results.sort(key=lambda x: x[1], reverse=True)
    
    print(f"\n搜索: '{query}'")
    print("-" * 50)
    for i, (text, score) in enumerate(results[:5], 1):
        bar = "█" * int(score * 30)
        print(f"  {i}. [{score:.4f}] {bar}")
        print(f"     {text}")

print("\n再见！")

运行后思考：

搜"怎么管理代码版本"------能找到"Git 是分布式版本控制系统"吗？（预期：能）
搜"手机 App 开发"------能找到 Kotlin 相关的吗？
搜索词和结果没有共同关键词时，还能匹配吗？（预期：能，这就是语义搜索的威力）
这个能力可以用来做什么？（提示：知识库问答、智能客服、文档搜索）

11:30-12:00 ｜实验 4: 参数调优实战（30 分钟）

回到 Day 5 的参数实验，这次用不同场景：

python 复制代码

# code/param_tuning.py
"""参数调优实战：为不同任务找到最佳参数"""
import os
import time
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com"
)
MODEL = "deepseek-chat"

def ask(prompt, temp=0.7, max_tokens=300):
    response = client.chat.completions.create(
        model=MODEL,
        messages=[{"role": "user", "content": prompt}],
        temperature=temp,
        max_tokens=max_tokens
    )
    return response.choices[0].message.content

# 场景 A: JSON 数据提取
print("=" * 60)
print("场景 A: JSON 数据提取")
print("=" * 60)

extract_prompt = """从以下商品描述中提取信息，输出 JSON：
"华为 Mate 60 Pro，12GB+512GB，售价 6999 元，支持卫星通话"

JSON 格式：{"brand": "", "model": "", "price": 0, "features": []}"""

for temp in [0.0, 0.3, 0.7]:
    result = ask(extract_prompt, temp=temp)
    print(f"\nT={temp}: {result}")
    time.sleep(0.5)

# 场景 B: 创意文案
print(f"\n{'='*60}")
print("场景 B: 创意文案")
print("=" * 60)

creative_prompt = "为一款 AI 编程助手写一句广告语，要有创意。"

for temp in [0.3, 0.8, 1.2]:
    result = ask(creative_prompt, temp=temp)
    print(f"\nT={temp}: {result}")
    time.sleep(0.5)

# 场景 C: 代码生成
print(f"\n{'='*60}")
print("场景 C: 代码生成")
print("=" * 60)

code_prompt = "用 Python 写一个函数，判断字符串是否是回文。"

for temp in [0.0, 0.5, 1.0]:
    result = ask(code_prompt, temp=temp)
    print(f"\nT={temp}:")
    print(result)
    time.sleep(0.5)

填写结论表：

场景	T=0	T=0.3-0.5	T=0.7-1.0	T=1.0+	推荐
JSON 提取
创意文案
代码生成

Day 6 验收清单

4 组实验全部完成
token_optimization.py 记录了 Token 节省数据
model_limits.py 测试了至少 6 种任务
semantic_search_demo.py 运行成功，尝试了至少 5 个搜索词
param_tuning.py 完成了 3 个场景的参数对比
notes/day6_experiments.md 写完，包含所有实验结论

Day 7（周日）--- 写笔记 + 知识梳理（2-3 小时）

09:00-09:30 ｜回顾梳理（30 分钟）

操作步骤：

翻看 Day 1-6 的笔记（notes/day1.md 到 day6_experiments.md）
在纸上画一张知识地图，标注概念之间的关系
用三种颜色标记：
- 绿色：完全理解了
- 黄色：大概理解，但说不清楚
- 红色：还不理解

自测问答（能回答就过关）：

LLM 和传统 NLP 的本质区别是什么？
Transformer 的 Attention 机制解决什么问题？
Token 是什么？为什么中文比英文贵？
Embedding 是什么？它有什么用？
Context Window 是什么？超出怎么办？
GPT-4o 和 DeepSeek 各适合什么场景？
Temperature=0 和 Temperature=1 的输出有什么区别？
模型在哪些任务上不可靠？怎么弥补？

09:30-11:00 ｜写技术笔记（90 分钟）

推荐标题（选一个）：

「LLM 核心概念速通：程序员需要知道的一切」
「搞懂 Token、Embedding、Context Window：AI 开发第一课」
「我花 7 天搞懂了大语言模型的基础，这是我的笔记」

文章结构：

markdown 复制代码

## 前言
为什么程序员需要理解 LLM 原理（不只是调 API）
一句话点出文章价值

## 1. LLM 是什么
- 一句话定义
- AI > ML > DL > NLP > LLM 的关系
- GPT 演进时间线（配表）
- 预训练 + 微调 + RLHF 三步走

## 2. Transformer：LLM 的大脑
- Attention 要解决什么问题
- Q/K/V 的直觉理解（用搜索类比）
- GPT 是 Decoder-only，预测下一个词

## 3. 三个核心概念（本文重点）

### 3.1 Token：LLM 的"货币"
- 什么是 Token
- 中英文 Token 差异（附你的实验数据）
- Token 影响成本和速度
- Prompt 压缩技巧

### 3.2 Embedding：让文字变成数字
- 直觉理解
- 语义相似度实验（附代码和结果截图）
- 这是 RAG 和语义搜索的基础

### 3.3 Context Window：LLM 的"工作记忆"
- 不同模型的窗口大小
- 超出窗口怎么办
- 成本与窗口的 tradeoff

## 4. 模型选择实战
- 主流模型对比表（附你的实测数据）
- 选模型决策框架
- 同一 Prompt 三模型对比（附截图）

## 5. 参数调优
- Temperature 的直觉理解
- 不同场景的推荐参数（附实验数据）
- Top-P 和其他参数

## 6. 模型的能力边界
- 擅长什么（附实验）
- 不擅长什么（附实验）
- 什么时候该用工具增强

## 总结
- 一周学习心得
- 下周学什么（Prompt Engineering）

写作技巧：

每个概念先给"一句话解释"，再展开
配实验数据比配理论更有说服力
用你自己的话写，不要复制文档
代码示例确保能跑通

11:00-11:30 ｜发布前检查（30 分钟）

代码示例都能跑通（复制出来本地跑一遍）
实验数据是真实的（不是编的）
有自己的思考和心得（不是纯搬运）
截图清晰（终端输出截图比纯文字好）
排版整洁（Markdown 格式正确）
标题吸引人但不标题党

本周产出清单

6 个实验脚本（上传 GitHub）
- hello_llm.py
- token_experiment.py
- embedding_experiment.py
- model_comparison.py
- parameter_experiment.py
- semantic_search_demo.py
- token_optimization.py
- model_limits.py
- param_tuning.py
1 个语义搜索 Demo
1 篇可发布的技术笔记
notes/ 目录有 7 天的每日笔记
GitHub 仓库创建，代码推送

下周预告

Week 2 学 Prompt Engineering：

Zero-shot / Few-shot / Chain-of-Thought 三种模式
结构化 Prompt 设计框架
高级技巧（Self-Consistency、ReAct）
Prompt 安全与注入防御
构建自己的 Prompt 模板库

附录：本周所有代码文件清单

文件	对应 Day	核心知识点
`hello_llm.py`	Day 1	API 基础调用
`token_experiment.py`	Day 3	Token 计数、中英文对比
`embedding_experiment.py`	Day 3	Embedding、语义相似度
`model_comparison.py`	Day 4	多模型对比
`parameter_experiment.py`	Day 5	Temperature/Top-P 实验
`token_optimization.py`	Day 6	Token 压缩技巧
`model_limits.py`	Day 6	模型能力边界测试
`semantic_search_demo.py`	Day 6	语义搜索（RAG 雏形）
`param_tuning.py`	Day 6	场景化参数选择

附录：推荐资源汇总

类型	资源	说明
视频	3Blue1Brown「But what is a GPT?」	Transformer 直觉理解
文章	Jay Alammar「The Illustrated Transformer」	图解 Attention
视频	Karpathy「Let's build GPT from scratch」	硬核，可选
文档	OpenAI Cookbook	官方代码示例集
文档	DeepSeek API 文档	国内模型 API 参考
工具	tiktoken (Python 库)	Token 计数
工具	OpenAI Playground	在线测试 Prompt

AI 智能体开发第一月 · Week 1 逐小时执行手册