强化学习的一些概念

强化学习

打个比方

核心要素

State

Action

Reward

几个代码demo

学习目标

强化学习

强化学习（Reinforcement Learning, RL）是机器学习的一个分支，旨在让智能体（Agent）通过与环境的交互学习最优策略，以最大化长期累积奖励。其核心思想是 “试错 - 反馈”，智能体在环境中通过不断尝试动作，根据环境反馈的奖励调整行为，最终学会在不同状态下选择最优动作。

打个比方

强化学习的「自主生存法则」：像玩游戏一样学本领

想象你养了个智能体（比如扫地机器人），把它扔进环境（你家客厅），然后告诉它：「自己想办法把地扫干净，扫得好有奖励，撞桌子就扣钱！」这就是强化学习的核心 ——让智能体在「试错 - 反馈」中自己摸出一套生存策略。

对比人类小孩学走路：

没人教婴儿「先迈左脚还是右脚」（无监督）

摔疼了自己哭（负面反馈），站稳了家人笑（正面反馈）

最终形成「平衡感 + 迈步节奏」的肌肉记忆（策略）

强化学习的智能体，就是这样一个「会哭会笑的电子小孩」。

智能体的「三件套」：眼睛（状态）、手脚（动作）、奖惩（反馈）

以扫地机器人为例拆解：

状态（眼睛看到的世界）

实时感知：前方有没有桌子（激光雷达数据）、哪里灰尘多（摄像头识别）、电量剩多少（传感器）

大白话：「现在在客厅茶几旁，左边有灰尘，右边是沙发，电量 80%」

动作（手脚的选择）

可选操作：前进、左转、右转、吸尘、回充

大白话：「是先吸茶几底下，还是绕到沙发后面？」

奖励（好坏的裁判）

正向：每吸 1㎡灰尘 + 1 分，按时回充 + 5 分

负向：撞桌子 - 3 分，没电关机 - 10 分

大白话：「吸尘是赚钱，撞桌是罚款，没电最亏！」

自主学习的「闭环逻辑」：从乱撞到老司机

智能体的学习过程像玩「无限循环的闯关游戏」：

第一阶段：乱撞期（探索）

机器人：「反正没电就关机，先乱开试试！」（随机选动作）

结果：撞墙 3 次，偶然吸到灰尘（获得零星奖励）

第二阶段：摸规律（试错中总结）

发现：「电量低于 20% 回充，能避免关机扣分」

记住：「看到灰尘多的区域，先吸尘再移动更划算」

第三阶段：老司机（策略成型）

最优策略：「优先清扫高灰尘区→电量 30% 时规划回充路径→避开家具密集区」

结果：从「乱撞扣分」变成「稳定高分」，甚至比人类指挥的效率还高

为什么说「自动驾驶是强化学习的终极考场」？

对比扫地机器人，自动驾驶的「环境复杂度」暴增：

状态：不仅是车身传感器，还要预测其他车辆、行人的行为（比如外卖电动车突然变道）

动作：刹车力度、转向角度、变道时机，精度要求到厘米级

奖励：安全到达 + 100 分，急刹乘客难受 - 20 分，违章 - 50 分，碰撞 - 1000 分（直接「Game Over」）

难点：需要在 0.1 秒内完成「感知状态→计算最优动作→执行」的循环，还要适应雨天、夜间等极端场景

这就是为什么特斯拉、Waymo 等公司疯狂投入强化学习 ——只有让汽车自己在虚拟世界「撞坏」100 万次，才能在现实中「零事故」。

一句话总结强化学习：

「给智能体一个‘好坏’的标准（奖励），让它在环境里自己‘摸爬滚打’，最终学会「既能占便宜，又能避坑」的生存之道。」

（就像父母教孩子：「自己出去玩，别碰火（负反馈），帮妈妈拿东西有糖吃（正反馈）」，孩子最终学会独立生存。）

核心要素

智能体与环境：智能体是决策主体（如机器人、游戏角色），环境是智能体行动的空间。两者通过 “状态 - 动作 - 奖励” 循环交互

State

状态（State）：环境当前的观测信息，如机器人的位置、游戏画面等

Action

动作（Action）：智能体在当前状态下的选择，如移动、跳跃

1. 动作的本质与分类

动作是智能体与环境交互的直接载体，其设计决定了智能体的行为能力。根据动作的特性，可分为以下两类：

离散动作空间：动作数量有限且可数，如机器人的移动方向（上 / 下 / 左 / 右）、游戏中的按键操作等。

连续动作空间：动作取值为连续区间，如自动驾驶中的油门深度（0-100%）、机械臂的关节角度等。

关键挑战：

