Deep Rl Course

嘿，欢迎来到深度强化学习的世界！别被名字吓到，其实它没那么神秘。说白了，强化学习就是让机器像人一样“试错学习”——做对了给奖励，做错了给惩罚，慢慢它就学会怎么做事了。

咱们直接上干货，看看怎么用 Hugging Face 的课程跑第一个例子。

核心概念先搞懂：
1）Agent（智能体）：就是那个要学习的“机器人”。2）Environment（环境）：它待的世界，比如一个游戏画面。3）Action（动作）：它能做的事，比如左移、右移。4）Reward（奖励）：每做一步，环境给它的分数。5）Policy（策略）：它脑子里的决策规则。

实操步骤（用 Hugging Face 的 Gymnasium 库）：
1）打开你的 Python 环境（推荐用 Google Colab，国内能访问，还免费）。
2）安装库：在代码框里输入 `!pip install gymnasium`，然后运行。
3）创建环境：输入 `import gymnasium as gym`，再加 `env = gym.make("CartPole-v1")`。这个 CartPole 是个经典游戏——一根杆子立在车上，你要左右移动车不让杆子倒。
4）看看环境长啥样：运行 `print(env.observation_space)` 和 `print(env.action_space)`。你会看到杆子的状态（位置、速度等）和动作（左或右）。
5）让智能体随机动一下：写个循环。
```python
import gymnasium as gym
env = gym.make("CartPole-v1")
obs, info = env.reset()
for _ in range(100):
action = env.action_space.sample() # 随机选动作
obs, reward, done, truncated, info = env.step(action)
env.render()
if done:
break
env.close()
```
6）运行看看。你会看到一个窗口（在 Colab 里可能要用 `env.render_mode="rgb_array"` 配合显示），杆子很快倒了——因为智能体是瞎蒙的。

实用技巧：
- 国内访问 Hugging Face 模型慢？可以用镜像站 `https://hf-mirror.com`，或者直接用 Colab 自带的库。
- 每次跑完记得 `env.close()` 释放资源，不然会报错。
- 别被“深度”吓到，先理解“试错”这个核心，后面深度学习只是给它加了个“大脑”。

这一章你只要跑通上面的代码，就赢了。下一章我们来教这个智能体怎么“学”。

好，现在咱们让智能体真正“学”起来。最经典的方法就是 Q-Learning，它像个小账本，记下每个状态下做什么动作能得多少分。

想象你玩一个游戏，每次走一步，脑子里记下“这个路口往右走能得10分”。Q-Learning 就是帮机器记这个账本（Q表）。核心公式：Q(s,a) = Q(s,a) + α * [r + γ * max(Q(s',a')) - Q(s,a)]。别慌，拆开看：
- Q(s,a)：当前状态下做动作a的预期分数。
- α：学习率，学得快慢（0到1）。
- r：刚拿到的奖励。
- γ：折扣因子，看重眼前还是长远（0到1）。
- max(Q(s',a'))：下一步能拿到的最高分。

实操：用 FrozenLake 环境（冰湖游戏，格子世界，走到目标得1分，掉坑里就输）。
1）安装并导入：`!pip install gymnasium`，然后 `import gymnasium as gym`。
2）创建环境：`env = gym.make("FrozenLake-v1", is_slippery=False)`。`is_slippery=False` 表示冰面不滑，简单模式。
3）初始化 Q 表：用 numpy 搞个全零矩阵。
```python
import numpy as np
Q = np.zeros([env.observation_space.n, env.action_space.n])
```
4）设置参数：`alpha = 0.1`, `gamma = 0.99`, `epsilon = 1.0`（探索率，一开始多尝试）。
5）训练循环（跑5000轮）：
```python
for episode in range(5000):
state, info = env.reset()
done = False
while not done:
if np.random.uniform(0, 1) < epsilon:
action = env.action_space.sample() # 探索
else:
action = np.argmax(Q[state, :]) # 利用Q表
new_state, reward, done, truncated, info = env.step(action)
# 更新Q表
Q[state, action] = Q[state, action] + alpha * (reward + gamma * np.max(Q[new_state, :]) - Q[state, action])
state = new_state
epsilon = max(0.01, epsilon * 0.995) # 慢慢减少探索
```
6）测试：跑100轮看成功率。
```python
successes = 0
for _ in range(100):
state, info = env.reset()
done = False
while not done:
action = np.argmax(Q[state, :])
state, reward, done, truncated, info = env.step(action)
if reward == 1:
successes += 1
print(f"成功率: {successes}%")
```

实用技巧：
- 如果成功率低，调大 `episode` 数或 `alpha`。
- 国内用 Colab 注意：`gymnasium` 包可能需要 `!pip install gymnasium[toy-text]` 才能用 FrozenLake。
- 试试把 `is_slippery=True`，你会看到难度飙升——因为环境有随机性，Q-Learning 就吃力了，这时候该深度学习上场。

跑通了？恭喜！你已经手写了一个经典强化学习算法。下一章我们升级到深度 Q 网络（DQN）。

上一章的 Q-Learning 在复杂任务（比如游戏画面）上会崩溃，因为状态太多了，Q表存不下。这时候就用神经网络代替 Q 表——这就是深度 Q 网络（DQN）。

