Skip to main content

No project description provided

Project description

Unit-tests Documentation Benchmarks codecov Twitter Follow Python version GitHub license pypi version pypi nightly version Downloads Downloads Discord Shield

TorchRL

Documentation | TensorDict | Features | Examples, tutorials and demos | Citation | Installation | Asking a question | Contributing

TorchRL is an open-source Reinforcement Learning (RL) library for PyTorch.

It provides pytorch and python-first, low and high level abstractions for RL that are intended to be efficient, modular, documented and properly tested. The code is aimed at supporting research in RL. Most of it is written in python in a highly modular way, such that researchers can easily swap components, transform them or write new ones with little effort.

This repo attempts to align with the existing pytorch ecosystem libraries in that it has a dataset pillar (torchrl/envs), transforms, models, data utilities (e.g. collectors and containers), etc. TorchRL aims at having as few dependencies as possible (python standard library, numpy and pytorch). Common environment libraries (e.g. OpenAI gym) are only optional.

On the low-level end, torchrl comes with a set of highly re-usable functionals for cost functions, returns and data processing.

TorchRL aims at (1) a high modularity and (2) good runtime performance. Read the full paper for a more curated description of the library.

Getting started

Check our Getting Started tutorials for quickly ramp up with the basic features of the library!

Documentation and knowledge base

The TorchRL documentation can be found here. It contains tutorials and the API reference.

TorchRL also provides a RL knowledge base to help you debug your code, or simply learn the basics of RL. Check it out here.

We have some introductory videos for you to get to know the library better, check them out:

Writing simplified and portable RL codebase with TensorDict

RL algorithms are very heterogeneous, and it can be hard to recycle a codebase across settings (e.g. from online to offline, from state-based to pixel-based learning). TorchRL solves this problem through TensorDict, a convenient data structure(1) that can be used to streamline one's RL codebase. With this tool, one can write a complete PPO training script in less than 100 lines of code!

Code
import torch
from tensordict.nn import TensorDictModule
from tensordict.nn.distributions import NormalParamExtractor
from torch import nn

from torchrl.collectors import SyncDataCollector
from torchrl.data.replay_buffers import TensorDictReplayBuffer, \
    LazyTensorStorage, SamplerWithoutReplacement
from torchrl.envs.libs.gym import GymEnv
from torchrl.modules import ProbabilisticActor, ValueOperator, TanhNormal
from torchrl.objectives import ClipPPOLoss
from torchrl.objectives.value import GAE

env = GymEnv("Pendulum-v1")
model = TensorDictModule(
    nn.Sequential(
        nn.Linear(3, 128), nn.Tanh(),
        nn.Linear(128, 128), nn.Tanh(),
        nn.Linear(128, 128), nn.Tanh(),
        nn.Linear(128, 2),
        NormalParamExtractor()
    ),
    in_keys=["observation"],
    out_keys=["loc", "scale"]
)
critic = ValueOperator(
    nn.Sequential(
        nn.Linear(3, 128), nn.Tanh(),
        nn.Linear(128, 128), nn.Tanh(),
        nn.Linear(128, 128), nn.Tanh(),
        nn.Linear(128, 1),
    ),
    in_keys=["observation"],
)
actor = ProbabilisticActor(
    model,
    in_keys=["loc", "scale"],
    distribution_class=TanhNormal,
    distribution_kwargs={"min": -1.0, "max": 1.0},
    return_log_prob=True
    )
buffer = TensorDictReplayBuffer(
    LazyTensorStorage(1000),
    SamplerWithoutReplacement()
    )
collector = SyncDataCollector(
    env,
    actor,
    frames_per_batch=1000,
    total_frames=1_000_000
    )
loss_fn = ClipPPOLoss(actor, critic, gamma=0.99)
optim = torch.optim.Adam(loss_fn.parameters(), lr=2e-4)
adv_fn = GAE(value_network=critic, gamma=0.99, lmbda=0.95, average_gae=True)
for data in collector:  # collect data
    for epoch in range(10):
        adv_fn(data)  # compute advantage
        buffer.extend(data.view(-1))
        for i in range(20):  # consume data
            sample = buffer.sample(50)  # mini-batch
            loss_vals = loss_fn(sample)
            loss_val = sum(
                value for key, value in loss_vals.items() if
                key.startswith("loss")
                )
            loss_val.backward()
            optim.step()
            optim.zero_grad()
    print(f"avg reward: {data['next', 'reward'].mean().item(): 4.4f}")

