随机生成数据并利用Python的storageRolloutStorage()实现存储功能

在机器学习和深度强化学习中，经验回放（Experience Replay）是一种重要的技术。经验回放的核心思想是将智能体在环境中的交互数据存储起来，然后随机抽样这些数据进行训练，以增强训练的稳定性和效果。

在PyTorch中，有一个非常有用的类storageRolloutStorage()用于实现经验回放的存储功能。它提供了一种机制来存储和处理训练数据的批次，以供后续训练使用。

下面是一个简单的例子来演示如何使用storageRolloutStorage()类来存储数据：

import torch
from torch.distributions import Categorical
from torch.utils.data.sampler import BatchSampler, SubsetRandomSampler


class storageRolloutStorage():
    def __init__(self, num_steps, num_envs, obs_size, action_size):
        self.num_steps = num_steps
        self.num_envs = num_envs
        self.obs_size = obs_size
        self.action_size = action_size

        self.obs = torch.zeros(num_steps + 1, num_envs, obs_size)
        self.actions = torch.zeros(num_steps, num_envs, action_size)
        self.rewards = torch.zeros(num_steps, num_envs, 1)
        self.masks = torch.ones(num_steps + 1, num_envs, 1)

        self.current_step = 0

    def insert(self, obs, actions, rewards, masks):
        self.obs[self.current_step + 1].copy_(obs)
        self.actions[self.current_step].copy_(actions)
        self.rewards[self.current_step].copy_(rewards)
        self.masks[self.current_step + 1].copy_(masks)

        self.current_step = (self.current_step + 1) % self.num_steps

    def after_update(self):
        self.obs[0].copy_(self.obs[-1])
        self.masks[0].copy_(self.masks[-1])

    def compute_returns(self, next_value, gamma):
        returns = torch.zeros(self.num_steps + 1, self.num_envs, 1)
        returns[-1] = next_value
        for step in reversed(range(self.num_steps)):
            returns[step] = returns[step + 1] * gamma * self.masks[step + 1] + self.rewards[step]
        return returns[:-1]


# 使用示例
num_steps = 5
num_envs = 3
obs_size = 4
action_size = 2
gamma = 0.9

# 创建storageRolloutStorage对象
rollouts = storageRolloutStorage(num_steps, num_envs, obs_size, action_size)

# 生成随机数据并插入到存储中
for step in range(num_steps):
    obs = torch.randn(num_envs, obs_size)
    actions = torch.randint(action_size, (num_envs, 1))
    rewards = torch.randn(num_envs, 1)
    masks = torch.randint(2, (num_envs, 1))
    rollouts.insert(obs, actions, rewards, masks)

# 计算回报值
next_value = torch.randn(num_envs, 1)
returns = rollouts.compute_returns(next_value, gamma)

# 打印存储中的数据
print("Observations:")
print(rollouts.obs)
print("Actions:")
print(rollouts.actions)
print("Rewards:")
print(rollouts.rewards)
print("Masks:")
print(rollouts.masks)
print("Returns:")
print(returns)

在这个例子中，我们创建了一个storageRolloutStorage对象，并指定了数据的维度。然后，我们生成了随机的观察、动作、奖励和掩码数据，并将其插入到存储中。接下来，我们计算了回报值，并将结果打印出来。

通过使用storageRolloutStorage类，我们可以方便地存储和处理训练数据的批次，为模型训练提供了便利。在实际的深度强化学习应用中，经验回放和存储功能的使用可以提高训练的效果和稳定性。