离散动作空间需枚举所有可能动作，适合规则明确的场景；

连续动作空间需通过策略网络输出概率分布或直接生成动作（如 DDPG 中的正态分布采样）。

2. 动作空间的设计原则

完整性：动作集合需覆盖所有可能的有效行为，避免遗漏关键操作。

正交性：动作间应相互独立，减少冗余（如同时存在 “加速” 和 “前进” 可能导致策略混淆）。

可扩展性：允许动态调整动作空间（如在训练中逐步解锁新动作）。

3. 数学表达

离散动作：用独热编码（One-Hot Encoding）表示，如 4 个方向的动作可表示为 [0,0,0,1]（右）。

连续动作：常用均值 - 方差模型（如正态分布）或直接通过神经网络输出动作值，如：a∼N(μ(s∣θ),σ2(s∣θ))

其中，μ和σ由策略网络参数θ生成。

4. 典型应用场景

离散动作：Atari 游戏（跳跃、开火）、围棋落子（19x19 位置）。

连续动作：机器人控制（关节扭矩）、飞行器姿态调整（俯仰角、滚转角）。

Reward

奖励（Reward）：环境对动作的反馈，正数表示鼓励，负数表示惩罚

1. 奖励的核心作用

奖励是环境对智能体行为的即时反馈信号，是驱动学习的核心动力。其作用包括：

行为引导：通过正负反馈塑造智能体策略（如奖励 “直行”，惩罚 “碰撞”）。

目标对齐：将抽象目标转化为可量化的数值（如 “到达终点” 对应 + 100 奖励）。

2. 奖励设计的关键原则

明确性：奖励需直接反映动作对目标的贡献（如 “进球” 奖励远大于 “传球”）。

稀疏性与密度平衡：稀疏奖励（如仅在成功时给予奖励）可能导致学习缓慢；

密集奖励（如每步给予小奖励）可能引入噪声，需谨慎设计。

延迟奖励处理：通过折扣因子\(\gamma\)（0≤γ≤1）将未来奖励折算为现值：\(G_t = r_t + \gamma r_{t+1} + \gamma^2 r_{t+2} + \dots\)

3. 奖励塑形（Reward Shaping）

通过人工设计辅助奖励加速学习：

中间目标奖励：在路径规划中，每接近目标点一步给予小额奖励。

内在动机奖励：探索未知区域时给予奖励，解决 “探索 - 利用” 困境。

惩罚设计：对危险行为（如车辆闯红灯）施加大额负奖励。

4. 数学公式与算法关联