Here is an example of how the environment API relies on tensordict to carry data from one function to another during a rollout execution: Alt Text

TensorDict makes it easy to re-use pieces of code across environments, models and algorithms.

Code

For instance, here's how to code a rollout in TorchRL:

- obs, done = env.reset()
+ tensordict = env.reset()
policy = SafeModule(
    model,
    in_keys=["observation_pixels", "observation_vector"],
    out_keys=["action"],
)
out = []
for i in range(n_steps):
-     action, log_prob = policy(obs)
-     next_obs, reward, done, info = env.step(action)
-     out.append((obs, next_obs, action, log_prob, reward, done))
-     obs = next_obs
+     tensordict = policy(tensordict)
+     tensordict = env.step(tensordict)
+     out.append(tensordict)
+     tensordict = step_mdp(tensordict)  # renames next_observation_* keys to observation_*
- obs, next_obs, action, log_prob, reward, done = [torch.stack(vals, 0) for vals in zip(*out)]
+ out = torch.stack(out, 0)  # TensorDict supports multiple tensor operations

Using this, TorchRL abstracts away the input / output signatures of the modules, env, collectors, replay buffers and losses of the library, allowing all primitives to be easily recycled across settings.

Code

Here's another example of an off-policy training loop in TorchRL (assuming that a data collector, a replay buffer, a loss and an optimizer have been instantiated):

- for i, (obs, next_obs, action, hidden_state, reward, done) in enumerate(collector):
+ for i, tensordict in enumerate(collector):
-     replay_buffer.add((obs, next_obs, action, log_prob, reward, done))
+     replay_buffer.add(tensordict)
    for j in range(num_optim_steps):
-         obs, next_obs, action, hidden_state, reward, done = replay_buffer.sample(batch_size)
-         loss = loss_fn(obs, next_obs, action, hidden_state, reward, done)
+         tensordict = replay_buffer.sample(batch_size)
+         loss = loss_fn(tensordict)
        loss.backward()
        optim.step()
        optim.zero_grad()

This training loop can be re-used across algorithms as it makes a minimal number of assumptions about the structure of the data.

TensorDict supports multiple tensor operations on its device and shape (the shape of TensorDict, or its batch size, is the common arbitrary N first dimensions of all its contained tensors):

Code
# stack and cat
tensordict = torch.stack(list_of_tensordicts, 0)
tensordict = torch.cat(list_of_tensordicts, 0)
# reshape
tensordict = tensordict.view(-1)
tensordict = tensordict.permute(0, 2, 1)
tensordict = tensordict.unsqueeze(-1)
tensordict = tensordict.squeeze(-1)
# indexing
tensordict = tensordict[:2]
tensordict[:, 2] = sub_tensordict
# device and memory location
tensordict.cuda()
tensordict.to("cuda:1")
tensordict.share_memory_()

TensorDict comes with a dedicated tensordict.nn module that contains everything you might need to write your model with it. And it is functorch and torch.compile compatible!

Code
transformer_model = nn.Transformer(nhead=16, num_encoder_layers=12)
+ td_module = SafeModule(transformer_model, in_keys=["src", "tgt"], out_keys=["out"])
src = torch.rand((10, 32, 512))
tgt = torch.rand((20, 32, 512))
+ tensordict = TensorDict({"src": src, "tgt": tgt}, batch_size=[20, 32])
- out = transformer_model(src, tgt)
+ td_module(tensordict)
+ out = tensordict["out"]

The TensorDictSequential class allows to branch sequences of nn.Module instances in a highly modular way. For instance, here is an implementation of a transformer using the encoder and decoder blocks:

encoder_module = TransformerEncoder(...)
encoder = TensorDictSequential(encoder_module, in_keys=["src", "src_mask"], out_keys=["memory"])
decoder_module = TransformerDecoder(...)
decoder = TensorDictModule(decoder_module, in_keys=["tgt", "memory"], out_keys=["output"])
transformer = TensorDictSequential(encoder, decoder)
assert transformer.in_keys == ["src", "src_mask", "tgt"]
assert transformer.out_keys == ["memory", "output"]

TensorDictSequential allows to isolate subgraphs by querying a set of desired input / output keys:

