强化学习入门教程

1 强化学习入门教程：像教小孩走路一样搞懂AI

不用记公式、不用懂代码，咱们用教小孩学走路这个事儿，把强化学习讲得明明白白。

一、强化学习的本质：试错中找甜头

先想一个场景：你家刚会爬的小宝宝，想自己站起来走路。

宝宝（咱们叫它 智能体）一开始啥也不会，只能瞎晃、摔跤；
它站了1秒没倒，你拍手夸它、给颗糖（奖励）；
它一屁股摔地上哭了，你没给糖，还得哄它（惩罚/无奖励）；
试了几百次后，宝宝慢慢摸清了门道：“站稳=有糖，乱晃=摔跤”，最后稳稳学会走路。

强化学习的核心，就是智能体在环境里瞎试，通过“奖励/惩罚”的反馈，慢慢学会最划算的做事方法。
这和你训练小狗握手、玩贪吃蛇游戏AI躲墙，逻辑一模一样。

二、5个核心词：用带娃场景翻译

别被专业术语吓到，对应带娃场景，秒懂：

强化学习术语	带娃场景对应	人话解释
智能体（Agent）	学走路的宝宝	那个“正在学习、正在做事”的主角，可能是AI、机器人，甚至是人
环境（Environment）	家里的客厅	智能体待的地方，会对它的动作给出反应（比如宝宝站稳，你给糖）
动作（Action）	宝宝“站、晃、走”	智能体在环境里能做的事
奖励（Reward）	给宝宝的糖、夸奖	环境给的“好处”，鼓励智能体多做这个动作
策略（Policy）	宝宝“站稳再迈步”的经验	智能体学到的“最优做事方法”，照着做能拿最多奖励

三、强化学习的“学习流程”：就4步

还是拿宝宝学走路举例，AI的学习过程完全复刻这个逻辑：

随机乱试：宝宝一开始手脚乱蹬，一会儿站一会儿坐，完全没章法（AI初期也是随机选动作）；
接收反馈：站稳→得糖（正反馈），摔跤→没糖还疼（负反馈）；
更新经验：宝宝记住“慢慢站比猛站不容易摔，还能拿糖”，AI也会更新自己的“策略”，下次更倾向选能拿奖励的动作；
反复优化：试几百、几万次后，宝宝能稳稳走路，AI也能稳定拿到最高奖励（比如贪吃蛇不撞墙、打游戏赢对手）。

这里要划重点：AI不会“思考”！它不像人一样懂“走路是为了去玩玩具”，它只知道“这么做能拿更多奖励”，纯粹是“趋利避害”的机械优化。

四、生活里的强化学习：到处都是

别觉得这是高科技，咱们天天都在接触：

短视频推荐：你点赞的视频（奖励），APP就多推同类；你划走的视频（无奖励），就少推——APP就是在强化学习你的喜好；
王者荣耀人机：人机打多了会越来越精，因为它拿人头（奖励）、送人头（惩罚），慢慢学会蹲草、躲技能；
你自己学骑车：摔一次（惩罚）就记住“转弯别太猛”，顺利骑10米（奖励）就记住“握把要稳”——这就是“人类版强化学习”。

五、入门避坑：3个常见误区

误区1：得懂高数才能学？
错！先搞懂“试错-反馈-优化”这个核心逻辑，数学是后面深化用的，入门看例子就行；
误区2：AI学会了就不会忘？
错！如果环境变了（比如宝宝换了个滑溜溜的地板），之前的经验就不好使了，得重新学——这叫“泛化能力”，是强化学习的一大难点；
误区3：学了就能做机器人？
错！强化学习是基础逻辑，想做实际应用，还得学Python编程、用OpenAI Gym这类练习框架，但先懂了核心，后面学啥都顺。

最后总结

强化学习一点都不玄乎，就是让智能体在环境里“瞎折腾”，用奖励当“诱饵”，让它慢慢摸出最赚钱的做事套路。
就像教小孩、训宠物，耐心给反馈，它总能学会你想要的技能。

2 强化学习入门小实验：用Python练手（超通俗，0基础也能跑）

咱们不搞复杂公式，直接用「贪吃蛇简化版」「走迷宫」这两个最经典的小实验，把强化学习的核心逻辑落地。先讲思路，再给能直接复制的代码，跟着做一遍，你就能直观感受到AI是怎么“试错学东西”的。

第一步：准备工具（5分钟搞定）

强化学习入门最常用的练手框架是 OpenAI Gym（专门做各种虚拟环境，比如迷宫、赛车、贪吃蛇），先装两个必备工具：

1. 安装Python（如果没装）

去官网https://www.python.org/下载3.8~3.10版本（兼容性最好），安装时勾上“Add Python to PATH”。

2. 安装Gym和基础库

打开电脑的「命令提示符」（Windows）或「终端」（Mac/Linux），复制粘贴这两行，按回车：

pip install gym==0.26.2  # 固定版本，避免兼容问题
pip install numpy matplotlib  # 数值计算+画图（看学习过程）

如果装的时候报错，大概率是网络问题，加个国内镜像：

