使用Python的storageRolloutStorage()随机生成并存储数据

storageRolloutStorage() 是一个用于存储和管理随机生成的数据的辅助类，通常与深度强化学习算法一起使用。它可以在不同的时间步骤中存储和检索网络输入和输出数据，并提供一些工具方法用于更新和访问这些数据。

下面是一个使用Python的 storageRolloutStorage() 的例子：

import torch
from torch.distributions import Categorical

# 定义storageRolloutStorage类
class RolloutStorage:
    def __init__(self, num_steps, num_envs, obs_shape, action_space):
        # 初始化存储空间
        self.obs = torch.zeros(num_steps + 1, num_envs, *obs_shape)
        self.rewards = torch.zeros(num_steps, num_envs, 1)
        self.masks = torch.ones(num_steps + 1, num_envs, 1)
        self.actions = torch.zeros(num_steps, num_envs, 1).long()
        self.value_preds = torch.zeros(num_steps + 1, num_envs, 1)
        self.returns = torch.zeros(num_steps + 1, num_envs, 1)
        
        # 初始化obs_shape
        self.obs_shape = obs_shape
    
    # 存储每个时间步的观测、动作、奖励、掩码以及当前状态的值预测
    def insert(self, step, obs, actions, action_log_probs, value_preds, rewards, masks):
        self.obs[step + 1].copy_(obs)
        self.actions[step].copy_(actions)
        self.action_log_probs[step].copy_(action_log_probs)
        self.value_preds[step].copy_(value_preds)
        self.rewards[step].copy_(rewards)
        self.masks[step + 1].copy_(masks)
    
    # 更新数据，计算优势和返回值，并将所有数据转移到GPU上
    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):
        self.value_preds[-1] = next_value
        gae = 0
        for step in reversed(range(self.rewards.size(0))):
            delta = self.rewards[step] + gamma * self.value_preds[step + 1] * self.masks[step + 1] - self.value_preds[step]
            gae = delta + gamma * gae * self.masks[step + 1]
            self.returns[step] = gae + self.value_preds[step]
        
    # 从存储中获取数据
    def get_batch(self):
        num_steps, num_envs = self.rewards.size()[0:2]
        batch = {
            'obs': self.obs[:-1].view(-1, *self.obs_shape),
            'actions': self.actions.view(-1, 1),
            'value_preds': self.value_preds[:-1].view(-1, 1),
            'returns': self.returns[:-1].view(-1, 1),
            'masks': self.masks[:-1].view(-1, 1),
            'bad_masks': self.bad_masks[:-1].view(-1, 1),
            'old_action_log_probs': self.action_log_probs.view(-1, 1)
        }
        return batch

# 创建一个RolloutStorage对象
num_steps = 5
num_envs = 4
obs_shape = (3, 84, 84)
action_space = 2  # 二进制动作空间

storage = RolloutStorage(num_steps, num_envs, obs_shape, action_space)

# 随机生成一些示例数据，并将它们存储到storage中
for step in range(num_steps):
    obs = torch.Tensor(num_envs, *obs_shape).uniform_()
    actions = torch.LongTensor(num_envs, 1).random_(0, action_space)
    action_log_probs = torch.Tensor(num_envs, 1).uniform_()
    value_preds = torch.Tensor(num_envs, 1).uniform_()
    rewards = torch.Tensor(num_envs, 1).uniform_(-1, 1)
    masks = torch.Tensor(num_envs, 1).random_()  # 屏蔽一些环境
    
    storage.insert(step, obs, actions, action_log_probs, value_preds, rewards, masks)

# 更新数据
next_value = torch.Tensor(num_envs, 1).uniform_()
gamma = 0.99
storage.compute_returns(next_value, gamma)
storage.after_update()

# 从存储中获取数据批次
batch = storage.get_batch()

# 使用批次数据进行训练

在这个例子中，我们首先创建了一个 RolloutStorage 对象，指定了时间步数、环境个数、观测和动作的形状。然后，我们通过循环随机生成一些示例数据，并将它们插入到存储中。接下来，我们计算优势和返回值，并将存储中的数据移动到GPU上（如果有的话）。最后，我们从存储中获取一个数据批次，并使用它进行模型的训练。

storageRolloutStorage() 是一个非常有用的类，它可以帮助我们方便地管理和存储深度强化学习算法中生成的数据。