transformer.select_subsequence(out_keys=["memory"])  # returns the encoder
transformer.select_subsequence(in_keys=["tgt", "memory"])  # returns the decoder

Check TensorDict tutorials to learn more!

Features

  • A common interface for environments which supports common libraries (OpenAI gym, deepmind control lab, etc.)(1) and state-less execution (e.g. Model-based environments). The batched environments containers allow parallel execution(2). A common PyTorch-first class of tensor-specification class is also provided. TorchRL's environments API is simple but stringent and specific. Check the documentation and tutorial to learn more!

    Code
    env_make = lambda: GymEnv("Pendulum-v1", from_pixels=True)
    env_parallel = ParallelEnv(4, env_make)  # creates 4 envs in parallel
    tensordict = env_parallel.rollout(max_steps=20, policy=None)  # random rollout (no policy given)
    assert tensordict.shape == [4, 20]  # 4 envs, 20 steps rollout
    env_parallel.action_spec.is_in(tensordict["action"])  # spec check returns True
    
  • multiprocess and distributed data collectors(2) that work synchronously or asynchronously. Through the use of TensorDict, TorchRL's training loops are made very similar to regular training loops in supervised learning (although the "dataloader" -- read data collector -- is modified on-the-fly):

    Code
    env_make = lambda: GymEnv("Pendulum-v1", from_pixels=True)
    collector = MultiaSyncDataCollector(
        [env_make, env_make],
        policy=policy,
        devices=["cuda:0", "cuda:0"],
        total_frames=10000,
        frames_per_batch=50,
        ...
    )
    for i, tensordict_data in enumerate(collector):
        loss = loss_module(tensordict_data)
        loss.backward()
        optim.step()
        optim.zero_grad()
        collector.update_policy_weights_()
    

    Check our distributed collector examples to learn more about ultra-fast data collection with TorchRL.

  • efficient(2) and generic(1) replay buffers with modularized storage:

    Code
    storage = LazyMemmapStorage(  # memory-mapped (physical) storage
        cfg.buffer_size,
        scratch_dir="/tmp/"
    )
    buffer = TensorDictPrioritizedReplayBuffer(
        alpha=0.7,
        beta=0.5,
        collate_fn=lambda x: x,
        pin_memory=device != torch.device("cpu"),
        prefetch=10,  # multi-threaded sampling
        storage=storage
    )
    

    Replay buffers are also offered as wrappers around common datasets for offline RL:

    Code
    from torchrl.data.replay_buffers import SamplerWithoutReplacement
    from torchrl.data.datasets.d4rl import D4RLExperienceReplay
    data = D4RLExperienceReplay(
        "maze2d-open-v0",
        split_trajs=True,
        batch_size=128,
        sampler=SamplerWithoutReplacement(drop_last=True),
    )
    for sample in data:  # or alternatively sample = data.sample()
        fun(sample)
    
  • cross-library environment transforms(1), executed on device and in a vectorized fashion(2), which process and prepare the data coming out of the environments to be used by the agent:

    Code
    env_make = lambda: GymEnv("Pendulum-v1", from_pixels=True)
    env_base = ParallelEnv(4, env_make, device="cuda:0")  # creates 4 envs in parallel
    env = TransformedEnv(
        env_base,
        Compose(
            ToTensorImage(),
            ObservationNorm(loc=0.5, scale=1.0)),  # executes the transforms once and on device
    )
    tensordict = env.reset()
    assert tensordict.device == torch.device("cuda:0")
    

    Other transforms include: reward scaling (RewardScaling), shape operations (concatenation of tensors, unsqueezing etc.), concatenation of successive operations (CatFrames), resizing (Resize) and many more.

    Unlike other libraries, the transforms are stacked as a list (and not wrapped in each other), which makes it easy to add and remove them at will:

    env.insert_transform(0, NoopResetEnv())  # inserts the NoopResetEnv transform at the index 0
    

    Nevertheless, transforms can access and execute operations on the parent environment:

    transform = env.transform[1]  # gathers the second transform of the list
    parent_env = transform.parent  # returns the base environment of the second transform, i.e. the base env + the first transform
    
  • various tools for distributed learning (e.g. memory mapped tensors)(2);

  • various architectures and models (e.g. actor-critic)(1):

    Code
    # create an nn.Module
    common_module = ConvNet(
        bias_last_layer=True,
        depth=None,
        num_cells=[32, 64, 64],
        kernel_sizes=[8, 4, 3],
        strides=[4, 2, 1],
    )
    # Wrap it in a SafeModule, indicating what key to read in and where to
    # write out the output
    common_module = SafeModule(
        common_module,
        in_keys=["pixels"],
        out_keys=["hidden"],
    )
    # Wrap the policy module in NormalParamsWrapper, such that the output
    # tensor is split in loc and scale, and scale is mapped onto a positive space
    policy_module = SafeModule(
        NormalParamsWrapper(
            MLP(num_cells=[64, 64], out_features=32, activation=nn.ELU)
        ),
        in_keys=["hidden"],
        out_keys=["loc", "scale"],
    )
    # Use a SafeProbabilisticTensorDictSequential to combine the SafeModule with a
    # SafeProbabilisticModule, indicating how to build the
    # torch.distribution.Distribution object and what to do with it
    policy_module = SafeProbabilisticTensorDictSequential(  # stochastic policy
        policy_module,
        SafeProbabilisticModule(
            in_keys=["loc", "scale"],
            out_keys="action",
            distribution_class=TanhNormal,
        ),
    )
    value_module = MLP(
        num_cells=[64, 64],
        out_features=1,
        activation=nn.ELU,
    )
    # Wrap the policy and value funciton in a common module
    actor_value = ActorValueOperator(common_module, policy_module, value_module)
    # standalone policy from this
    standalone_policy = actor_value.get_policy_operator()
    
  • exploration wrappers and modules to easily swap between exploration and exploitation(1):

    Code
    policy_explore = EGreedyWrapper(policy)
    with set_exploration_type(ExplorationType.RANDOM):
        tensordict = policy_explore(tensordict)  # will use eps-greedy
    with set_exploration_type(ExplorationType.MODE):
        tensordict = policy_explore(tensordict)  # will not use eps-greedy
    
  • A series of efficient loss modules and highly vectorized functional return and advantage computation.

    Code

    Loss modules

    from torchrl.objectives import DQNLoss
    loss_module = DQNLoss(value_network=value_network, gamma=0.99)
    tensordict = replay_buffer.sample(batch_size)
    loss = loss_module(tensordict)
    

    Advantage computation

    from torchrl.objectives.value.functional import vec_td_lambda_return_estimate
    advantage = vec_td_lambda_return_estimate(gamma, lmbda, next_state_value, reward, done, terminated)
    
  • a generic trainer class(1) that executes the aforementioned training loop. Through a hooking mechanism, it also supports any logging or data transformation operation at any given time.

  • various recipes to build models that correspond to the environment being deployed.