DQN 的核心：用神经网络输入状态（比如像素），输出每个动作的 Q 值。两个关键技巧：经验回放（存下经历，随机抽取训练）+ 目标网络（冻结一个网络，稳定训练）。

咱们用 Hugging Face 的 Stable-Baselines3 库，它封装好了 DQN，直接调用。

实操：训练一个智能体玩 CartPole。
1）安装库：`!pip install stable-baselines3`（国内用镜像 `!pip install -i https://pypi.tuna.tsinghua.edu.cn/simple stable-baselines3`）。
2）导入并创建环境：
```python
import gymnasium as gym
from stable_baselines3 import DQN
env = gym.make("CartPole-v1")
```
3）定义模型并训练：
```python
model = DQN("MlpPolicy", env, verbose=1, learning_rate=0.001, buffer_size=50000, batch_size=64)
model.learn(total_timesteps=20000) # 训练2万步
```
4）保存模型：`model.save("dqn_cartpole")`。
5）加载并测试：
```python
model = DQN.load("dqn_cartpole")
obs, info = env.reset()
for _ in range(500):
action, _states = model.predict(obs, deterministic=True)
obs, reward, done, truncated, info = env.step(action)
env.render()
if done:
break
env.close()
```
6）看效果：杆子应该能立很久了！

如果你想深入，可以自己写 DQN（不用库）：
```python
import torch
import torch.nn as nn
import torch.optim as optim
import random
from collections import deque

# 定义神经网络
class DQNNet(nn.Module):
def __init__(self, state_dim, action_dim):
super().__init__()
self.fc = nn.Sequential(
nn.Linear(state_dim, 128),
nn.ReLU(),
nn.Linear(128, 128),
nn.ReLU(),
nn.Linear(128, action_dim)
)
def forward(self, x):
return self.fc(x)

# 经验回放缓存
replay_buffer = deque(maxlen=50000)
# 初始化网络
state_dim = env.observation_space.shape[0]
action_dim = env.action_space.n
policy_net = DQNNet(state_dim, action_dim)
target_net = DQNNet(state_dim, action_dim)
target_net.load_state_dict(policy_net.state_dict())
optimizer = optim.Adam(policy_net.parameters(), lr=0.001)
```

实用技巧：
- 训练时 `verbose=1` 会显示进度，方便调试。
- 如果训练不稳定，调小 `learning_rate` 或增大 `buffer_size`。
- 国内用 PyTorch 的话，安装命令是 `!pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu`（CPU版，够用）。

跑通这个，你已经入门深度强化学习了。下一章我们玩点更酷的——用预训练模型做项目。

前面学了理论，现在咱们做个能拿得出手的项目：用 Hugging Face 的预训练模型，让 AI 玩 Atari 游戏（比如 Breakout 打砖块）。

咱们直接用 Hugging Face Hub 上的模型，不用从头训练（省时间）。重点：学会加载别人的模型，然后自己测试、修改。

实操步骤：
1）安装依赖（国内用户用镜像）：
```bash
!pip install -i https://pypi.tuna.tsinghua.edu.cn/simple gymnasium[atari] gymnasium[accept-rom-license] stable-baselines3 huggingface_hub
```
2）从 Hugging Face Hub 下载模型（用镜像站）：
```python
import os
os.environ["HF_ENDPOINT"] = "https://hf-mirror.com" # 国内镜像
from huggingface_hub import hf_hub_download
# 下载一个训练好的 Breakout 模型（来自用户 "sb3"）
model_path = hf_hub_download(repo_id="sb3/dqn-BreakoutNoFrameskip-v4", filename="dqn-BreakoutNoFrameskip-v4.zip")
```
3）加载模型并创建环境：
```python
from stable_baselines3 import DQN
import gymnasium as gym
env = gym.make("BreakoutNoFrameskip-v4", render_mode="rgb_array")
model = DQN.load(model_path)
```
4）让 AI 玩游戏并记录分数：
```python
obs, info = env.reset()
total_reward = 0
for step in range(10000):
action, _ = model.predict(obs, deterministic=True)
obs, reward, done, truncated, info = env.step(action)
total_reward += reward
# 在 Colab 里显示画面（每10步）
if step % 10 == 0:
from IPython.display import clear_output, display
import matplotlib.pyplot as plt
clear_output(wait=True)
plt.imshow(env.render())
plt.axis('off')
display(plt.gcf())
if done:
break
print(f"游戏结束，总分: {total_reward}")
env.close()
```
5）如果没画面，用 `env.render()` 保存为 GIF 也行：
```python
import imageio
frames = []
obs, info = env.reset()
for _ in range(1000):
action, _ = model.predict(obs, deterministic=True)
obs, reward, done, truncated, info = env.step(action)
frames.append(env.render())
if done:
break
imageio.mimsave('breakout.gif', frames, fps=30)
```

实用技巧：
- 国内下载模型慢？用 `hf-mirror.com` 镜像，或者在 Hugging Face 官网手动下载 `.zip` 文件后上传到 Colab。
- 如果报错 `ROM is missing`，运行 `!pip install gymnasium[accept-rom-license]` 并同意许可。
- 想换游戏？去 Hugging Face Hub 搜 `sb3/` 开头的模型，比如 `sb3/dqn-SpaceInvadersNoFrameskip-v4`，把名字换掉就行。