pip install gym==0.26.2 numpy matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple

第二步：实验1：走迷宫（最易理解的强化学习入门）

实验逻辑

智能体：一个小方块（在迷宫里走）
环境：5x5的迷宫，有墙、起点、终点（终点给+10奖励，撞墙给-5惩罚，走一步给-0.1惩罚（鼓励少走路））
目标：AI试几千次后，能从起点最快走到终点，不撞墙。

代码（直接复制就能跑）

新建一个文本文件，改名为maze_ql.py（后缀从txt改成py），把下面代码粘进去：

import numpy as np
import matplotlib.pyplot as plt

# 1. 定义迷宫环境（5x5网格）
# 0=空地，1=墙，2=起点，3=终点
maze = np.array([
    [2, 0, 1, 0, 0],
    [0, 1, 0, 1, 0],
    [0, 0, 0, 1, 0],
    [1, 1, 0, 0, 0],
    [0, 0, 1, 0, 3]
])
# 动作：0=上，1=下，2=左，3=右
actions = [0, 1, 2, 3]
# Q表：记录「状态（位置）-动作」的价值，初始全0（AI一开始啥都不懂）
q_table = np.zeros((5*5, 4))  # 5x5个位置，每个位置4个动作

# 2. 核心参数（不用改，先跑）
learning_rate = 0.1    # 学习率（AI更新经验的速度）
gamma = 0.9            # 折扣因子（重视未来奖励：比如“走两步到终点”比“当下没奖励”更重要）
epsilon = 0.9          # 探索率（90%选已知好动作，10%随机试新动作，避免死脑筋）
episodes = 2000        # 训练次数（试2000次迷宫）

# 3. 找当前位置（状态）
def get_state(pos):
    return pos[0] * 5 + pos[1]

# 4. 执行动作，返回新位置和奖励
def step(pos, action):
    x, y = pos
    # 执行动作
    if action == 0: x -= 1  # 上
    elif action == 1: x += 1  # 下
    elif action == 2: y -= 1  # 左
    elif action == 3: y += 1  # 右
    
    # 判断边界（出迷宫=不动）
    x = max(0, min(x, 4))
    y = max(0, min(y, 4))
    
    # 判断是否撞墙（不动）
    if maze[x][y] == 1:
        return (x, y), -5  # 撞墙：位置不变，奖励-5
    # 判断是否到终点
    elif maze[x][y] == 3:
        return (x, y), 10  # 终点：奖励+10
    # 普通空地
    else:
        return (x, y), -0.1  # 走一步：奖励-0.1（鼓励少走）

# 5. 训练AI
rewards_history = []  # 记录每次训练的总奖励（看学习效果）
for episode in range(episodes):
    # 每次训练：回到起点（0,0）
    pos = (0, 0)
    total_reward = 0
    done = False
    
    while not done:
        state = get_state(pos)
        # 选动作：90%选Q表中最好的，10%随机试新的
        if np.random.uniform(0, 1) < epsilon:
            action = np.argmax(q_table[state])  # 选已知最优动作
        else:
            action = np.random.choice(actions)  # 随机探索
        
        # 执行动作，拿反馈
        new_pos, reward = step(pos, action)
        new_state = get_state(new_pos)
        total_reward += reward
        
        # 更新Q表（核心：强化学习的“经验更新”）
        # Q(s,a) = Q(s,a) + 学习率*(奖励 + 折扣*未来最优Q - 当前Q)
        q_table[state][action] += learning_rate * (reward + gamma * np.max(q_table[new_state]) - q_table[state][action])
        
        # 更新位置
        pos = new_pos
        
        # 判断是否结束（到终点或撞墙太多）
        if maze[pos[0]][pos[1]] == 3:  # 到终点，结束
            done = True
        if total_reward < -100:  # 撞墙太多，放弃本次训练
            done = True
    
    rewards_history.append(total_reward)
    # 每100次打印一次进度
    if (episode + 1) % 100 == 0:
        print(f"第{episode+1}次训练，总奖励：{total_reward:.1f}")

# 6. 画学习曲线（看AI是不是越学越好）
plt.plot(rewards_history)
plt.xlabel("训练次数")
plt.ylabel("每次训练总奖励")
plt.title("AI走迷宫的学习过程（奖励越高越好）")
plt.show()

# 7. 测试：看AI学会的最优路径
print("\nAI学会的最优路径：")
pos = (0, 0)
path = [pos]
while maze[pos[0]][pos[1]] != 3:
    state = get_state(pos)
    action = np.argmax(q_table[state])  # 选最优动作
    pos, _ = step(pos, action)
    path.append(pos)
print(path)

怎么跑代码

保存好maze_ql.py；
打开命令提示符/终端，进入文件所在的文件夹（比如文件在桌面，输入cd Desktop）；
输入python maze_ql.py，按回车。

看结果（关键！理解AI怎么学）

控制台输出：前几百次训练的总奖励是负数（AI乱撞墙），后面慢慢变成正数（能到终点）；
学习曲线：画图窗口里，曲线从低往高走——说明AI越练越会走迷宫；
最优路径：最后打印的坐标列表，就是AI学出来的“最快到终点的路”。