If you feel a feature is missing from the library, please submit an issue! If you would like to contribute to new features, check our call for contributions and our contribution page.

Examples, tutorials and demos

A series of examples are provided with an illustrative purpose:

and many more to come!

Check the examples markdown directory for more details about handling the various configuration settings.

We also provide tutorials and demos that give a sense of what the library can do.

Citation

If you're using TorchRL, please refer to this BibTeX entry to cite this work:

@misc{bou2023torchrl,
      title={TorchRL: A data-driven decision-making library for PyTorch}, 
      author={Albert Bou and Matteo Bettini and Sebastian Dittert and Vikash Kumar and Shagun Sodhani and Xiaomeng Yang and Gianni De Fabritiis and Vincent Moens},
      year={2023},
      eprint={2306.00577},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}

Installation

Create a conda environment where the packages will be installed.

conda create --name torch_rl python=3.9
conda activate torch_rl

PyTorch

Depending on the use of functorch that you want to make, you may want to install the latest (nightly) PyTorch release or the latest stable version of PyTorch. See here for a detailed list of commands, including pip3 or other special installation instructions.

Torchrl

You can install the latest stable release by using

pip3 install torchrl

This should work on linux, Windows 10 and OsX (Intel or Silicon chips). On certain Windows machines (Windows 11), one should install the library locally (see below).

The nightly build can be installed via

pip install torchrl-nightly

which we currently only ship for Linux and OsX (Intel) machines. Importantly, the nightly builds require the nightly builds of PyTorch too.

To install extra dependencies, call

