evolutionary-policy-optimization 0.0.1__tar.gz

evolutionary_policy_optimization-0.0.1/.github/workflows/python-publish.yml

@@ -0,0 +1,36 @@
+# This workflow will upload a Python Package using Twine when a release is created
+# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build
+    - name: Build package
+      run: python -m build
+    - name: Publish package
+      uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_API_TOKEN }}

evolutionary_policy_optimization-0.0.1/.gitignore

@@ -0,0 +1,174 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc

evolutionary_policy_optimization-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Phil Wang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

evolutionary_policy_optimization-0.0.1/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: evolutionary-policy-optimization
+Version: 0.0.1
+Summary: EPO - Pytorch
+Project-URL: Homepage, https://pypi.org/project/evolutionary-policy-optimization/
+Project-URL: Repository, https://github.com/lucidrains/evolutionary-policy-optimization
+Author-email: Phil Wang <lucidrains@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Phil Wang
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: artificial intelligence,deep learning,genetic algorithms,reinforcement learning,robotics
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Requires-Dist: einops>=0.8.0
+Requires-Dist: torch>=2.2
+Requires-Dist: tqdm
+Provides-Extra: examples
+Requires-Dist: numpy; extra == 'examples'
+Requires-Dist: pufferlib>=2.0.6; extra == 'examples'
+Requires-Dist: tqdm; extra == 'examples'
+Provides-Extra: examples-gym
+Requires-Dist: box2d-py; extra == 'examples-gym'
+Requires-Dist: gymnasium[box2d]>=1.0.0; extra == 'examples-gym'
+Requires-Dist: tqdm; extra == 'examples-gym'
+Description-Content-Type: text/markdown
+
+<img width="450px" alt="fig1" src="https://github.com/user-attachments/assets/33bef569-e786-4f09-bdee-56bad7ea9e6d" />
+
+## Evolutionary Policy Optimization (wip)
+
+Pytorch implementation of [Evolutionary Policy Optimization](https://web3.arxiv.org/abs/2503.19037), from Wang et al. of the Robotics Institute at Carnegie Mellon University
+
+This paper stands out, as I have witnessed the positive effects first hand in an [exploratory project](https://github.com/lucidrains/firefly-torch) (mixing evolution with gradient based methods). Perhaps the Alexnet moment for genetic algorithms has not come to pass yet.
+
+Besides their latent variable method, I'll also throw in some attempts with crossover in weight space
+
+## Usage
+
+```python
+import torch
+
+from evolutionary_policy_optimization import (
+    LatentGenePool,
+    MLP
+)
+
+latent_pool = LatentGenePool(
+    num_latents = 32,
+    dim_latent = 32,
+    net = MLP(
+        dims = (512, 256),
+        dim_latent = 32,
+    )
+)
+
+state = torch.randn(1, 512)
+action = latent_pool(state, latent_id = 3) # use latent / gene 4
+
+# interact with environment and receive rewards, termination etc
+
+# derive a fitness score for each gene / latent
+
+fitness = torch.randn(32)
+
+latent_pool.genetic_algorithm_step(fitness) # update latents using one generation of genetic algorithm
+
+```
+
+## Citations
+
+```bibtex
+@inproceedings{Wang2025EvolutionaryPO,
+    title = {Evolutionary Policy Optimization},
+    author = {Jianren Wang and Yifan Su and Abhinav Gupta and Deepak Pathak},
+    year  = {2025},
+    url   = {https://api.semanticscholar.org/CorpusID:277313729}
+}
+```
+
+*Evolution is cleverer than you are.* - Leslie Orgel

evolutionary_policy_optimization-0.0.1/README.md

@@ -0,0 +1,54 @@
+<img width="450px" alt="fig1" src="https://github.com/user-attachments/assets/33bef569-e786-4f09-bdee-56bad7ea9e6d" />
+
+## Evolutionary Policy Optimization (wip)
+
+Pytorch implementation of [Evolutionary Policy Optimization](https://web3.arxiv.org/abs/2503.19037), from Wang et al. of the Robotics Institute at Carnegie Mellon University
+
+This paper stands out, as I have witnessed the positive effects first hand in an [exploratory project](https://github.com/lucidrains/firefly-torch) (mixing evolution with gradient based methods). Perhaps the Alexnet moment for genetic algorithms has not come to pass yet.
+
+Besides their latent variable method, I'll also throw in some attempts with crossover in weight space
+
+## Usage
+
+```python
+import torch
+
+from evolutionary_policy_optimization import (
+    LatentGenePool,
+    MLP
+)
+
+latent_pool = LatentGenePool(
+    num_latents = 32,
+    dim_latent = 32,
+    net = MLP(
+        dims = (512, 256),
+        dim_latent = 32,
+    )
+)
+
+state = torch.randn(1, 512)
+action = latent_pool(state, latent_id = 3) # use latent / gene 4
+
+# interact with environment and receive rewards, termination etc
+
+# derive a fitness score for each gene / latent
+
+fitness = torch.randn(32)
+
+latent_pool.genetic_algorithm_step(fitness) # update latents using one generation of genetic algorithm
+
+```
+
+## Citations
+
+```bibtex
+@inproceedings{Wang2025EvolutionaryPO,
+    title = {Evolutionary Policy Optimization},
+    author = {Jianren Wang and Yifan Su and Abhinav Gupta and Deepak Pathak},
+    year  = {2025},
+    url   = {https://api.semanticscholar.org/CorpusID:277313729}
+}
+```
+
+*Evolution is cleverer than you are.* - Leslie Orgel

evolutionary_policy_optimization-0.0.1/evolutionary_policy_optimization/__init__.py

@@ -0,0 +1,4 @@
+from evolutionary_policy_optimization.epo import (
+    MLP,
+    LatentGenePool
+)

evolutionary_policy_optimization-0.0.1/evolutionary_policy_optimization/epo.py

@@ -0,0 +1,326 @@
+from __future__ import annotations
+
+import torch
+from torch import nn, cat
+import torch.nn.functional as F
+
+import torch.nn.functional as F
+from torch.nn import Linear, Module, ModuleList
+
+from einops import rearrange, repeat
+
+# helpers
+
+def exists(v):
+    return v is not None
+
+def default(v, d):
+    return v if exists(v) else d
+
+def identity(t):
+    return t
+
+def xnor(x, y):
+    return not (x ^ y)
+
+def l2norm(t):
+    return F.normalize(t, p = 2, dim = -1)
+
+# tensor helpers
+
+def log(t, eps = 1e-20):
+    return t.clamp(min = eps).log()
+
+def calc_entropy(logits):
+    prob = logits.softmax(dim = -1)
+    return -prob * log(prob)
+
+def gather_log_prob(
+    logits, # Float[b l]
+    indices # Int[b]
+): # Float[b]
+    indices = rearrange(indices, '... -> ... 1')
+    log_probs = logits.log_softmax(dim = -1)
+    log_prob = log_probs.gather(-1, indices)
+    return rearrange(log_prob, '... 1 -> ...')
+
+# reinforcement learning related - ppo
+
+def actor_loss(
+    logits,         # Float[b l]
+    old_log_probs,  # Float[b]
+    actions,        # Int[b]
+    advantages,     # Float[b]
+    eps_clip = 0.2,
+    entropy_weight = .01,
+):
+    log_probs = gather_log_prob(logits, actions)
+
+    entropy = calc_entropy(logits)
+
+    ratio = (log_probs - old_log_probs).exp()
+
+    clipped_ratio = ratio.clamp(min = 1. - eps_clip, max = 1. + eps_clip)
+
+    # classic clipped surrogate loss from ppo
+
+    actor_loss = -torch.min(clipped_ratio * advantage, ratio * advantage)
+
+    # add entropy loss for exploration
+
+    entropy_aux_loss = -entropy_weight * entropy
+
+    return actor_loss + entropy_aux_loss
+
+def critic_loss(
+    pred_values,  # Float[b]
+    advantages,   # Float[b]
+    old_values    # Float[b]
+):
+    discounted_values = advantages + old_values
+    return F.mse_loss(pred_values, discounted_values)
+
+# evolution related functions
+
+def crossover_latents(
+    parent1, parent2,
+    weight = None,
+    random = False,
+    l2norm_output = False
+):
+    assert parent1.shape == parent2.shape
+
+    if random:
+        assert not exists(weight)
+        weight = torch.randn_like(parent1).sigmoid()
+    else:
+        weight = default(weight, 0.5) # they do a simple averaging for the latents as crossover, but allow for random interpolation, as well extend this work for tournament selection, where same set of parents may be re-selected
+
+    child = torch.lerp(parent1, parent2, weight)
+
+    if not l2norm_output:
+        return child
+
+    return l2norm(child)
+
+def mutation(
+    latents,
+    mutation_strength = 1.,
+    l2norm_output = False
+):
+    mutations = torch.randn_like(latents)
+
+    mutated = latents + mutations * mutation_strength
+
+    if not l2norm_output:
+        return mutated
+
+    return l2norm(mutated)
+
+# simple MLP networks, but with latent variables
+# the latent variables are the "genes" with the rest of the network as the scaffold for "gene expression" - as suggested in the paper
+
+class MLP(Module):
+    def __init__(
+        self,
+        dims: tuple[int, ...],
+        dim_latent = 0,
+    ):
+        super().__init__()
+        assert len(dims) >= 2, 'must have at least two dimensions'
+
+        # add the latent to the first dim
+
+        first_dim, *rest_dims = dims
+        first_dim += dim_latent
+        dims = (first_dim, *rest_dims)
+
+        self.dim_latent = dim_latent
+        self.needs_latent = dim_latent > 0
+
+        self.encode_latent = nn.Sequential(
+            Linear(dim_latent, dim_latent),
+            nn.SiLU()
+        ) if self.needs_latent else None
+
+        # pairs of dimension
+
+        dim_pairs = tuple(zip(dims[:-1], dims[1:]))
+
+        # modules across layers
+
+        layers = ModuleList([Linear(dim_in, dim_out) for dim_in, dim_out in dim_pairs])
+
+        self.layers = layers
+
+    def forward(
+        self,
+        x,
+        latent = None
+    ):
+        assert xnor(self.needs_latent, exists(latent))
+
+        if exists(latent):
+            # start with naive concatenative conditioning
+            # but will also offer some alternatives once a spark is seen (film, adaptive linear from stylegan, etc)
+
+            batch = x.shape[0]
+
+            latent = self.encode_latent(latent)
+            latent = repeat(latent, 'd -> b d', b = batch)
+
+            x = cat((x, latent), dim = -1)
+
+        # layers
+
+        for ind, layer in enumerate(self.layers, start = 1):
+            is_last = ind == len(self.layers)
+
+            x = layer(x)
+
+            if not is_last:
+                x = F.silu(x)
+
+        return x
+
+# classes
+
+class LatentGenePool(Module):
+    def __init__(
+        self,
+        num_latents,                     # same as gene pool size
+        dim_latent,                      # gene dimension
+        crossover_random = True,         # random interp from parent1 to parent2 for crossover, set to `False` for averaging (0.5 constant value)
+        l2norm_latent = False,           # whether to enforce latents on hypersphere,
+        frac_tournaments = 0.25,         # fraction of genes to participate in tournament - the lower the value, the more chance a less fit gene could be selected
+        frac_natural_selected = 0.25,    # number of least fit genes to remove from the pool
+        frac_elitism = 0.1,              # frac of population to preserve from being noised
+        mutation_strength = 1.,          # factor to multiply to gaussian noise as mutation to latents
+        net: MLP | Module | dict | None = None,
+    ):
+        super().__init__()
+
+        maybe_l2norm = l2norm if l2norm_latent else identity
+
+        latents = torch.randn(num_latents, dim_latent)
+
+        if l2norm_latent:
+            latents = maybe_l2norm(latents, dim = -1)
+
+        self.latents = nn.Parameter(latents, requires_grad = False)
+
+        self.maybe_l2norm = maybe_l2norm
+
+        # some derived values
+
+        assert 0. < frac_tournaments < 1.
+        assert 0. < frac_natural_selected < 1.
+        assert 0. <= frac_elitism < 1.
+        assert (frac_natural_selected + frac_elitism) < 1.
+
+        self.dim_latent = dim_latent
+        self.num_latents = num_latents
+        self.num_natural_selected = int(frac_natural_selected * num_latents)
+
+        self.num_tournament_participants = int(frac_tournaments * self.num_natural_selected)
+        self.crossover_random  = crossover_random
+
+        self.mutation_strength = mutation_strength
+        self.num_elites = int(frac_elitism * num_latents)
+        self.has_elites = self.num_elites > 0
+
+        # network for the latent / gene
+
+        if isinstance(net, dict):
+            net = MLP(**net)
+
+        assert net.dim_latent == dim_latent, f'the latent dimension set on the MLP {net.dim_latent} must be what was passed into the latent gene pool module ({dim_latent})'
+        self.net = net
+
+    @torch.no_grad()
+    # non-gradient optimization, at least, not on the individual level (taken care of by rl component)
+    def genetic_algorithm_step(
+        self,
+        fitness, # Float['p'],
+        inplace = True
+    ):
+        """
+        p - population
+        g - gene dimension
+        """
+
+        genes = self.latents # the latents are the genes
+
+        pop_size = genes.shape[0]
+        assert pop_size == fitness.shape[0]
+
+        # 1. natural selection is simple in silico
+        # you sort the population by the fitness and slice off the least fit end
+
+        sorted_indices = fitness.sort().indices
+        natural_selected_indices = sorted_indices[-self.num_natural_selected:]
+        genes, fitness = genes[natural_selected_indices], fitness[natural_selected_indices]
+
+        # 2. for finding pairs of parents to replete gene pool, we will go with the popular tournament strategy
+
+        batch_randperm = torch.randn((pop_size - self.num_natural_selected, self.num_tournament_participants)).argsort(dim = -1)
+
+        participants = genes[batch_randperm]
+        participant_fitness = fitness[batch_randperm]
+
+        tournament_winner_indices = participant_fitness.topk(2, dim = -1).indices
+
+        tournament_winner_indices = repeat(tournament_winner_indices, '... -> ... g', g = self.dim_latent)
+
+        parents = participants.gather(-2, tournament_winner_indices)
+
+        # 3. do a crossover of the parents - in their case they went for a simple averaging, but since we are doing tournament style and the same pair of parents may be re-selected, lets make it random interpolation
+
+        parent1, parent2 = parents.unbind(dim = 1)
+        children = crossover_latents(parent1, parent2, random = self.crossover_random)
+
+        # append children to gene pool
+
+        genes = cat((children, genes))
+
+        # 4. they use the elitism strategy to protect best performing genes from being changed
+
+        if self.has_elites:
+            genes, elites = genes[:-self.num_elites], genes[-self.num_elites:]
+
+        # 5. mutate with gaussian noise - todo: add drawing the mutation rate from exponential distribution, from the fast genetic algorithms paper from 2017
+
+        genes = mutation(genes, mutation_strength = self.mutation_strength)
+
+        # add back the elites
+
+        if self.has_elites:
+            genes = cat((genes, elites))
+
+        genes = self.maybe_l2norm(genes)
+
+        if not inplace:
+            return genes
+
+        # store the genes for the next interaction with environment for new fitness values (a function of reward and other to be researched measures)
+
+        self.latents.copy_(genes)
+
+    def forward(
+        self,
+        *args,
+        latent_id: int,
+        **kwargs,
+    ):
+
+        assert exists(self.net)
+
+        assert 0 <= latent_id < self.num_latents
+
+        latent = self.latents[latent_id]
+
+        return self.net(
+            *args,
+            latent = latent,
+            **kwargs
+        )

evolutionary_policy_optimization-0.0.1/evolutionary_policy_optimization/experimental.py

@@ -0,0 +1,27 @@
+import torch
+
+def crossover_weights(w1, w2, transpose = False):
+    assert w2.shape == w2.shape
+    assert w1.ndim == 2
+
+    if transpose:
+        w1, w2 = w1.t(), w2.t()
+
+    rank = min(w2.shape)
+    assert rank >= 2
+
+    u1, s1, v1 = torch.svd(w1)
+    u2, s2, v2 = torch.svd(w2)
+
+    mask = torch.randperm(rank) < (rank // 2)
+
+    u = torch.where(mask[None, :], u1, u2)
+    s = torch.where(mask, s1, s2)
+    v = torch.where(mask[None, :], v1, v2)
+
+    out = u @ torch.diag_embed(s) @ v.mT
+
+    if transpose:
+        out = out.t()
+
+    return out

evolutionary_policy_optimization-0.0.1/pyproject.toml

@@ -0,0 +1,66 @@
+[project]
+name = "evolutionary-policy-optimization"
+version = "0.0.1"
+description = "EPO - Pytorch"
+authors = [
+    { name = "Phil Wang", email = "lucidrains@gmail.com" }
+]
+readme = "README.md"
+requires-python = ">= 3.8"
+license = { file = "LICENSE" }
+keywords = [
+    'artificial intelligence',
+    'deep learning',
+    'reinforcement learning',
+    'genetic algorithms',
+    'robotics'
+  ]
+classifiers=[
+    'Development Status :: 4 - Beta',
+    'Intended Audience :: Developers',
+    'Topic :: Scientific/Engineering :: Artificial Intelligence',
+    'License :: OSI Approved :: MIT License',
+    'Programming Language :: Python :: 3.8',
+  ]
+
+dependencies = [
+    'einops>=0.8.0',
+    'torch>=2.2',
+    'tqdm'
+]
+
+[project.urls]
+Homepage = "https://pypi.org/project/evolutionary-policy-optimization/"
+Repository = "https://github.com/lucidrains/evolutionary-policy-optimization"
+
+[project.optional-dependencies]
+examples = [
+    "numpy",
+    "pufferlib>=2.0.6",
+    "tqdm",
+]
+
+examples_gym = [
+    "box2d-py",
+    "gymnasium[box2d]>=1.0.0",
+    "tqdm",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.rye]
+managed = true
+dev-dependencies = [
+    "ruff>=0.4.2",
+    "pytest>=8.2.0",
+    "pytest-examples>=0.0.10",
+    "pytest-cov>=5.0.0",
+]
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["evolutionary_policy_optimization"]