国创——深度Q学习算法

最新推荐文章于 2025-04-26 14:08:55 发布

小熊要努力刷题！

最新推荐文章于 2025-04-26 14:08:55 发布

阅读量1.2k

点赞数 6

分类专栏：国创文章标签：学习算法

本文链接：https://blog.youkuaiyun.com/2301_80073593/article/details/142670502

版权

国创专栏收录该内容

8 篇文章

订阅专栏

1. 深度Q学习（Deep Q - Learning）算法概述

- 深度Q - 学习是一种强化学习算法，用于解决马尔可夫决策过程（Markov Decision Processes，MDP）中的最优策略问题。在这种情况下，虚拟人物作为智能体（agent），在环境（environment）中通过一系列的动作（action）来最大化累积奖励（reward）。

- 它基于Q - 学习算法，使用深度神经网络（Deep Neural Network，DNN）来近似Q - 函数（Q - function）。Q - 函数表示在给定状态（state）下采取某个动作的预期长期奖励。

2. 深度Q学习算法的具体实现步骤

- 环境定义

- 确定虚拟人物所处的环境，包括状态空间（所有可能的状态集合）、动作空间（所有可能的动作集合）和奖励机制（根据动作和状态转换给予奖励）。

- 神经网络构建

- 使用Python中的深度学习框架（如TensorFlow或PyTorch）构建一个深度神经网络。这个网络将输入状态，输出每个动作的Q - 值估计。

- 例如，在PyTorch中：


import torch

import torch.nn as nn

import torch.nn.functional as F


class DQN(nn.Module):

    def __init__(self, input_size, output_size):

        super(DQN, self).__init__()

        self.fc1 = nn.Linear(input_size, 128)

        self.fc2 = nn.Linear(128, 128)

        self.fc3 = nn.Linear(128, output_size)



    def forward(self, x):

        x = F.relu(self.fc1(x))

        x = F.relu(self.fc2(x))

        return self.fc3(x)

- 经验回放（Experience Replay）

- 创建一个经验回放缓冲区（通常是一个队列或列表）来存储智能体的经验。经验是一个四元组（state，action，reward，next_state）。

class ReplayBuffer:

    def __init__(self, capacity):

        self.capacity = capacity

        self.buffer = []

        self.position = 0



    def push(self, state, action, reward, next_state):

        if len(self.buffer) < self.capacity:

            self.buffer.append(None)

        self.buffer[self.position]=(state, action, reward, next_state)

        self.position = (self.position + 1) % self.capacity



    def sample(self, batch_size):

        return random.sample(self.buffer, batch_size)



    def __len__(self):

        return len(self.buffer)

- 训练过程

- 初始化Q - 网络（ q_network ）和目标Q - 网络（ target_q_network ，初始参数与 q_network 相同）。

- 在每个时间步：

- 选择一个动作：根据当前状态和Q - 网络，可以使用 epsilon - greedy 策略选择动作。 epsilon - greedy 策略以概率 epsilon 随机选择动作，以概率 1 - epsilon 选择具有最高Q - 值的动作。

- 执行动作，获得奖励和下一个状态。

- 将经验（state，action，reward，next_state）存储到经验回放缓冲区。

- 从经验回放缓冲区中随机采样一批经验。

- 计算目标Q - 值：对于每个采样的经验，目标Q - 值 y_j 的计算如下：

- 如果下一个状态是终止状态（例如任务完成或失败），则 y_j = reward_j 。