pip3 install "torchrl[atari,dm_control,gym_continuous,rendering,tests,utils,marl,checkpointing]"

or a subset of these.

One may also desire to install the library locally. Three main reasons can motivate this:

  • the nightly/stable release isn't available for one's platform (eg, Windows 11, nightlies for Apple Silicon etc.);
  • contributing to the code;
  • install torchrl with a previous version of PyTorch (note that this should also be doable via a regular install followed by a downgrade to a previous pytorch version -- but the C++ binaries will not be available.)

To install the library locally, start by cloning the repo:

git clone https://github.com/pytorch/rl

Go to the directory where you have cloned the torchrl repo and install it (after installing ninja)

cd /path/to/torchrl/
pip install ninja -U
python setup.py develop

(unfortunately, pip install -e . will not work).

On M1 machines, this should work out-of-the-box with the nightly build of PyTorch. If the generation of this artifact in MacOs M1 doesn't work correctly or in the execution the message (mach-o file, but is an incompatible architecture (have 'x86_64', need 'arm64e')) appears, then try

ARCHFLAGS="-arch arm64" python setup.py develop

To run a quick sanity check, leave that directory (e.g. by executing cd ~/) and try to import the library.

python -c "import torchrl"

This should not return any warning or error.

Optional dependencies

The following libraries can be installed depending on the usage one wants to make of torchrl:

# diverse
pip3 install tqdm tensorboard "hydra-core>=1.1" hydra-submitit-launcher

# rendering
pip3 install moviepy

# deepmind control suite
pip3 install dm_control

# gym, atari games
pip3 install "gym[atari]" "gym[accept-rom-license]" pygame

# tests
pip3 install pytest pyyaml pytest-instafail

# tensorboard
pip3 install tensorboard

# wandb
pip3 install wandb

Troubleshooting

If a ModuleNotFoundError: No module named ‘torchrl._torchrl errors occurs (or a warning indicating that the C++ binaries could not be loaded), it means that the C++ extensions were not installed or not found.

  • One common reason might be that you are trying to import torchrl from within the git repo location. The following code snippet should return an error if torchrl has not been installed in develop mode:
    cd ~/path/to/rl/repo
    python -c 'from torchrl.envs.libs.gym import GymEnv'
    
    If this is the case, consider executing torchrl from another location.
  • If you're not importing torchrl from within its repo location, it could be caused by a problem during the local installation. Check the log after the python setup.py develop. One common cause is a g++/C++ version discrepancy and/or a problem with the ninja library.
  • If the problem persists, feel free to open an issue on the topic in the repo, we'll make our best to help!
  • On MacOs, we recommend installing XCode first. With Apple Silicon M1 chips, make sure you are using the arm64-built python (e.g. here). Running the following lines of code
    wget https://raw.githubusercontent.com/pytorch/pytorch/master/torch/utils/collect_env.py
    python collect_env.py
    
    should display
    OS: macOS *** (arm64)
    
    and not
    OS: macOS **** (x86_64)
    

Versioning issues can cause error message of the type undefined symbol and such. For these, refer to the versioning issues document for a complete explanation and proposed workarounds.

Asking a question

If you spot a bug in the library, please raise an issue in this repo.

If you have a more generic question regarding RL in PyTorch, post it on the PyTorch forum.

Contributing

Internal collaborations to torchrl are welcome! Feel free to fork, submit issues and PRs. You can checkout the detailed contribution guide here. As mentioned above, a list of open contributions can be found in here.

Contributors are recommended to install pre-commit hooks (using pre-commit install). pre-commit will check for linting related issues when the code is committed locally. You can disable th check by appending -n to your commit command: git commit -m <commit message> -n

Disclaimer

This library is released as a PyTorch beta feature. BC-breaking changes are likely to happen but they will be introduced with a deprecation warranty after a few release cycles.

License

TorchRL is licensed under the MIT License. See LICENSE for details.

Project details


Release history Release notifications | RSS feed

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distributions

No source distribution files available for this release.See tutorial on generating distribution archives.

Built Distributions

torchrl_nightly-2024.4.2-cp311-cp311-win_amd64.whl (887.5 kB view details)

Uploaded CPython 3.11 Windows x86-64

torchrl_nightly-2024.4.2-cp311-cp311-macosx_10_9_universal2.whl (1.1 MB view details)

