rl
v0.6.0: compiled losses and partial steps
Dokumentation | TensSarbict | Funktionen | Beispiele, Tutorials und Demos | Zitat | Installation | Eine Frage stellen | Beitragen
Torchrl ist eine Open-Source-Bibliothek für Verstärkung (RL) für Pytorch.
Lesen Sie das vollständige Papier für eine kuratiertere Beschreibung der Bibliothek.
Sehen Sie sich unsere Tutorials für die Erste Schritte an, um sich schnell mit den grundlegenden Funktionen der Bibliothek zu verbessern!
Die Torchrl -Dokumentation finden Sie hier. Es enthält Tutorials und die API -Referenz.
Torchrl bietet auch eine RL -Wissensbasis, mit der Sie Ihren Code debuggen oder einfach die Grundlagen von RL lernen können. Schau es dir hier an.
Wir haben einige Einführungsvideos für Sie, um die Bibliothek besser kennenzulernen, und schauen Sie sich an:
Torchrl ist domänen-agnostisch, Sie können es in vielen verschiedenen Feldern verwenden. Hier sind einige Beispiele:
TensorDict RL-Algorithmen sind sehr heterogen, und es kann schwierig sein, eine Codebasis über Einstellungen hinweg zu recyceln (z. B. von online bis offline, von staatlich basiert bis pixelbasiert). Torchrl löst dieses Problem durch TensorDict , eine bequeme Datenstruktur (1) , mit der die RL -Codebasis eigene RL -Codebasis optimiert werden kann. Mit diesem Tool kann man ein komplettes PPO -Trainingsskript in weniger als 100 Codezeilen schreiben!
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 = { "low" : - 1.0 , "high" : 1.0 },
return_log_prob = True
)
buffer = TensorDictReplayBuffer (
storage = LazyTensorStorage ( 1000 ),
sampler = SamplerWithoutReplacement (),
batch_size = 50 ,
)
collector = SyncDataCollector (
env ,
actor ,
frames_per_batch = 1000 ,
total_frames = 1_000_000 ,
)
loss_fn = ClipPPOLoss ( actor , critic )
adv_fn = GAE ( value_network = critic , average_gae = True , gamma = 0.99 , lmbda = 0.95 )
optim = torch . optim . Adam ( loss_fn . parameters (), lr = 2e-4 )
for data in collector : # collect data
for epoch in range ( 10 ):
adv_fn ( data ) # compute advantage
buffer . extend ( data )
for sample in buffer : # consume data
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 } " ) Hier ist ein Beispiel dafür, wie sich die Umgebungs -API auf TensSudict stützt, um Daten von einer Funktion zur anderen während einer Rollout -Ausführung zu übertragen: 
TensorDict können Sie sich leicht um Umgebungen, Modelle und Algorithmen in Code in Bezug auf Umgebungen, Modelle und Algorithmen wiedergeben.
So codiert beispielsweise eine 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 operationsMit diesem Fall werden die Eingangs- / Ausgangssignaturen der Module, Env, Sammler, Wiederholungspuffer und Verluste der Bibliothek abstrahiert, sodass alle Primitiven leicht über Einstellungen recycelt werden können.
Hier ist ein weiteres Beispiel für eine Off-Policy-Trainingsschleife in Torchrl (unter der Annahme, dass ein Datensammler, ein Wiederholungspuffer, ein Verlust und ein Optimierer instanziiert wurden):
- 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()Diese Trainingsschleife kann über Algorithmen hinweg wiederverwendet werden, da sie eine minimale Anzahl von Annahmen über die Struktur der Daten ergibt.
TENSELLECICT unterstützt mehrere Tensoroperationen auf seinem Gerät und seiner Form (die Form des TensSudicts oder seine Chargengröße ist die übliche willkürliche N -erste Abmessungen aller enthaltenden Tensoren):
# 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_ () TensSortict hat ein dediziertes tensordict.nn -Modul, das alles enthält, was Sie möglicherweise benötigen, um Ihr Modell damit zu schreiben. Und es ist functorch und torch.compile -kompatibel!
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"] Mit der TensorDictSequential -Klasse werden Sequenzen von nn.Module -Instanzen auf sehr modulare Weise verzweigt. Beispielsweise finden Sie hier eine Implementierung eines Transformators mit den Encoder- und Decoderblöcken:
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 können Untergraphen isolieren, indem ein Satz gewünschter Eingangs- / Ausgabetasten abfragt:
transformer . select_subsequence ( out_keys = [ "memory" ]) # returns the encoder
transformer . select_subsequence ( in_keys = [ "tgt" , "memory" ]) # returns the decoderÜberprüfen Sie die Tenssrator -Tutorials, um mehr zu erfahren!
Eine gemeinsame Schnittstelle für Umgebungen, die gemeinsame Bibliotheken (OpenAI Gym, DeepMind Control Lab usw.) (1) und staatliche Ausführung (z. B. modellbasierte Umgebungen) unterstützt. Die Container der Charge -Umgebungen ermöglichen eine parallele Ausführung (2) . Es wird ebenfalls eine gemeinsame Pytorch-First-Klasse von Tensor-Specification-Klasse bereitgestellt. Die Umgebungs -API von Torchrl ist einfach, aber streng und spezifisch. Überprüfen Sie die Dokumentation und das Tutorial, um mehr zu erfahren!
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 TrueMultiprozess und verteilte Datensammler (2) , die synchron oder asynchron funktionieren. Durch den Einsatz von TensSudict werden die Trainingsschleifen von Torchrl den regulären Trainingsschleifen im überwachten Lernen sehr ähnlich (obwohl der "Dataloader"-Lesedatenkollektor-auf die Fliege geändert wird):
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_ ()Weitere Informationen zur ultraschnellen Datenerfassung mit Torchrl finden Sie in unseren Distributed Collector-Beispielen.
Effiziente (2) und generische (1) Wiederholungspuffer mit modularisiertem Speicher:
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
)Wiederholungspuffer werden auch als Wrapper für gemeinsame Datensätze für Offline RL angeboten:
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-Libry Environment transformiert (1) , die auf dem Gerät ausgeführt und auf vektorisierte Weise (2) ausgeführt wird, die die Daten verarbeiten und vorbereiten, die aus den Umgebungen stammen, die vom Agenten verwendet werden sollen:
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" ) Weitere Transformationen sind: Belohnungsskalierung ( RewardScaling ), Formoperationen (Verkettung von Tensoren, Unversehrung usw.), Verkettung von aufeinanderfolgenden Operationen ( CatFrames ), Größenänderung ( Resize ) und vieles mehr.
Im Gegensatz zu anderen Bibliotheken werden die Transformationen als Liste gestapelt (und nicht ineinander eingewickelt), was es einfach macht, sie nach Belieben hinzuzufügen und zu entfernen:
env . insert_transform ( 0 , NoopResetEnv ()) # inserts the NoopResetEnv transform at the index 0Dennoch können Transformationen auf die übergeordnete Umgebung zugreifen und auf Vorgänge ausführen:
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 transformVerschiedene Werkzeuge für verteiltes Lernen (z. B. Tensoren des z.
Verschiedene Architekturen und Modelle (z. B. Schauspielerkritiker) (1) :
# 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 ()Erkundungsverpackungen und Module, um leicht zwischen Erkundung und Ausbeutung zu tauschen (1) :
policy_explore = EGreedyWrapper ( policy )
with set_exploration_type ( ExplorationType . RANDOM ):
tensordict = policy_explore ( tensordict ) # will use eps-greedy
with set_exploration_type ( ExplorationType . DETERMINISTIC ):
tensordict = policy_explore ( tensordict ) # will not use eps-greedyEine Reihe effizienter Verlustmodule und stark vektorisierter funktionaler Rendite und Vorteilsberechnung.
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 ) 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 )Eine generische Trainerklasse (1), die die oben genannte Trainingsschleife ausführt. Durch einen Hooking -Mechanismus unterstützt es zu einem bestimmten Zeitpunkt auch jegliche Protokollierungs- oder Datentransformationsoperation.
Verschiedene Rezepte zum Erstellen von Modellen, die der Einsatzumgebung entsprechen.
Wenn Sie der Meinung sind, dass eine Funktion in der Bibliothek fehlt, geben Sie bitte ein Problem ein! Wenn Sie zu neuen Funktionen beitragen möchten, überprüfen Sie unseren Aufruf nach Beiträgen und unsere Beitragsseite.
Eine Reihe hochmoderner Implementierungen wird mit einem veranschaulichen Zweck versehen:
| Algorithmus | Support kompilieren ** | TensSudrict-freie API | Modulare Verluste | Kontinuierlich und diskret |
| DQN | 1,9x | + | N / A | + (durch ActionDiscretizer -Transformation) |
| DDPG | 1,87x | + | + | - (nur kontinuierlich) |
| Iql | 3.22x | + | + | + |
| CQL | 2.68x | + | + | + |
| Td3 | 2.27x | + | + | - (nur kontinuierlich) |
| TD3+BC | ungetestet | + | + | - (nur kontinuierlich) |
| A2C | 2.67x | + | - - | + |
| PPO | 2.42x | + | - - | + |
| SACK | 2.62x | + | - - | + |
| Redq | 2.28x | + | - - | - (nur kontinuierlich) |
| Träumer v1 | ungetestet | + | + (verschiedene Klassen) | - (nur kontinuierlich) |
| Entscheidungstransformatoren | ungetestet | + | N / A | - (nur kontinuierlich) |
| Crossq | ungetestet | + | + | - (nur kontinuierlich) |
| Gail | ungetestet | + | N / A | + |
| Impala | ungetestet | + | - - | + |
| IQL (Marl) | ungetestet | + | + | + |
| DDPG (MARL) | ungetestet | + | + | - (nur kontinuierlich) |
| PPO (Margel) | ungetestet | + | - - | + |
| QMIX-VDN (Marl) | ungetestet | + | N / A | + |
| SAC (Margel) | ungetestet | + | - - | + |
| Rlhf | N / A | + | N / A | N / A |
** Die Zahl zeigt die erwartete Geschwindigkeit im Vergleich zum eifrigen Modus an, wenn sie auf der CPU ausgeführt werden. Die Zahlen können je nach Architektur und Gerät variieren.
Und noch viele zu kommen!
Code -Beispiele, die Spielzeugcode -Snippets und Trainingsskripte anzeigen, sind ebenfalls verfügbar
Weitere Informationen zum Umgang mit den verschiedenen Konfigurationseinstellungen finden Sie im Beispielverzeichnis.
Wir bieten auch Tutorials und Demos, die ein Gefühl dafür geben, was die Bibliothek tun kann.
Wenn Sie Torchrl verwenden, finden Sie diesen Bibtex -Eintrag, um diese Arbeit zu zitieren:
@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}
}
Erstellen Sie eine Conda -Umgebung, in der die Pakete installiert werden.
conda create --name torch_rl python=3.9
conda activate torch_rl
Pytorch
Abhängig von der Verwendung von Functorch, die Sie erstellen möchten, möchten Sie möglicherweise die neueste (abendliche) Pytorch -Version oder die neueste stabile Version von Pytorch installieren. Hier finden Sie eine detaillierte Liste von Befehlen, einschließlich pip3 oder anderen speziellen Installationsanweisungen.
Torchrl
Sie können die neueste stabile Version mithilfe verwenden
pip3 install torchrlDies sollte unter Linux, Windows 10 und OSX (Intel oder Siliziumchips) funktionieren. Unter bestimmten Windows -Maschinen (Windows 11) sollte die Bibliothek lokal installiert werden (siehe unten).
Der nächtliche Build kann durch installiert werden
pip3 install torchrl-nightlyWas wir derzeit nur für Linux- und OSX (Intel) -Maschinen versenden. Wichtig ist, dass die nächtlichen Builds auch die nächtlichen Builds von Pytorch erfordern.
Um zusätzliche Abhängigkeiten zu installieren, rufen Sie an
pip3 install " torchrl[atari,dm_control,gym_continuous,rendering,tests,utils,marl,open_spiel,checkpointing] "oder eine Teilmenge davon.
Man kann auch die Bibliothek vor Ort installieren. Drei Hauptgründe können dies motivieren:
Um die Bibliothek lokal zu installieren, klonen Sie zunächst das Repo:
git clone https://github.com/pytorch/rlUnd vergessen Sie nicht, den Zweig oder Tag für den Build zu überprüfen: Tag, den Sie für den Build verwenden möchten:
git checkout v0.4.0 Gehen Sie in das Verzeichnis, in dem Sie das Torchrl -Repo geklont haben, und installieren Sie es (nach der Installation ninja )
cd /path/to/torchrl/
pip3 install ninja -U
python setup.py developMan kann die Räder auch bauen, um Kollegen zu verteilen
python setup.py bdist_wheel Ihre Räder werden dort gespeichert ./dist/torchrl<name>.whl und installierbar über
pip install torchrl < name > .whl WARNUNG : Leider pip3 install -e . funktioniert derzeit nicht. Beiträge, um dies zu beheben, sind willkommen!
Auf M1-Maschinen sollte dies mit dem nächtlichen Aufbau von Pytorch aus dem Feld funktionieren. Wenn die Erzeugung dieses Artefakts in MacOS M1 nicht richtig oder in der Ausführung funktioniert (mach-o file, but is an incompatible architecture (have 'x86_64', need 'arm64e'))
ARCHFLAGS="-arch arm64" python setup.py develop
Lassen Sie das Verzeichnis (z. B. durch Ausführen cd ~/ ) und versuchen Sie, die Bibliothek zu importieren.
python -c "import torchrl"
Dies sollte keine Warnung oder Fehler zurückgeben.
Optionale Abhängigkeiten
Die folgenden Bibliotheken können je nach Verwendung installiert werden, die man von Torchrl herstellen möchte:
# 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
Fehlerbehebung
Wenn ein ModuleNotFoundError: No module named 'torchrl._torchrl -Fehler auftritt (oder eine Warnung, die angibt, dass die C ++ - Binärdateien nicht geladen werden konnten), bedeutet dies, dass die C ++ - Verlängerungen nicht installiert oder nicht gefunden wurden.
develop nicht installiert wurde: cd ~/path/to/rl/repo
python -c 'from torchrl.envs.libs.gym import GymEnv'
python setup.py develop . Eine gemeinsame Ursache ist eine G ++/C ++ - Versionsdiskrepanz und/oder ein Problem mit der ninja -Bibliothek. wget https://raw.githubusercontent.com/pytorch/pytorch/master/torch/utils/collect_env.py
python collect_env.py
OS: macOS *** (arm64)
OS: macOS **** (x86_64)
Versioningprobleme können zu Fehlermeldungen des und undefined symbol und dergleichen führen. Weitere Informationen finden Sie im Versioning -Problem -Dokument für eine vollständige Erklärung und eine vorgeschlagene Problemumgehung.
Wenn Sie einen Fehler in der Bibliothek erkennen, wehren Sie bitte ein Problem in diesem Repo an.
Wenn Sie eine allgemeinere Frage zu RL in Pytorch haben, posten Sie sie im Pytorch -Forum.
Interne Kooperationen an Torchrl sind willkommen! Fühlen Sie sich frei, Gabel zu geben, Probleme und PRs einzureichen. Hier können Sie den detaillierten Beitragshandbuch hier auschecken. Wie oben erwähnt, finden Sie hier eine Liste offener Beiträge.
Mitwirkenden werden empfohlen, Vorkommiten-Hooks zu installieren (mithilfe pre-commit install ). Pre-Commit prüft nach linten Problemen, wenn der Code lokal begangen wird. Sie können den Scheck deaktivieren, indem Sie -n an Ihren Commit -Befehl anhängen: git commit -m <commit message> -n
Diese Bibliothek wird als Pytorch Beta -Funktion veröffentlicht. BC-Breaking-Änderungen werden wahrscheinlich stattfinden, sie werden jedoch nach einigen Freisetzungszyklen mit einer Abschaltgarantie eingeführt.
Torchrl ist unter der MIT -Lizenz lizenziert. Weitere Informationen finden Sie in Lizenz.