- 否则， y_j = reward_j+ gamma * max_{a'} Q(s'_{j}, a'; \theta^{-}) ，其中 gamma 是折扣因子（通常在0到1之间）， theta^{-} 是目标Q - 网络的参数。

- 计算损失：使用均方误差（MSE）损失函数，计算预测Q - 值（ q_network(state) ）和目标Q - 值（ y_j ）之间的损失。

- 优化Q - 网络：使用优化器（如Adam）根据损失反向传播更新Q - 网络的参数。

- 定期更新目标Q - 网络的参数（例如，每C步将 target_q_network 的参数更新为 q_network 的参数）。

3. 完整的深度Q学习算法示例代码（使用PyTorch和一个简单的虚拟环境示例）

import torch

import torch.nn as nn

import torch.nn.functional as F

import random

import numpy as np


# 定义Q - 网络

class DQN(nn.Module):

    def __init__(self, input_size, output_size):

        super(DQN, self).__init__()

        self.fc1 = nn.Linear(input_size, 128)

        self.fc2 = nn.Linear(128, 128)

        self.fc3 = nn.Linear(128, output_size)



    def forward(self, x):

        x = F.relu(self.fc1(x))

        x = F.relu(self.fc2(x))

        return self.fc3(x)



# 经验回放缓冲区

class ReplayBuffer:

    def __init__(self, capacity):

        self.capacity = capacity

        self.buffer = []

        self.position = 0



    def push(self, state, action, reward, next_state):

        if len(self.buffer) < self.capacity:

            self.buffer.append(None)

        self.buffer[self.position]=(state, action, reward, next_state)

        self.position = (self.position + 1) % self.capacity



    def sample(self, batch_size):

        return random.sample(self.buffer, batch_size)



    def __len__(self):

        return len(self.buffer)

4.虚拟环境示例（简单的网格世界，这里只是示例，实际需要根据具体任务定义）

class SimpleEnvironment:

    def __init__(self):

        self.state = np.array([0, 0])

        self.goal = np.array([4, 4])


    def step(self, action):

        # 动作：0 - 上，1 - 下，2 - 左，3 - 右

        if action == 0:

            self.state[0] = max(self.state[0] - 1, 0)

        elif action == 1:

            self.state[0] = min(self.state[0] + 1, 4)

        elif action == 2:

            self.state[1] = max(self.state[1] - 1, 0)

        elif action == 3:

            self.state[1] = min(self.state[1] + 1, 4)



        reward = -1

        if np.array_equal(self.state, self.goal):

            reward = 10

            done = True

        else:

            done = False



        return self.state, reward, done





# 深度Q - 学习训练

def train_dqn():

    input_size = 2  # 状态空间维度（这里是简单的2D坐标）

    output_size = 4  # 动作空间维度（4个方向）

    gamma = 0.99

    epsilon_start = 1.0

    epsilon_end = 0.01

    epsilon_decay = 1000

    learning_rate = 0.001

    batch_size = 32

    buffer_capacity = 1000

    target_update = 10



    q_network = DQN(input_size, output_size)

    target_q_network = DQN(input_size, output_size)

    target_q_network.load_state_dict(q_network.state_dict())

    optimizer = torch.optim.Adam(q_network.parameters(), lr = learning_rate)

    replay_buffer = ReplayBuffer(buffer_capacity)



    env = SimpleEnvironment()



    num_episodes = 1000

    for episode in range(num_episodes):

        state = env.state

        state = torch.FloatTensor(state)

        epsilon = epsilon_start - (epsilon_start - epsilon_end) * (episode / epsilon_decay)

        done = False

        while not done:

            if random.random() < epsilon:

                action = random.randint(0, output_size - 1)

            else:

                q_values = q_network(state)

                _, action = torch.max(q_values, 0)

                action = action.item()



            next_state, reward, done = env.step(action)

            next_state = torch.FloatTensor(next_state)

            replay_buffer.push(state, action, reward, next_state)

            state = next_state



            if len(replay_buffer) >= batch_size:

                batch = replay_buffer.sample(batch_size)

                states, actions, rewards, next_states = zip(*batch)

                states = torch.stack(states)

                actions = torch.LongTensor(actions).unsqueeze(1)

                rewards = torch.FloatTensor(rewards).unsqueeze(1)

                next_states = torch.stack(next_states)



                q_pred = q_network(states).gather(1, actions)

                q_next = target_q_network(next_states).max(1)[0].unsqueeze(1)

                target_q = rewards + gamma * q_next

                loss = F.mse_loss(q_pred, target_q)



                optimizer.zero_grad()

                loss.backward()

                optimizer.step()



        if episode % target_update == 0:

            target_q_network.load_state_dict(q_network.state_dict())





if __name__ == "__main__":

    train_dqn()