Uploaded CPython 3.11 macOS 10.9+ universal2 (ARM64, x86-64)

torchrl_nightly-2024.4.2-cp310-cp310-win_amd64.whl (890.9 kB view details)

Uploaded CPython 3.10 Windows x86-64

torchrl_nightly-2024.4.2-cp310-cp310-macosx_10_15_x86_64.whl (933.1 kB view details)

Uploaded CPython 3.10 macOS 10.15+ x86-64

torchrl_nightly-2024.4.2-cp39-cp39-win_amd64.whl (888.2 kB view details)

Uploaded CPython 3.9 Windows x86-64

torchrl_nightly-2024.4.2-cp39-cp39-macosx_11_0_x86_64.whl (933.4 kB view details)

Uploaded CPython 3.9 macOS 11.0+ x86-64

torchrl_nightly-2024.4.2-cp38-cp38-win_amd64.whl (890.9 kB view details)

Uploaded CPython 3.8 Windows x86-64

torchrl_nightly-2024.4.2-cp38-cp38-macosx_11_0_x86_64.whl (933.0 kB view details)

Uploaded CPython 3.8 macOS 11.0+ x86-64

File details

Details for the file torchrl_nightly-2024.4.2-cp311-cp311-win_amd64.whl.

File metadata

File hashes

Hashes for torchrl_nightly-2024.4.2-cp311-cp311-win_amd64.whl
Algorithm Hash digest
SHA256 97239f9cd9508b23bf161151150ad6fd2de776bd9dc40f65f2cedcc913ba0aaf
MD5 322438b87852d1d32e9b25e9cbaca943
BLAKE2b-256 e4faafe0bd9b3142a77f57aec37c90390e79b54769d5c25617daf2f52b7702ba

See more details on using hashes here.

File details

Details for the file torchrl_nightly-2024.4.2-cp311-cp311-manylinux1_x86_64.whl.

File metadata

File hashes

Hashes for torchrl_nightly-2024.4.2-cp311-cp311-manylinux1_x86_64.whl
Algorithm Hash digest
SHA256 1a07c3dda22e2008d474497cbe5bc0f1815db12283e93350da1cdb5fa4ef2132
MD5 b33cb53737b44f66b86ec14dec8ab6c4
BLAKE2b-256 d8fb97f165120b636e82b96a1b64f6b10b4d9ebd54f58dec4cac63900f1908ad

See more details on using hashes here.

File details

Details for the file torchrl_nightly-2024.4.2-cp311-cp311-macosx_10_9_universal2.whl.

File metadata

File hashes

Hashes for torchrl_nightly-2024.4.2-cp311-cp311-macosx_10_9_universal2.whl
Algorithm Hash digest
SHA256 800e25cd31820135b3eded0466a0a35b33b6f61f50d67fd4cb18276e322a4fb2
MD5 687feb6f156df59f00fbd67b8fe674b4
BLAKE2b-256 cca2174a4a1eeb24729ae6e7c21cf8784be13a508c6aeef49e1a4f9fab58b234

See more details on using hashes here.

File details

Details for the file torchrl_nightly-2024.4.2-cp310-cp310-win_amd64.whl.

File metadata

File hashes

Hashes for torchrl_nightly-2024.4.2-cp310-cp310-win_amd64.whl
Algorithm Hash digest
SHA256 cf13d34dd813785af6a571f7f0601375462e96443395da97ec30f3c679342dea
MD5 815fcc4194052d2f330439c693586361
BLAKE2b-256 9402a8a661038dde17897ca6853cb48798b0b800a0154b5301bdfda7403426a6

See more details on using hashes here.

File details

Details for the file torchrl_nightly-2024.4.2-cp310-cp310-manylinux1_x86_64.whl.

File metadata

File hashes

Hashes for torchrl_nightly-2024.4.2-cp310-cp310-manylinux1_x86_64.whl
Algorithm Hash digest
SHA256 62888a57e6967349ccf03690b1556bcadb31f01b081b97b6a744036aa7bea4a0
MD5 46cecf1293c55394f4ae58d44c4b0627
BLAKE2b-256 ea5983ad3296d3f855b7fc3b1d2d9ef9ce776983d92ffb70dceafaf64a37554e

See more details on using hashes here.

File details

Details for the file torchrl_nightly-2024.4.2-cp310-cp310-macosx_10_15_x86_64.whl.