核心逻辑拆解（对应之前的“带娃”逻辑）

Q表 = 宝宝的“经验本”：记录“在某个位置，往哪个方向走更划算”；
选动作 = 宝宝“有时按经验走，有时瞎试”：90%按Q表（经验），10%随机（试错）；
更新Q表 = 宝宝“记住对错”：拿到奖励/惩罚后，更新“经验本”，下次更会选。

第三步：实验2：玩Gym自带的小游戏（CartPole，推车杆）

如果想玩更现成的环境，试试Gym自带的“推车杆”——目标是让小推车顶着杆子不倒下，AI通过左右推小车学平衡。

代码（直接复制）

新建cartpole_ql.py，粘入：

import gym
import numpy as np
import matplotlib.pyplot as plt

# 1. 创建环境（推车杆）
env = gym.make('CartPole-v1')
# 离散化状态（把连续的位置/速度，变成离散的区间，方便Q表存储）
def discretize_state(state, bins=10):
    cart_pos = np.digitize(state[0], np.linspace(-4.8, 4.8, bins))
    cart_vel = np.digitize(state[1], np.linspace(-3, 3, bins))
    pole_ang = np.digitize(state[2], np.linspace(-0.418, 0.418, bins))
    pole_vel = np.digitize(state[3], np.linspace(-3, 3, bins))
    return (cart_pos, cart_vel, pole_ang, pole_vel)

# 2. 初始化Q表
bins = 10
q_table = np.zeros((bins, bins, bins, bins, 2))  # 4个状态维度，2个动作（左/右）

# 3. 训练参数
learning_rate = 0.1
gamma = 0.95
epsilon = 0.9
episodes = 500
scores = []  # 记录每次坚持的步数（杆子不倒的步数）

# 4. 训练
for episode in range(episodes):
    state = env.reset()[0]  # 重置环境，获取初始状态
    discrete_state = discretize_state(state, bins)
    done = False
    score = 0
    
    while not done:
        # 选动作
        if np.random.uniform(0, 1) < epsilon:
            action = np.argmax(q_table[discrete_state])
        else:
            action = env.action_space.sample()  # 随机选动作
        
        # 执行动作
        new_state, reward, done, _, _ = env.step(action)
        new_discrete_state = discretize_state(new_state, bins)
        score += 1
        
        # 更新Q表
        if not done:
            q_table[discrete_state][action] += learning_rate * (reward + gamma * np.max(q_table[new_discrete_state]) - q_table[discrete_state][action])
        else:
            # 杆子倒了，惩罚
            q_table[discrete_state][action] += learning_rate * (-100 - q_table[discrete_state][action])
        
        discrete_state = new_discrete_state
    
    scores.append(score)
    # 慢慢减少探索率（越学越成熟，少瞎试）
    epsilon = max(0.1, epsilon - 0.001)
    
    if (episode + 1) % 50 == 0:
        print(f"第{episode+1}次训练，坚持了{score}步")

# 5. 画学习曲线
plt.plot(scores)
plt.xlabel("训练次数")
plt.ylabel("杆子不倒的步数（越高越好）")
plt.title("AI推小车的学习过程")
plt.show()

# 6. 可视化测试（看AI玩）
env = gym.make('CartPole-v1', render_mode='human')
state = env.reset()[0]
done = False
while not done:
    discrete_state = discretize_state(state, bins)
    action = np.argmax(q_table[discrete_state])
    state, _, done, _, _ = env.step(action)
    env.render()  # 显示游戏画面
env.close()

跑代码的结果

训练时：前几十次AI只能坚持几步（杆子秒倒），训练几百次后能坚持几百步（杆子稳稳的）；
测试时：会弹出一个小窗口，能看到小车左右移动，杆子一直不倒——这就是AI学出来的“平衡策略”！

第四步：实验后必懂的2个核心点（帮你举一反三）

Q-learning（咱们用的方法）的本质：
就是给AI一个“经验本（Q表）”，记录「在某个状态下，做某个动作能拿到的总奖励」。每次试错后，用公式更新这个“经验本”，让AI慢慢知道“选啥动作最划算”。
为啥要“探索+利用”：
- 利用：90%选已知最好的动作（比如走迷宫知道往右走能到终点，就一直往右）；
- 探索：10%随机试新动作（比如偶尔往左走，看看有没有更近的路）；
  少了探索，AI会“死脑筋”（比如迷宫改了就不会走）；少了利用，AI永远瞎试，学不会最优策略。

下一步可以玩的进阶方向（不用急，先吃透上面的）

改参数：比如把epsilon改成0.5（更多探索），看看AI学的快慢变化；
换环境：Gym里还有FrozenLake-v1（冰湖走路）、Taxi-v3（出租车接客），把代码里的环境名改掉就能玩；
学简单框架：比如stable-baselines3（封装好的强化学习算法），不用自己写Q表，直接调包就能训练AI。

posted @ 2025-12-04 17:25 wangya216 阅读(2) 评论(0) 收藏举报

刷新页面返回顶部