Saravanan666/pypi-org huggingface dataset:
Package: rld
A development tool for evaluation and interpretability of reinforcement learning agents.InstallationpipinstallrldUsageFirstly, calculate attributations for your rollout using:rldattribute[--rllib][--out<ROLLOUT>]config.py<INPUT_ROLLOUT>This will takeINPUT_ROLLOUT(possibly in the Ray RLlib format, if--rllibis set)
and calculate attributations for each timestep in each trajectory,
using the configuration stored inconfig.py.
The output file will be stored asROLLOUT.
See theConfigclass for possible configuration.Once the attributations are calculated, you can visualize them using:rldstart--viewer<VIEWER_ID><ROLLOUT>See theexamplesfor reference.Descriptionrld provides a set of tools to evaluate and understand behaviors of reinforcement
learning agents. Under the hood, rld usesCaptumto calculate
attributations of observation components. rld is also integrated withRay RLliblibrary and allows to load agents trained in RLlib.Current limitationsrld is currently in its early development stage, thus the functionality is very limited.RL algorithmsrld is algorithm-agnostic, but currently it is more suitable for policy-based methods.
This is due to the fact that theModelis now expected to output logits for a given
observation. This, however, will change in the future, and rld will support more
algorithms.ViewersThis is the list of viewers, which ship with rld:nonecartpoleatariYou can easily create your own viewer, for your own environment, but to make it visible
for rld, you have to rebuild the project. This will be improved in the future.Observation and action spacesThe table below presents currently supported observation and action spaces.Action spaceDiscreteMultiDiscreteObs spaceBox:heavy_check_mark::heavy_check_mark:Dict:heavy_check_mark::heavy_check_mark:RoadmapSee theissuespage to see the list of
features planned for the future releases. If you have your own ideas,
you are encouraged to post them there.
Package: rldog
PyRLEnvironment Agnostic RL algorithm implementations using Pytorch. High quality code, typehints, thorough tests, examples.
Also uses minibatches correctly, which most public libraries don't implement.See examples for some, well, examples. Algos implemented:Deep Q Learning (DQN)(Mnih et al. 2013)--- UPCOMING ---DQN Experience Replay(Mnih et al. 2013)DQN with Fixed targets(Mnih et al. 2013)Double Q Learning (DDQN)(arXiv:1509.06461v3 [cs.LG] 8 Dec 2015)REINFORCE(Richard S. Sutton et al 1999)Advantage Actor Critic (arXiv:1611.06256)PPOWhat i'm happy with
Quality of the code, thorough tests, majority of functionality, ease of use & versatilityRun tests with: pytest tests
Package: rlenv
Copyright (c) 2019-2022 Accenta (www.accenta.ai)Web site:https://gitlab.com/ens-data-challenge/accenta-gym-environmentOnline documentation:https://ens-data-challenge.gitlab.io/accenta-gym-environmentExamples:https://ens-data-challenge.gitlab.io/accenta-gym-environment/gallery/Source code:https://gitlab.com/ens-data-challenge/accenta-gym-environmentIssue tracker:https://gitlab.com/ens-data-challenge/accenta-gym-environment/issuesDescriptionAccenta Gym EnvironmentNote:This project is still in beta stage, so the API is not finalized yet.DependenciesC.f. requirements.txtInstallationPosix (Linux, MacOSX, WSL, …)From the EnergyPlus Python source code:conda deactivate         # Only if you use Anaconda...
python3 -m venv env
source env/bin/activate
python3 -m pip install --upgrade pip
python3 -m pip install -r requirements.txt
python3 setup.py developWindowsFrom the EnergyPlus Python source code:conda deactivate         # Only if you use Anaconda...
python3 -m venv env
env\Scripts\activate.bat
python3 -m pip install --upgrade pip
python3 -m pip install -r requirements.txt
python3 setup.py developBuild and run the Accenta Gym Environment Docker imageBuild the docker imageFrom the EnergyPlus Python source code:docker build -t registry.gitlab.com/ens-data-challenge/accenta-gym-environment .Run unit tests from the docker containerFrom the EnergyPlus Python source code:docker run registry.gitlab.com/ens-data-challenge/accenta-gym-environment pytestRun an example from the docker containerFrom the EnergyPlus Python source code:docker run registry.gitlab.com/ens-data-challenge/accenta-gym-environment python3 /rlenv/examples/plot_wall_env.pyPush the docker image on the container registryFrom the EnergyPlus Python source code:docker push registry.gitlab.com/ens-data-challenge/accenta-gym-environmentDocumentationOnline documentation:https://ens-data-challenge.gitlab.io/accenta-gym-environmentAPI documentation:https://ens-data-challenge.gitlab.io/accenta-gym-environment/api.htmlExample usageC.f.https://ens-data-challenge.gitlab.io/accenta-gym-environment/gallery/Bug reportsTo search for bugs or report them, please use the Accenta’s Gym Environments Bug Tracker at:https://gitlab.com/accenta_group/ai-gym/issues
Package: rlenvironments
rlenvironmentsrlenvironmentsis a Python library that provides an environment calledTargetSeekerfor reinforcement learning tasks involving target seeking. It allows agents to navigate towards a target point in a bounded environment.Installationpip install rlenvironmentsUsageTo use theTargetSeekerenvironment, you can follow this example:fromrlenvironments.target_seekerimportTargetSeeker# Create an instance of TargetSeeker environmentenv=TargetSeeker(image_option='show',output_interval=5)for_inrange(20):# Reset the environmentstate=env.reset()whilenotenv.episode_ended:# Choose an actionaction=env.random_action()# Take a step in the environmentnext_state,reward,done=env.step(action)# Do something with the results[Output1](https://github.com/ukoksoy/rlenvironments/blob/main/rlenvironments/target_seeker_images/output1.png)[Output2](https://github.com/ukoksoy/rlenvironments/blob/main/rlenvironments/target_seeker_images/output2.png)[Output3](https://github.com/ukoksoy/rlenvironments/blob/main/rlenvironments/target_seeker_images/output3.png)[Output4](https://github.com/ukoksoy/rlenvironments/blob/main/rlenvironments/target_seeker_images/output4.png)
Package: rlenvs
Reinforcement Learning EnvironmentsThis package is to simplify life for doing RL experiments by providing easily generatable RL environments that can be used to test out RL algorithms.This is still work in progress, however, hopefully this will serve as a useful feature for exact RL experiments in a reproducible, light-weight and scientific manner.Getting Started.InstallationInstalling with PyPipip3installrlenvsInstalling from sourcegit clone https://github.com/ai-nikolai/rl-environments
cd rl-environments
pip3 install -e .Examples:Banditfromrlenvs.banditsimportMultiarmBernoulliBanditenv=MultiarmBernoulliBandit(arms=5)reward,observation,is_finished,internal_state=env.step(0)#picks arm 0Tree MDPfromrlenvs.mdpsimportBalancedDenseTreeDeterministicMDPenv=BalancedDenseTreeDeterministicMDP(branching=3,depth=5)#creates a tree with 3 choices each turn and a total of 5 turns.reward,observation,is_finished,internal_state=env.step(3)#picks arm 0This is how such an environment would look like:Documentation:Overview:Overall, this package provides environments, whose API is quite similar to the environments provided by Deepmind and OpenAI. (for interoperability.)That is the interface provided by every environment:classBaseEnvironment(object):"""Implements the following methods inspired by both OpenAI gym and Deepmind Bsuite (dm_env).:initialise() -> observation, resets and initialises the environment and returns first observation::step(action) -> reward(float), observation(Optional[Any]), is_finished(bool), state(Optional[Any])::reset() -> "resets the environement"::undo() -> "goes to the previous state of the environment" reward, observation, is_finished(bool), sate(Optional[Any])::go_to_state(state) -> "goes to a specific state of the environment" is_finished(bool)::seed(int) -> "sets the seed"::render() -> "renders the environment"::get_specs() -> returns the custom specs of the environment:"""Troubleshooting / FAQs:Requirements: (What are the requirements):In the future this will hopefully be configurablepython >= 3.6
networkx
graphviz
...Copyright (C) - Nikolai Rozanov 2020-Present
Package: rl-envs-forge
rl-envs-forgeLightweight environments for reinforcement learning applications.Table of Contentsrl-envs-forgeTable of ContentsInstallationEnvironmentsLabyrinthLabyrinth rendered exampleKArmedBanditKArmedBandit rendered exampleGridWorldGridWorld rendered exampleACMLUsageTestsLicenseContact & SupportInstallationpipinstallrl-envs-forgeEnvironmentsLabyrinthLabyrinth is a classic maze-solving environment, where the goal is to navigate from a start point to a target. The maze layout is randomly generated based on a set of parametrizable arguments.📖Detailed Documentation:Click here to read more about the Labyrinth environmentLabyrinth rendered exampleKArmedBanditKArmedBandit is a bandit environment, which returns a reward from a distribution associated with the chosen arm at each timestep. This implementation includes multiple distributions, and the possibility to shift the distribution parameters during sampling.📖Detailed Documentation:Click here to read more about the KArmedBandit environmentKArmedBandit rendered exampleGridWorldGridWorld is a customizable grid-based environment for reinforcement learning, featuring adjustable grid size, start and terminal states, walls, and special transitions. Each action taken by the agent results in a transition within the grid, adhering to the defined rules and probabilities.📖Detailed Documentation:Click here to read more about the GridWorld environmentGridWorld rendered exampleACMLThe Adaptive Computation and Machine Learning (ACML) environments are toy environments proposed in Reinforcement Learning: An Introduction* (2nd ed.).📖Detailed Documentation:Click here to read more about the ACML environmentsUsageExample code on setting up and testing the Labyrinth environment.Note, this code snippet produced the render visible in sectionLabyrinthfromtimeimportsleepfromrl_envs_forge.envs.labyrinth.labyrinthimportLabyrinthenv=Labyrinth(20,20,seed=0)done=Falsequit_event=Falsewhilenotdoneandnotquit_event:action=env.action_space.sample()observation,reward,done,truncated,info=env.step(action)quit_event,_=env.render()sleep(0.1)TestsRequirements: pytest and pytest-covRun the tests in the root folder with:pytesttestsLicenseThis project is licensed under theMIT License.Contact & SupportFor any queries or support, or if you would like to contribute to this project, reach out atmarius.dragomir.dgm@gmail.comor raise an issue on our GitHub repository.
Package: rlephant
RLephantA simple tool for writing and reading episodes of reinforcement learning environments to and from disk.FeaturesConvenient interface for constructing episodes and transitions in MDP's. Episodes can be accessed using
slicing along the time dimension.Efficient persistence on disk using the H5 file format.Only minimal dependencies.InstallationInstall latest stable release frompypi:pipinstallrlepehantFor the latest version in the repository, you can directly install it from there:pipinstallgit+https://github.com/axelbr/elephant.git#egg=rlephantUsageThis simple example shows the basic usage ofrlephant. More examples can be found inexamples.importrlephantimportgymenv=gym.make('CartPole-v0')env.reset()# Create an instance of ReplayStorage.storage=rlephant.ReplayStorage('cartpole.h5')# Create a new episode.episode=rlephant.Episode()action=env.action_space.sample()obs,reward,done,info=env.step(action)# Construct a new transition. Note that currently only# dictionaries are supported for actions and observations.transition=rlephant.Transition(observation={'some_obs':obs},action={'some_action':action},reward=reward,done=done)# Append the transition to the episode...episode.append(transition)# ... and save it to disk.storage.save(episode)# Now you can access the episodes and transitions using slicing.last_episode=storage[-1]fortransitioninlast_episode:print(transition)ToolsTo print a summary of a collection, you can use the built in command line
toolsummary. It will print information such as the number of episodes, episode
stats etc. to the console.Usage:python -m rlephant.summary <path_to_collection>
Package: rlfl
===========RLFL. RogueLike Function Library===========Version 2.3This is a collection of functions for roguelike games for use with the python programming language. FOV,pathfinding, projection, LOS and various helper functions. This is here to aid me in my hobby to createa python roguelike. The aim is to build on alot more AI and fun stuff.There are a number of examples in the examples directory.This is not a display library and contains no display functions.Documentation available here:http://packages.python.org/rlfl/index.htmlInstallation============python3 setup.py installORpython setup.py installThenimport rlflCompile instructions (makefile).--------------------------------create a makefile (see makefile_32x or makefile_64x examples) and simply `make rlfl-python`. To usewith python place the `rlfl.so` file in your python path and `import rlfl`. Make sure to specifythe python lib version you wish to compile against. Currently tested against python2.7 andpython3.2You will need python development headers installedRLF can be built into a c lib without python support with `make rlfl`.This code has not been tested on windows.Credit list===========The code here is a collection of fragments and inspirations from various roguelikes, libraries and othersources, adapted or modified, including but not limited to:* Angband		http://rephial.org/* T.O.M.E		http://te4.org/download* libtcod		http://doryen.eptalys.net/libtcod/* hengband		http://hengband.sourceforge.jp/en/* roguebasin		http://roguebasin.roguelikedevelopment.org* Brogue		http://sites.google.com/site/broguegame/If you feel you should be mentioned, please drop me a line.<jtm@robot.is>
Package: rlflow
===============================RLFlow===============================.. image:: https://img.shields.io/pypi/v/rlflow.svg:target: https://pypi.python.org/pypi/rlflow.. image:: https://img.shields.io/travis/tpbarron/rlflow.svg:target: https://travis-ci.org/tpbarron/rlflow.. image:: https://readthedocs.org/projects/rlflow/badge/?version=latest:target: https://rlflow.readthedocs.io/en/latest/?badge=latest:alt: Documentation Status.. image:: https://pyup.io/repos/github/tpbarron/rlflow/shield.svg:target: https://pyup.io/repos/github/tpbarron/rlflow/:alt: UpdatesA framework for learning about and experimenting with reinforcement learning algorithms.It is built on top of TensorFlow and `TFLearn <http://tflearn.org/>`_  and is interfaceswith the OpenAI gym (universe should work, too). It aims to be as modular as possible sothat new algorithms and ideas can easily be tested. I started it to gain a betterunderstanding of core RL algorithms and maybe it can be useful for others as well.Features--------Algorithms (future algorithms italicized):- MDP algorithms+ Value iteration+ Policy iteration- Temporal Difference Learning+ SARSA+ Deep Q-Learning+ *Policy gradient Q-learning*- Gradient algorithms+ Vanilla policy gradient+ *Deterministic policy gradient*+ *Natural policy gradient*- Gradient-Free algorithms+ *Cross entropy method*Function approximators (defined by TFLearn model):- Linear- Neural network- *RBF*Works with any OpenAI gym environment.Future Enhancements-------------------* Improved TensorBoard logging* Improved model snapshotting to include exploration states, memories, etc.* Any suggestions?Fixes------------------* Errors / warnings on TensorFlow session saveLicense------------------* Free software: MIT license* Documentation: https://rlflow.readthedocs.io.=======History=======0.1.2/3 (2016-17-15)------------------* Improving meta data and fixing __init__ scripts to load subpackages properly0.1.0 (2016-16-15)------------------* First release on PyPI.
Package: rlforge
RLForgeRL Forge is an open source reinforcement learning library that aims to provide the users with useful functions for the development of Reinforcement Learning Agents. The library also includes multiple popular reinforcement learning agents and environments, in addition, it is designed to be compatible with the gymnasium library (previous OpenAI Gym).InstallationIf you already have Python installed in your computer, you can install RLForge with:pip install rlforgeThis will download and install the latest stable release ofrlforgeavailable in thePython Package Index.RLForge works with Python 3.9 or later, intalling RLForge withpipwill automatically download all required packages if they are not present in your workspace.DocumentationThe documentation, with examples, can be found inRead the Docs(NOTE:Currently the documentation is under development and is not totaly complete).ExamplesMultiple examples on how to use the different agents are included in theexamples folder. These examples include using the library both with gymnasium environments and environments included in this package.SARSA - Frozen LakeDyna Architecture - Planning AgentsTabular Methods ComparisonFunction Approximation with Tile Coding and Q learning - Mountain CarTile Coding Q learning - Mecanum Car EnvironmentTile Coding Q learning - Obstacle Avoidance EnvironmentTile Coding Q learning - Trajectory Tracking EnvironmentDQN - Mountain CarSoftmax and Gaussian Actor Critic - Pendulum
Package: rlgraph
RLgraph is a framework to quickly prototype, define and execute reinforcement learning
algorithms both in research and practice. RLgraph supports both
TensorFlow (or static graphs in general) and Pytorch (eager/define-by run execution) through
a single component based interface. An introductory blogpost can be found here:https://rlgraph.github.io/rlgraph/2019/01/04/introducing-rlgraph.html
Package: rlgridworld
RLGridWorldThis is a simple yet efficient, highly customizable grid-world implementation to run reinforcement learning algorithms.The official documentation is herehttps://rlgridworld.readthedocs.io/ <https://rlgridworld.readthedocs.io/>_install with.. code-block:: bashpip install rlgridworldEnvironmentYou can simply use a string like.. code-block:: textW H T O W
W O O H W
W O A O W
W O O T W
W W W W Wto represent a grid-world, where* A: Agent
* T: Target location
* O: Empty Ground spot (where the agent can step on and stay)
* W: Wall
* H: Hole (where the agent will fall if it steps in)The single_rgb_array rendering of which is:.. image:: imgs/ExampleFile.png
:width: 400
:alt: Alternative textThe goal of the agent is to reach one of the Target locations without falling into a hole or falling out of the edge.
(More pre-configured environments can be found in EnvSettings)ActionsThe actions can be continuous or discrete. The agent can also move diagonally.
The details can be found in the Action class in rlgridworld/gridenv.py* Continuous: Action is a tuple of length 2, where the first element is the x-axis and the second element is the y-axis
* Discrete: Action can be chosen from ['UP', 'DOWN', 'RIGHT', 'LEFT', 'UPRIGHT', 'UPLEFT', 'DOWNRIGHT', 'DOWNLEFT']RewardCustomizable with r_fall_off, r_reach_target, r_timeout, r_continue.
The details can be found in theinitfunction of class GridEnv in rlgridworld/gridenv.py
Package: rlgym
The Rocket League GymThis is a python API that can be used to treat the gameRocket Leagueas though it were anOpenAI Gym-style environment for Reinforcement Learning projects. This API must be used with the accompanying Bakkesmod plugin.RequirementsA Windows 10 PCRocket League (Both Steam and Epic are supported)BakkesmodThe RLGym plugin for Bakkesmod (It's installed automatically by pip)Python between versions 3.7 and 3.9 (3.10 not supported).InstallationInstall the library via pip:pip install rlgymOnce the API is installed, you will need to enable the RLGym plugin from inside the Bakkesmod plugin manager. To do this, first launch the game, then press F2 to open the Bakkesmod menu. Navigate to thepluginstab and open thePlugin Manager. From there, scroll down until you find the RLGym plugin, and enable it. Close the game when this is done.RLGym is now installed! simply runexample.pyfrom our repo to ensure everything works.UsageFor tutorials and documentation, please visit ourWiki.
Package: rlgym-rocket-league
The Rocket League GymThis is a python API that can be used to treat the gameRocket Leagueas though it were anOpenAI Gym-style environment for Reinforcement Learning projects. This API must be used with the accompanying Bakkesmod plugin.RequirementsA Windows 10 PCRocket League (Both Steam and Epic are supported)BakkesmodThe RLGym plugin for Bakkesmod (It's installed automatically by pip)Python between versions 3.7 and 3.9 (3.10 not supported).InstallationInstall the library via pip:pip install rlgym-rocket-league[all]Once the API is installed, you will need to enable the RLGym plugin from inside the Bakkesmod plugin manager. To do this, first launch the game, then press F2 to open the Bakkesmod menu. Navigate to thepluginstab and open thePlugin Manager. From there, scroll down until you find the RLGym plugin, and enable it. Close the game when this is done.RLGym is now installed! simply runexample.pyfrom our repo to ensure everything works.UsageFor tutorials and documentation, please visit ourWiki.
Package: rlhive
Installing|Tutorials|ContributingRLHiveRLHive is a framework designed to facilitate research in reinforcement learning. It provides the components necessary to run a full RL experiment, for both single agent and multi agent environments. It is designed to be readable and easily extensible, to allow users to quickly run and experiment with their own ideas.The full documentation and tutorials are available athttps://rlhive.readthedocs.io/.InstallingRLHive is available through pip! For the basic RLHive package, simply runpip install rlhive.You can also install dependencies necessary for the environments that
RLHive comes with by runningpip install rlhive[<env_names>]where<env_names>is a comma separated list made up of the following:atarigym_minigridpettingzooIn addition to these environments, Minatar and Marlgrid are also supported, but
need to be installed separately.To install Minatar, runpip install MinAtar@git+https://github.com/kenjyoung/MinAtar.git@8b39a18a60248ede15ce70142b557f3897c4e1ebTo install Marlgrid, runpip install marlgrid@https://github.com/kandouss/marlgrid/archive/refs/heads/master.zipTutorialsCreating new agentsUsing DQN/Rainbow AgentsUsing Environments/Creating new EnvironmentsConfiguring your experiments through YAML files and command lineLoggers and SchedulingRegistering Custom RLHive ObjectsUsing Replay BuffersSingle/Multi-Agent RunnersContributingWe'd love for you to contribute your own work to RLHive. Before doing so, please read ourcontributing guide.