File metadata

File hashes

Hashes for torchrl_nightly-2024.4.2-cp310-cp310-macosx_10_15_x86_64.whl
Algorithm Hash digest
SHA256 7262b2edcd7a783036c3df8ac0bef52658474a628fd32a64eb06867f79109556
MD5 6c1e6cbe4e0eddcf430c040027291969
BLAKE2b-256 29758ec250b69c27fd6cdc40fdf217cc165d89e6c167036510c0695c872ddae8

See more details on using hashes here.

File details

Details for the file torchrl_nightly-2024.4.2-cp39-cp39-win_amd64.whl.

File metadata

File hashes

Hashes for torchrl_nightly-2024.4.2-cp39-cp39-win_amd64.whl
Algorithm Hash digest
SHA256 8ac4909f8de9fce4a53a7740b9635b8ecf410c66466c36319f5f625f92bc0a47
MD5 5b6ecb99cb547ed12a1a93ccbcf7e9ee
BLAKE2b-256 df1f3898bc8ee8048b2feff1a4b209aa6692e0ee02f2e1585e6948b61f33a294

See more details on using hashes here.

File details

Details for the file torchrl_nightly-2024.4.2-cp39-cp39-manylinux1_x86_64.whl.

File metadata

File hashes

Hashes for torchrl_nightly-2024.4.2-cp39-cp39-manylinux1_x86_64.whl
Algorithm Hash digest
SHA256 d1f9cc99fd349cd3df774031dca5f09e9900a2eb4b74dda0651b29140b0c59a1
MD5 85b41e3ae1467aef41d1d59780f72b47
BLAKE2b-256 ec9c4685d1a48e54aa652a0b58559391c412d4cddba24bb40c77f47fdd6d406f

See more details on using hashes here.

File details

Details for the file torchrl_nightly-2024.4.2-cp39-cp39-macosx_11_0_x86_64.whl.

File metadata

File hashes

Hashes for torchrl_nightly-2024.4.2-cp39-cp39-macosx_11_0_x86_64.whl
Algorithm Hash digest
SHA256 d9fd826d51bd2c9e56b676be00bc84af7c2556d5d3faa1ecd16af7e31a40adcf
MD5 7e7edfc14bbbae1d30b98c73ac67b60c
BLAKE2b-256 9f069f5b31bffa43920f36e343664d5472c45f2921778d1214bdb048aa8e7244

See more details on using hashes here.

File details

Details for the file torchrl_nightly-2024.4.2-cp38-cp38-win_amd64.whl.

File metadata

File hashes

Hashes for torchrl_nightly-2024.4.2-cp38-cp38-win_amd64.whl
Algorithm Hash digest
SHA256 30fb84a7880c0f648b7f67b32b39447ec4e02450c18d5491573d6726a78a8ddd
MD5 cc28dfc16de5d19fb36d50cc343688aa
BLAKE2b-256 bdd2c5e00fc0c5dcb636f4795ecb5f781f565de4e805d8ede2286bdcd15626cc

See more details on using hashes here.

File details

Details for the file torchrl_nightly-2024.4.2-cp38-cp38-manylinux1_x86_64.whl.

File metadata

File hashes

Hashes for torchrl_nightly-2024.4.2-cp38-cp38-manylinux1_x86_64.whl
Algorithm Hash digest
SHA256 57e332e2f3c14d4f6d30b74a1f3f1f2975ca4a0676ad37f62c46016caa7c7391
MD5 5195166a04cc66283359cd98cfe43574
BLAKE2b-256 bbf0cfcd4f264a227f3007c4ff84fefc49f73bf330462fd39e2c075b03c3de0c

See more details on using hashes here.

File details

Details for the file torchrl_nightly-2024.4.2-cp38-cp38-macosx_11_0_x86_64.whl.

File metadata

File hashes

Hashes for torchrl_nightly-2024.4.2-cp38-cp38-macosx_11_0_x86_64.whl
Algorithm Hash digest
SHA256 5a8c703847a994dccc32286941c6ad0badc788fb4f3323f46e9f4845c4b4455e
MD5 7b931314a9d73acfeedbd5317f3809d1
BLAKE2b-256 9591562243c9ae308395ccff9b1fb46f990f6423c5a2c79fb52d45d295fe9acc

See more details on using hashes here.

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page