A-maze-ing environment in jax
Project description
Kheperax
The Kheperax task is a re-implementation of the fastsim
simulator from Mouret and Doncieux (2012).
Kheperax is fully written using JAX, to leverage hardware accelerators and massive parallelization.
Features
- Fully implemented in JAX for hardware acceleration
- Simulates Khepera-like robots (circular robots with 2 wheels) in 2D mazes
- Configurable robot sensors (lasers and bumpers)
- Directly compatible with the QDax library for efficient Quality-Diversity optimization
- Customizable maze layouts and target-based tasks
- Rendering capabilities for visualizing the environment
Installation
Kheperax is available on PyPI and can be installed with:
pip install kheperax
Alternatively, to install Kheperax with CUDA 12 support, you can run:
pip install kheperax[cuda12]
Task Properties
Environment
Each episode is run for a fixed amount of time-steps (by default equal to 250
).
The agent corresponds to a Khepera-like robot (circular robots with 2 wheels) that moves in a planar 2-dimensional maze.
This robot has (by default):
- 3 lasers to estimate its distance to some walls in specific directions (by default -45, 0 and 45 degrees).
- 2 bumpers to detect contact with walls. At each time-step, the agent receives an observation, which corresponds to all laser and bumper measures:
# by default:
[laser 1, laser 2, laser 3, bumper left, bumper right]
The bumpers return 1
if there's a contact with a wall and -1
otherwise.
The actions to pass to the environment should be between -1
and 1
.
They are then scaled depending on a scale defined in the environment configuration.
Run examples
Install Dependencies
Before running examples, we recommend creating a virtual environment and installing the required dependencies:
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
If you want to run the examples with CUDA 12 support, you need install jax
with the cuda12
extra:
pip install jax[cuda12]==<version-from-requirements.txt>
Launch MAP-Elites Example
To run the MAP-Elites example on the standard Kheperax task, you can use the following colab notebook:
Other tasks can be run with the following scripts.
python -m examples.target.target_me_training # Target task with MAP-Elites
python -m examples.final_distance.final_distance_me_training # Final Distance task with MAP-Elites
Additional details on those tasks can be found in the Tasks and Maze Types section.
Rendering images and gifs
To render images, you can run the following script:
python -m examples.rendering.maps_rendering
To render gifs, you can run the following script:
python -m examples.rendering.gif
Tasks and Maze Types
Kheperax supports various tasks and maze types. Here's an overview of the available options and their corresponding files:
Basic Kheperax Task
- File:
kheperax/tasks/main.py
- Class:
KheperaxTask
- Configuration:
KheperaxConfig
- Description: The standard Kheperax environment without a specific target.
- Fitness: sum of rewards
- Reward: negated norm of actions, r_t = -1 * norm a_t (i.e. r_t ~ negated energy spent at time t)
- Descriptor: final (x,y) location of the robot.
Key Features:
- Reward Function:
- negated norm of actions, r_t = -1 * norm a_t (i.e. r_t ~ negated energy spent at time t)
- This encourages the robot to move efficiently.
- Episode Termination:
- The episode terminates if the maximum number of steps is reached.
- Rendering:
- When rendered, the target appears as a green circle in the maze.
Configuration
A KheperaxConfig
object contains all the properties of a KheperaxTask
:
from kheperax.tasks.config import KheperaxConfig
config = KheperaxConfig.get_default()
Key configuration options with their default values:
episode_length
:int = 250
, maximum number of timesteps per episodemlp_policy_hidden_layer_sizes
:Tuple[int, ...] = (8,)
, structure of policy network's hidden layersaction_scale
:float = 0.025
, scales the actions for wheel velocitiesrobot
:Robot
, includes:posture
:Posture(x=0.15, y=0.15, angle=pi/2)
, initial position and orientationradius
:float = 0.015
, robot sizelaser_ranges
:Union[float, List[float]] = 0.2
, max ranges for laser sensorslaser_angles
:List[float] = [-pi/4, 0.0, pi/4]
, placement angles for laser sensorsstd_noise_sensor_measures
:float = 0.0
, noise in sensor readings
maze
:Maze
, defines the environment layout (default is a standard maze)std_noise_wheel_velocities
:float = 0.0
, noise in wheel velocitiesresolution
:Tuple[int, int] = (1024, 1024)
, rendering resolutionlimits
:Tuple[Tuple[float, float], Tuple[float, float]] = ((0., 0.), (1., 1.))
, environment boundariesaction_repeat
:int = 1
, number of times each action is repeated
Usage example:
from kheperax.tasks.config import KheperaxConfig
from kheperax.simu.robot import Robot
from kheperax.simu.maze import Maze
config = KheperaxConfig.get_default()
config.episode_length = 1000
config.action_scale = 0.03
config.resolution = (800, 800)
new_robot = Robot.create_default_robot().replace(radius=0.05)
config.robot = new_robot
new_maze = Maze.create(segments_list=[...]) # Define maze segments
config.maze = new_maze
Target Kheperax Task
- File:
kheperax/tasks/target.py
- Class:
TargetKheperaxTask
- Configuration:
TargetKheperaxConfig
- Description: Kheperax environment with a target position for the robot to reach.
- Fitness: sum of rewards (detailed below)
- Descriptor: final (x,y) location of the robot.
Key Features:
- Reward Function:
- At each step, the reward is the negative distance to the target center.
- This encourages the robot to move towards the target.
- Episode Termination:
- The episode ends when the robot reaches the target (enters the target radius).
- Also terminates if the maximum number of steps is reached.
- Rendering:
- When rendered, the target appears as a green circle in the maze.
Configuration
TargetKheperaxConfig
contains the same parameters as KheperaxConfig
, plus additional target-related parameters:
- Target Position: Defines a specific point in the maze for the robot to reach. Default position:
(0.15, 0.9)
- Target Radius: Specifies the size of the target area.
- Default radius: 0.05
- The episode ends when the robot enters this radius.
Usage example:
from kheperax.tasks.target import TargetKheperaxConfig, TargetKheperaxTask
# Create a default target configuration
target_config = TargetKheperaxConfig.get_default()
# Customize the configuration if needed
target_config.target_pos = (0.2, 0.8) # Change target position
target_config.target_radius = 0.06 # Change target radius
# Create the target task
target_task = TargetKheperaxTask(target_config)
# Use the task in your experiment
# ... (reset, step, etc.)
Final Distance Kheperax Task
- File:
kheperax/tasks/final_distance.py
- Class:
FinalDistKheperaxTask
- Description: A task that only rewards the final distance to the target.
- Fitness: sum of rewards (detailed below)
- Descriptor: final (x,y) location of the robot.
Key Features:
- Reward Function:
- At each step, the reward is -1, except for the final step, where the reward is 100 * the negative distance to the target center.
- This encourages the robot to move towards the target as quickly as possible.
- Episode Termination:
- The episode ends when the robot reaches the target (enters the target radius).
- Also terminates if the maximum number of steps is reached.
TargetKheperaxConfig
is still used to manage the configuration for this kind of task (see above description)
Maze Maps
- File:
kheperax/envs/maze_maps.py
- Description: Defines various maze layouts, including:
- Standard Kheperax maze -
standard
- Pointmaze -
pointmaze
- Snake maze -
snake
- Standard Kheperax maze -
To use a specific maze map:
from kheperax.tasks.config import KheperaxConfig
from kheperax.tasks.target import TargetKheperaxConfig
# Get the default configuration for the desired maze map
maze_map = KheperaxConfig.get_default_for_map("standard") # or "pointmaze", "snake"
# For target-based tasks
target_maze_map = TargetKheperaxConfig.get_default_for_map("standard") # or "pointmaze", "snake"
Standard | PointMaze | Snake | |
---|---|---|---|
No target | |||
Target |
Quad Mazes
- File:
kheperax/tasks/quad.py
- Function:
make_quad_config
- Description: Creates quad mazes, which are essentially four copies of the original maze flipped in different orientations.
To create a quad maze configuration:
from kheperax.tasks.config import KheperaxConfig
from kheperax.tasks.target import TargetKheperaxConfig
from kheperax.tasks.quad import make_quad_config
# Get the default configuration for the desired maze map
maze_map = KheperaxConfig.get_default_for_map("standard") # or "pointmaze", "snake"
target_maze_map = TargetKheperaxConfig.get_default_for_map("standard") # or "pointmaze", "snake"
# Create a quad maze configuration
quad_config = make_quad_config(maze_map) # or target_maze_map for target-based tasks
Quad Standard | Quad PointMaze | Quad Snake | |
---|---|---|---|
No target | |||
Target |
Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
License
This project is licensed under the MIT License - see the LICENSE file for details.
Citation
If you use Kheperax in your research, please cite the following paper:
@inproceedings{grillotti2023kheperax,
title={Kheperax: a lightweight jax-based robot control environment for benchmarking quality-diversity algorithms},
author={Grillotti, Luca and Cully, Antoine},
booktitle={Proceedings of the Companion Conference on Genetic and Evolutionary Computation},
pages={2163--2165},
year={2023}
}
Acknowledgements
- Original
fastsim
simulator by Mouret and Doncieux (2012)
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 Distribution
Built Distribution
File details
Details for the file kheperax-0.2.0.tar.gz
.
File metadata
- Download URL: kheperax-0.2.0.tar.gz
- Upload date:
- Size: 24.5 kB
- Tags: Source
- Uploaded using Trusted Publishing? No
- Uploaded via: twine/5.1.1 CPython/3.10.11
File hashes
Algorithm | Hash digest | |
---|---|---|
SHA256 | df6f3fb55650b7c3849fdfb3d8594824565728099d0ef140d475463370978205 |
|
MD5 | 9cd2d87e8f478b8c7d2e259eee69d24d |
|
BLAKE2b-256 | 75c4b8fe4a2ad325d4436e70521e4fb64f677c7c90b3be7794901fadc8a6bf86 |
File details
Details for the file kheperax-0.2.0-py3-none-any.whl
.
File metadata
- Download URL: kheperax-0.2.0-py3-none-any.whl
- Upload date:
- Size: 27.7 kB
- Tags: Python 3
- Uploaded using Trusted Publishing? No
- Uploaded via: twine/5.1.1 CPython/3.10.11
File hashes
Algorithm | Hash digest | |
---|---|---|
SHA256 | 5a21b8d357e66a56486c84afb9391a0b2b65754a708e2cdb1de2ccdd779b1823 |
|
MD5 | 973d41ee85854618223889fb9f75b5bb |
|
BLAKE2b-256 | f83c60afdd8758a6a3ae06ae0c9ab8cbaf601249cda0e3392a826ffd2e650d37 |