Q-learning：目标 Q 值为\(r + \gamma \max_a Q(s', a)\)，奖励直接影响更新方向。

策略梯度：用累积奖励\(R(\tau)\)作为权重更新策略网络：\(\nabla \theta \propto \sum_{t=1}^T R(\tau) \nabla \log \pi(a_t|s_t; \theta)\)

5. 典型应用场景

游戏：击败敌人 + 5 分，死亡 - 10 分。

机器人：保持平衡每帧 + 1 分，摔倒 - 50 分。

金融：盈利 + 1% 奖励，亏损 - 0.5% 惩罚。

几个代码demo

离散动作空间示例：简单的网格世界

import numpy as np

# 定义网格世界的大小
GRID_SIZE = 4
# 定义动作：上、下、左、右
ACTIONS = [(-1, 0), (1, 0), (0, -1), (0, 1)]
# 定义折扣因子
GAMMA = 0.9
# 定义学习率
ALPHA = 0.1
# 定义迭代次数
EPISODES = 1000

# 初始化 Q 表
q_table = np.zeros((GRID_SIZE * GRID_SIZE, len(ACTIONS)))

# 定义状态转换函数
def get_state(x, y):
    return x * GRID_SIZE + y

# 定义奖励函数
def get_reward(x, y):
    if x == GRID_SIZE - 1 and y == GRID_SIZE - 1:
        return 100  # 到达目标点给予奖励
    elif x < 0 or x >= GRID_SIZE or y < 0 or y >= GRID_SIZE:
        return -10  # 越界给予惩罚
    else:
        return -1  # 每走一步给予小惩罚

# Q - learning 算法
for episode in range(EPISODES):
    # 初始化状态
    x, y = 0, 0
    done = False
    while not done:
        state = get_state(x, y)
        # 选择动作（epsilon - greedy 策略）
        epsilon = 0.1
        if np.random.uniform(0, 1) < epsilon:
            action_idx = np.random.choice(len(ACTIONS))
        else:
            action_idx = np.argmax(q_table[state])
        action = ACTIONS[action_idx]
        # 执行动作
        new_x = x + action[0]
        new_y = y + action[1]
        new_state = get_state(new_x, new_y)
        # 获取奖励
        reward = get_reward(new_x, new_y)
        # 更新 Q 表
        q_table[state, action_idx] = (1 - ALPHA) * q_table[state, action_idx] + ALPHA * (
                reward + GAMMA * np.max(q_table[new_state]))
        # 判断是否到达目标
        if reward == 100:
            done = True
        x, y = new_x, new_y

# 打印最终的 Q 表
print("Final Q - table:")
print(q_table)

实现了一个简单的网格世界，智能体需要从左上角走到右下角。动作空间是离散的（上、下、左、右），通过 Q - learning 算法学习最优策略，有点类似于动态规划的策略要求引导

连续动作空间示例：简单的一维移动问题（使用 DDPG 简化版）

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 定义状态维度和动作维度
STATE_DIM = 1
ACTION_DIM = 1
# 定义折扣因子
GAMMA = 0.9
# 定义迭代次数
EPISODES = 1000

# 定义策略网络
class PolicyNetwork(nn.Module):
    def __init__(self):
        super(PolicyNetwork, self).__init__()
        self.fc1 = nn.Linear(STATE_DIM, 16)
        self.fc2 = nn.Linear(16, ACTION_DIM)

    def forward(self, state):
        x = torch.relu(self.fc1(state))
        action = torch.tanh(self.fc2(x))  # 动作范围在 [-1, 1]
        return action

# 初始化策略网络
policy_network = PolicyNetwork()
optimizer = optim.Adam(policy_network.parameters(), lr=0.001)

# 定义奖励函数
def get_reward(state, action):
    target_state = 5.0
    new_state = state + action.item()
    reward = -np.abs(new_state - target_state)
    return reward

# 训练过程
for episode in range(EPISODES):
    state = torch.tensor([0.0], dtype=torch.float32)
    done = False
    while not done:
        action = policy_network(state)
        reward = get_reward(state, action)
        # 简单的策略梯度更新
        loss = -reward * action
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        # 更新状态
        state = torch.tensor([state.item() + action.item()], dtype=torch.float32)
        if np.abs(state.item() - 5.0) < 0.1:
            done = True

# 打印最终的策略网络参数
print("Final policy network parameters:")
for name, param in policy_network.named_parameters():
    print(name, param.data)

实现了一个简单的一维移动问题，智能体需要从位置 0 移动到位置 5。动作空间是连续的，通过一个简单的策略网络学习最优动作。

奖励塑形示例：在网格世界中添加中间目标奖励

import numpy as np

# 定义网格世界的大小
GRID_SIZE = 4
# 定义动作：上、下、左、右
ACTIONS = [(-1, 0), (1, 0), (0, -1), (0, 1)]
# 定义折扣因子
GAMMA = 0.9
# 定义学习率
ALPHA = 0.1
# 定义迭代次数
EPISODES = 1000

# 初始化 Q 表
q_table = np.zeros((GRID_SIZE * GRID_SIZE, len(ACTIONS)))

# 定义状态转换函数
def get_state(x, y):
    return x * GRID_SIZE + y

# 定义奖励函数（包含中间目标奖励）
def get_reward(x, y):
    if x == GRID_SIZE - 1 and y == GRID_SIZE - 1:
        return 100  # 到达目标点给予奖励
    elif x < 0 or x >= GRID_SIZE or y < 0 or y >= GRID_SIZE:
        return -10  # 越界给予惩罚
    elif x > 0 and y > 0:
        return 1  # 中间目标奖励
    else:
        return -1  # 每走一步给予小惩罚

# Q - learning 算法
for episode in range(EPISODES):
    # 初始化状态
    x, y = 0, 0
    done = False
    while not done:
        state = get_state(x, y)
        # 选择动作（epsilon - greedy 策略）
        epsilon = 0.1
        if np.random.uniform(0, 1) < epsilon:
            action_idx = np.random.choice(len(ACTIONS))
        else:
            action_idx = np.argmax(q_table[state])
        action = ACTIONS[action_idx]
        # 执行动作
        new_x = x + action[0]
        new_y = y + action[1]
        new_state = get_state(new_x, new_y)
        # 获取奖励
        reward = get_reward(new_x, new_y)
        # 更新 Q 表
        q_table[state, action_idx] = (1 - ALPHA) * q_table[state, action_idx] + ALPHA * (
                reward + GAMMA * np.max(q_table[new_state]))
        # 判断是否到达目标
        if reward == 100:
            done = True
        x, y = new_x, new_y

# 打印最终的 Q 表
print("Final Q - table with reward shaping:")
print(q_table)