Hash

class torchrl.envs.transforms.Hash(in_keys: Sequence[NestedKey], out_keys: Sequence[NestedKey], in_keys_inv: Sequence[NestedKey] = None, out_keys_inv: Sequence[NestedKey] = None, *, hash_fn: Callable = None, seed: Any | None = None, use_raw_nontensor: bool = False, repertoire: tuple[tuple[int], Any] = None)

将哈希值添加到 tensordict 中。

参数:

• in_keys (Sequence of NestedKey) – 要哈希的值的键。

• out_keys (Sequence of NestedKey) – 结果哈希的键。

• in_keys_inv (Sequence of NestedKey, optional) – 在 inv 调用期间要哈希的值的键。

• out_keys_inv (Sequence of NestedKey, optional) – 在 inv 调用期间结果哈希的键。

关键字参数:

• hash_fn (Callable, optional) – 要使用的哈希函数。函数签名必须是 (input: Any, seed: Any | None) -> torch.Tensor。如果此转换使用 seed 参数初始化，则 seed 才会被使用。默认为 Hash.reproducible_hash。

• seed (optional) – 如果需要，用于哈希函数的种子。

• use_raw_nontensor (bool, optional) – 如果为 False，则在调用 fn 之前，会从 NonTensorData/NonTensorStack 输入中提取数据。如果为 True，则直接将原始 NonTensorData/NonTensorStack 输入提供给 fn，此时 fn 必须支持这些输入。默认为 False。

• repertoire (Dict[Tuple[int], Any], optional) – 如果提供，此字典将存储从哈希到输入的逆映射。此 repertoire 不会被复制，因此可以在转换实例化后在同一工作空间中修改它，这些修改将反映在映射中。缺少哈希将映射到 None。默认值：None

• Hash (>>> from torchrl.envs import GymEnv, UnaryTransform,) –

• GymEnv (>>> env =) –

• output (>>> # process the string) –

• env.append_transform( (>>> env =) –

• UnaryTransform( (...) –

• in_keys=["observation"], (...) –

• out_keys=["observation_str"], (...) –

• tensor (... fn=lambda) – str(tensor.numpy().tobytes())))

• output –

• env.append_transform( –

• Hash( (...) –

• in_keys=["observation_str"], (...) –

• out_keys=["observation_hash"],) (...) –

• ) (...) –

• env.observation_spec (>>>) –

• Composite( –

  observation: BoundedContinuous(

  shape=torch.Size([3]), space=ContinuousBox(

  low=Tensor(shape=torch.Size([3]), device=cpu, dtype=torch.float32, contiguous=True), high=Tensor(shape=torch.Size([3]), device=cpu, dtype=torch.float32, contiguous=True)),

  device=cpu, dtype=torch.float32, domain=continuous),

  observation_str: NonTensor(

  shape=torch.Size([]), space=None, device=cpu, dtype=None, domain=None),

  observation_hash: UnboundedDiscrete(

  shape=torch.Size([32]), space=ContinuousBox(

  low=Tensor(shape=torch.Size([32]), device=cpu, dtype=torch.uint8, contiguous=True), high=Tensor(shape=torch.Size([32]), device=cpu, dtype=torch.uint8, contiguous=True)),

  device=cpu, dtype=torch.uint8, domain=discrete),

  device=None, shape=torch.Size([]))

• env.rollout (>>>) –

• TensorDict( –

  fields={

  action: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.float32, is_shared=False), done: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.bool, is_shared=False), next: TensorDict(

  fields={

  done: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.bool, is_shared=False), observation: Tensor(shape=torch.Size([3, 3]), device=cpu, dtype=torch.float32, is_shared=False), observation_hash: Tensor(shape=torch.Size([3, 32]), device=cpu, dtype=torch.uint8, is_shared=False), observation_str: NonTensorStack(

  [“b’g\x08\x8b\xbexav\xbf\x00\xee(>’”, “b’\x…, batch_size=torch.Size([3]), device=None),

  reward: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.float32, is_shared=False), terminated: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.bool, is_shared=False), truncated: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.bool, is_shared=False)},

  batch_size=torch.Size([3]), device=None, is_shared=False),

  observation: Tensor(shape=torch.Size([3, 3]), device=cpu, dtype=torch.float32, is_shared=False), observation_hash: Tensor(shape=torch.Size([3, 32]), device=cpu, dtype=torch.uint8, is_shared=False), observation_str: NonTensorStack(

  [“b’\xb5\x17\x8f\xbe\x88\xccu\xbf\xc0Vr?’”…, batch_size=torch.Size([3]), device=None),

  terminated: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.bool, is_shared=False), truncated: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.bool, is_shared=False)},

  batch_size=torch.Size([3]), device=None, is_shared=False)

• env.check_env_specs() (>>>) –

• succeeded! ([torchrl][INFO] check_env_specs) –

get_input_from_hash(hash_tensor) → Any

查找给定特定哈希输出的输入。

此功能仅在初始化期间提供了 :arg:`repertoire` 参数，或者同时提供了 :arg:`in_keys_inv` 和 :arg:`out_keys_inv` 参数时才可用。

参数:

hash_tensor (Tensor) – 哈希输出。

返回:

生成哈希的输入。

返回类型:

任何

classmethod reproducible_hash(string, seed=None)

使用种子从字符串创建可复现的 256 位哈希。

参数:

• string (str or None) – 输入字符串。如果为 None，则使用空字符串 ""。

• seed (str, optional) – 种子值。默认为 None。

返回:

形状为 (32,)，dtype 为 torch.uint8。

返回类型:

张量

state_dict(*args, destination=None, prefix='', keep_vars=False)

返回一个字典，其中包含对模块整个状态的引用。

参数和持久缓冲区（例如，运行平均值）都包含在内。键是相应的参数和缓冲区名称。设置为 None 的参数和缓冲区不包含在内。

注意

返回的对象是浅拷贝。它包含对模块参数和缓冲区的引用。

警告

当前 state_dict() 还接受 destination、prefix 和 keep_vars 的位置参数，顺序为。但是，这正在被弃用，并且在未来的版本中将强制使用关键字参数。

警告

请避免使用参数 destination，因为它不是为最终用户设计的。

参数:

• destination (dict, optional) – 如果提供，模块的状态将更新到 dict 中，并返回相同的对象。否则，将创建一个 OrderedDict 并返回。默认为 None。

• prefix (str, optional) – a prefix added to parameter and buffer names to compose the keys in state_dict. Default: ''。

• keep_vars (bool, optional) – 默认情况下，state dict 中返回的 Tensors 会从 autograd 中分离。如果设置为 True，则不会执行分离。默认为 False。

返回:

包含模块整体状态的字典

返回类型:

dict

示例

>>> # xdoctest: +SKIP("undefined vars")
>>> module.state_dict().keys()
['bias', 'weight']