pyRDDLGym-jax 0.2__py3-none-any.whl → 0.4__py3-none-any.whl

pyRDDLGym_jax/core/simulator.py

@@ -1,7 +1,8 @@
-import jax
 import time
 from typing import Dict, Optional
 
+import jax
+
 from pyRDDLGym.core.compiler.model import RDDLLiftedModel
 from pyRDDLGym.core.debug.exception import (
     RDDLActionPreconditionNotSatisfiedError,

pyRDDLGym_jax/core/tuning.py

@@ -1,20 +1,18 @@
-from bayes_opt import BayesianOptimization
-from bayes_opt.util import UtilityFunction
 from copy import deepcopy
 import csv
 import datetime
-import jax
 from multiprocessing import get_context
-import numpy as np
 import os
 import time
 from typing import Any, Callable, Dict, Optional, Tuple
-
-Kwargs = Dict[str, Any]
-
 import warnings
 warnings.filterwarnings("ignore")
 
+from bayes_opt import BayesianOptimization
+from bayes_opt.util import UtilityFunction
+import jax
+import numpy as np
+
 from pyRDDLGym.core.debug.exception import raise_warning
 from pyRDDLGym.core.env import RDDLEnv
 
@@ -26,6 +24,8 @@ from pyRDDLGym_jax.core.planner import (
     JaxOnlineController
 )
 
+Kwargs = Dict[str, Any]
+
 
 # ===============================================================================
 # 
@@ -368,7 +368,8 @@ def objective_slp(params, kwargs, key, index):
         train_seconds=kwargs['timeout_training'],
         model_params=model_params,
         policy_hyperparams=policy_hparams,
-        verbose=0,
+        print_summary=False,
+        print_progress=False,
         tqdm_position=index)
     
     # initialize env for evaluation (need fresh copy to avoid concurrency)
@@ -499,7 +500,8 @@ def objective_replan(params, kwargs, key, index):
         train_seconds=kwargs['timeout_training'],
         model_params=model_params,
         policy_hyperparams=policy_hparams,
-        verbose=0,
+        print_summary=False,
+        print_progress=False,
         tqdm_position=index)
     
     # initialize env for evaluation (need fresh copy to avoid concurrency)
@@ -626,7 +628,8 @@ def objective_drp(params, kwargs, key, index):
         train_seconds=kwargs['timeout_training'],
         model_params=model_params,
         policy_hyperparams=policy_hparams,
-        verbose=0,
+        print_summary=False,
+        print_progress=False,
         tqdm_position=index)
     
     # initialize env for evaluation (need fresh copy to avoid concurrency)

pyRDDLGym_jax/examples/configs/HVAC_ippc2023_drp.cfg

@@ -6,7 +6,7 @@ tnorm_kwargs={}
 
 [Optimizer]
 method='JaxDeepReactivePolicy'
-method_kwargs={'topology': [128, 128]}
+method_kwargs={'topology': [64, 64]}
 optimizer='rmsprop'
 optimizer_kwargs={'learning_rate': 0.001}
 batch_size_train=1
@@ -14,5 +14,5 @@ batch_size_test=1
 
 [Training]
 key=42
-epochs=3000
-train_seconds=30
+epochs=6000
+train_seconds=60

pyRDDLGym_jax/examples/configs/MarsRover_ippc2023_drp.cfg

@@ -11,6 +11,7 @@ optimizer='rmsprop'
 optimizer_kwargs={'learning_rate': 0.01}
 batch_size_train=1
 batch_size_test=1
+action_bounds={'power-x': (-0.09999, 0.09999), 'power-y': (-0.09999, 0.09999)}
 
 [Training]
 key=42

pyRDDLGym_jax/examples/configs/Pendulum_gym_slp.cfg

@@ -8,7 +8,7 @@ tnorm_kwargs={}
 method='JaxStraightLinePlan'
 method_kwargs={}
 optimizer='rmsprop'
-optimizer_kwargs={'learning_rate': 5.0}
+optimizer_kwargs={'learning_rate': 1.0}
 batch_size_train=1
 batch_size_test=1
 

pyRDDLGym_jax/examples/configs/default_drp.cfg

@@ -15,5 +15,5 @@ batch_size_test=32
 [Training]
 key=42
 epochs=30000
-train_seconds=90
+train_seconds=60
 policy_hyperparams=2.0

pyRDDLGym_jax/examples/configs/default_slp.cfg

@@ -15,5 +15,5 @@ batch_size_test=32
 [Training]
 key=42
 epochs=30000
-train_seconds=90
+train_seconds=60
 policy_hyperparams=2.0

pyRDDLGym_jax/examples/run_gym.py

@@ -23,16 +23,13 @@ from pyRDDLGym_jax.core.simulator import JaxRDDLSimulator
 def main(domain, instance, episodes=1, seed=42):
     
     # create the environment
-    env = pyRDDLGym.make(domain, instance, enforce_action_constraints=True, 
-                         backend=JaxRDDLSimulator)
+    env = pyRDDLGym.make(domain, instance, backend=JaxRDDLSimulator)
 
-    # set up a random policy
+    # evaluate a random policy
     agent = RandomAgent(action_space=env.action_space,
                         num_actions=env.max_allowed_actions,
                         seed=seed)
     agent.evaluate(env, episodes=episodes, verbose=True, render=True, seed=seed)
-    
-    # important when logging to save all traces
     env.close()
 
 

pyRDDLGym_jax/examples/run_plan.py

@@ -13,6 +13,7 @@ where:
     <domain> is the name of a domain located in the /Examples directory
     <instance> is the instance number
     <method> is either slp, drp, or replan
+    <episodes> is the optional number of evaluation rollouts
 '''
 import os
 import sys
@@ -28,29 +29,26 @@ from pyRDDLGym_jax.core.planner import (
 def main(domain, instance, method, episodes=1):
     
     # set up the environment
-    env = pyRDDLGym.make(domain, instance, vectorized=True, enforce_action_constraints=True)
+    env = pyRDDLGym.make(domain, instance, vectorized=True)
     
     # load the config file with planner settings
     abs_path = os.path.dirname(os.path.abspath(__file__))
     config_path = os.path.join(abs_path, 'configs', f'{domain}_{method}.cfg') 
     if not os.path.isfile(config_path):
-        raise_warning(f'Config file {domain}_{method}.cfg was not found, '
-                      f'using default config (parameters could be suboptimal).', 
-                      'red')
+        raise_warning(f'Config file {config_path} was not found, '
+                      f'using default_{method}.cfg.', 'red')
         config_path = os.path.join(abs_path, 'configs', f'default_{method}.cfg') 
     planner_args, _, train_args = load_config(config_path)
     
     # create the planning algorithm
     planner = JaxBackpropPlanner(rddl=env.model, **planner_args)
     
-    # create the controller   
+    # evaluate the controller   
     if method == 'replan':
         controller = JaxOnlineController(planner, **train_args)
     else:
-        controller = JaxOfflineController(planner, **train_args)
-    
+        controller = JaxOfflineController(planner, **train_args)    
     controller.evaluate(env, episodes=episodes, verbose=True, render=True)
-    
     env.close()
         
         

pyRDDLGym_jax/examples/run_scipy.py

@@ -0,0 +1,61 @@
+'''In this example, the user has the choice to run the Jax planner using an
+optimizer from scipy.minimize.
+
+The syntax for running this example is:
+
+    python run_scipy.py <domain> <instance> <method> [<episodes>]
+    
+where:
+    <domain> is the name of a domain located in the /Examples directory
+    <instance> is the instance number
+    <method> is the name of a method provided to scipy.optimize.minimize()
+    <episodes> is the optional number of evaluation rollouts
+'''
+import os
+import sys
+import jax
+from scipy.optimize import minimize
+    
+import pyRDDLGym
+from pyRDDLGym.core.debug.exception import raise_warning
+
+from pyRDDLGym_jax.core.planner import load_config, JaxBackpropPlanner, JaxOfflineController
+
+    
+def main(domain, instance, method, episodes=1):
+    
+    # set up the environment
+    env = pyRDDLGym.make(domain, instance, vectorized=True)
+    
+    # load the config file with planner settings
+    abs_path = os.path.dirname(os.path.abspath(__file__))
+    config_path = os.path.join(abs_path, 'configs', f'{domain}_slp.cfg') 
+    if not os.path.isfile(config_path):
+        raise_warning(f'Config file {config_path} was not found, '
+                      f'using default_slp.cfg.', 'red')
+        config_path = os.path.join(abs_path, 'configs', 'default_slp.cfg') 
+    planner_args, _, train_args = load_config(config_path)
+
+    # create the planning algorithm
+    planner = JaxBackpropPlanner(rddl=env.model, **planner_args)
+    
+    # find the optimal plan
+    loss_fn, grad_fn, guess, unravel_fn = planner.as_optimization_problem()
+    opt = minimize(loss_fn, jac=grad_fn, x0=guess, method=method, options={'disp': True})
+    params = unravel_fn(opt.x)
+    
+    # evaluate the optimal plan
+    controller = JaxOfflineController(planner, params=params, **train_args)
+    controller.evaluate(env, episodes=episodes, verbose=True, render=True)    
+    env.close()
+        
+        
+if __name__ == "__main__":
+    args = sys.argv[1:]
+    if len(args) < 3:
+        print('python run_scipy.py <domain> <instance> <method> [<episodes>]')
+        exit(1)
+    kwargs = {'domain': args[0], 'instance': args[1], 'method': args[2]}
+    if len(args) >= 4: kwargs['episodes'] = int(args[3])
+    main(**kwargs)
+    

pyRDDLGym_jax/examples/run_tune.py

@@ -31,15 +31,14 @@ from pyRDDLGym_jax.core.planner import load_config
 def main(domain, instance, method, trials=5, iters=20, workers=4):
     
     # set up the environment   
-    env = pyRDDLGym.make(domain, instance, vectorized=True, enforce_action_constraints=True)
+    env = pyRDDLGym.make(domain, instance, vectorized=True)
     
     # load the config file with planner settings
     abs_path = os.path.dirname(os.path.abspath(__file__))
     config_path = os.path.join(abs_path, 'configs', f'{domain}_{method}.cfg')
     if not os.path.isfile(config_path):
-        raise_warning(f'Config file {domain}_{method}.cfg was not found, '
-                      f'using default config (parameters could be suboptimal).', 
-                      'red')
+        raise_warning(f'Config file {config_path} was not found, '
+                      f'using default_{method}.cfg.', 'red')
         config_path = os.path.join(abs_path, 'configs', f'default_{method}.cfg') 
     planner_args, plan_args, train_args = load_config(config_path)
     
@@ -49,8 +48,7 @@ def main(domain, instance, method, trials=5, iters=20, workers=4):
     elif method == 'drp':
         tuning_class = JaxParameterTuningDRP    
     elif method == 'replan':
-        tuning_class = JaxParameterTuningSLPReplan
-    
+        tuning_class = JaxParameterTuningSLPReplan    
     tuning = tuning_class(env=env,
                           train_epochs=train_args['epochs'],
                           timeout_training=train_args['train_seconds'],
@@ -60,6 +58,7 @@ def main(domain, instance, method, trials=5, iters=20, workers=4):
                           num_workers=workers,
                           gp_iters=iters)
     
+    # perform tuning and report best parameters
     best = tuning.tune(key=train_args['key'], filename=f'gp_{method}', 
                        save_plot=True)
     print(f'best parameters found: {best}')

pyRDDLGym_jax-0.4.dist-info/METADATA

@@ -0,0 +1,276 @@
+Metadata-Version: 2.1
+Name: pyRDDLGym-jax
+Version: 0.4
+Summary: pyRDDLGym-jax: automatic differentiation for solving sequential planning problems in JAX.
+Home-page: https://github.com/pyrddlgym-project/pyRDDLGym-jax
+Author: Michael Gimelfarb, Ayal Taitler, Scott Sanner
+Author-email: mike.gimelfarb@mail.utoronto.ca, ataitler@gmail.com, ssanner@mie.utoronto.ca
+License: MIT License
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyRDDLGym >=2.0
+Requires-Dist: tqdm >=4.66
+Requires-Dist: bayesian-optimization >=1.4.3
+Requires-Dist: jax >=0.4.12
+Requires-Dist: optax >=0.1.9
+Requires-Dist: dm-haiku >=0.0.10
+Requires-Dist: tensorflow-probability >=0.21.0
+
+# pyRDDLGym-jax
+
+Author: [Mike Gimelfarb](https://mike-gimelfarb.github.io)
+
+This directory provides:
+1. automated translation and compilation of RDDL description files into [JAX](https://github.com/google/jax), converting any RDDL domain to a differentiable simulator!
+2. powerful, fast and scalable gradient-based planning algorithms, with extendible and flexible policy class representations, automatic model relaxations for working in discrete and hybrid domains, and much more!
+
+> [!NOTE]  
+> While Jax planners can support some discrete state/action problems through model relaxations, on some discrete problems it can perform poorly (though there is an ongoing effort to remedy this!).
+> If you find it is not making sufficient progress, check out the [PROST planner](https://github.com/pyrddlgym-project/pyRDDLGym-prost) (for discrete spaces) or the [deep reinforcement learning wrappers](https://github.com/pyrddlgym-project/pyRDDLGym-rl).
+
+## Contents
+
+- [Installation](#installation)
+- [Running from the Command Line](#running-from-the-command-line)
+- [Running from within Python](#running-from-within-python)
+- [Configuring the Planner](#configuring-the-planner)
+- [Simulation](#simulation)
+- [Manual Gradient Calculation](#manual-gradient-calculation)
+- [Citing pyRDDLGym-jax](#citing-pyrddlgym-jax)
+  
+## Installation
+
+To use the compiler or planner without the automated hyper-parameter tuning, you will need the following packages installed: 
+- ``pyRDDLGym>=2.0``
+- ``tqdm>=4.66``
+- ``jax>=0.4.12``
+- ``optax>=0.1.9``
+- ``dm-haiku>=0.0.10``
+- ``tensorflow-probability>=0.21.0``
+
+Additionally, if you wish to run the examples, you need ``rddlrepository>=2``. 
+To run the automated tuning optimization, you will also need ``bayesian-optimization>=1.4.3``.
+
+You can install this package, together with all of its requirements, via pip:
+
+```shell
+pip install rddlrepository pyRDDLGym-jax
+```
+
+## Running from the Command Line
+
+A basic run script is provided to run the Jax Planner on any domain in ``rddlrepository``, and can be launched in the command line from the install directory of pyRDDLGym-jax:
+
+```shell
+python -m pyRDDLGym_jax.examples.run_plan <domain> <instance> <method> <episodes>
+```
+
+where:
+- ``domain`` is the domain identifier as specified in rddlrepository (i.e. Wildfire_MDP_ippc2014), or a path pointing to a valid ``domain.rddl`` file
+- ``instance`` is the instance identifier (i.e. 1, 2, ... 10), or a path pointing to a valid ``instance.rddl`` file
+- ``method`` is the planning method to use (i.e. drp, slp, replan)
+- ``episodes`` is the (optional) number of episodes to evaluate the learned policy.
+
+The ``method`` parameter supports three possible modes:
+- ``slp`` is the basic straight line planner described [in this paper](https://proceedings.neurips.cc/paper_files/paper/2017/file/98b17f068d5d9b7668e19fb8ae470841-Paper.pdf)
+- ``drp`` is the deep reactive policy network described [in this paper](https://ojs.aaai.org/index.php/AAAI/article/view/4744)
+- ``replan`` is the same as ``slp`` except the plan is recalculated at every decision time step.
+   
+A basic run script is also provided to run the automatic hyper-parameter tuning:
+
+```shell
+python -m pyRDDLGym_jax.examples.run_tune <domain> <instance> <method> <trials> <iters> <workers>
+```
+
+where:
+- ``domain`` is the domain identifier as specified in rddlrepository (i.e. Wildfire_MDP_ippc2014)
+- ``instance`` is the instance identifier (i.e. 1, 2, ... 10)
+- ``method`` is the planning method to use (i.e. drp, slp, replan)
+- ``trials`` is the (optional) number of trials/episodes to average in evaluating each hyper-parameter setting
+- ``iters`` is the (optional) maximum number of iterations/evaluations of Bayesian optimization to perform
+- ``workers`` is the (optional) number of parallel evaluations to be done at each iteration, e.g. the total evaluations = ``iters * workers``.
+
+For example, the following will train the Jax Planner on the Quadcopter domain with 4 drones:
+
+```shell
+python -m pyRDDLGym_jax.examples.run_plan Quadcopter 1 slp
+```
+
+After several minutes of optimization, you should get a visualization as follows:
+
+<p align="center">
+<img src="Images/quadcopter.gif" width="400" height="400" margin=1/>
+</p>
+
+## Running from within Python
+
+To run the Jax planner from within a Python application, refer to the following example:
+
+```python
+import pyRDDLGym
+from pyRDDLGym_jax.core.planner import JaxBackpropPlanner, JaxOfflineController
+
+# set up the environment (note the vectorized option must be True)
+env = pyRDDLGym.make("domain", "instance", vectorized=True)
+
+# create the planning algorithm
+planner = JaxBackpropPlanner(rddl=env.model, **planner_args)
+controller = JaxOfflineController(planner, **train_args)
+
+# evaluate the planner
+controller.evaluate(env, episodes=1, verbose=True, render=True)
+env.close()
+```
+
+Here, we have used the straight-line controller, although you can configure the combination of planner and policy representation if you wish. 
+All controllers are instances of pyRDDLGym's ``BaseAgent`` class, so they provide the ``evaluate()`` function to streamline interaction with the environment.
+The ``**planner_args`` and ``**train_args`` are keyword argument parameters to pass during initialization, but we strongly recommend creating and loading a config file as discussed in the next section.
+
+## Configuring the Planner
+
+The simplest way to configure the planner is to write and pass a configuration file with the necessary [hyper-parameters](https://pyrddlgym.readthedocs.io/en/latest/jax.html#configuring-pyrddlgym-jax).
+The basic structure of a configuration file is provided below for a straight-line planner:
+
+```ini
+[Model]
+logic='FuzzyLogic'
+logic_kwargs={'weight': 20}
+tnorm='ProductTNorm'
+tnorm_kwargs={}
+
+[Optimizer]
+method='JaxStraightLinePlan'
+method_kwargs={}
+optimizer='rmsprop'
+optimizer_kwargs={'learning_rate': 0.001}
+batch_size_train=1
+batch_size_test=1
+
+[Training]
+key=42
+epochs=5000
+train_seconds=30
+```
+
+The configuration file contains three sections:
+- ``[Model]`` specifies the fuzzy logic operations used to relax discrete operations to differentiable approximations; the ``weight`` dictates the quality of the approximation,
+and ``tnorm`` specifies the type of [fuzzy logic](https://en.wikipedia.org/wiki/T-norm_fuzzy_logics) for relacing logical operations in RDDL (e.g. ``ProductTNorm``, ``GodelTNorm``, ``LukasiewiczTNorm``)
+- ``[Optimizer]`` generally specify the optimizer and plan settings; the ``method`` specifies the plan/policy representation (e.g. ``JaxStraightLinePlan``, ``JaxDeepReactivePolicy``), the gradient descent settings, learning rate, batch size, etc.
+- ``[Training]`` specifies computation limits, such as total training time and number of iterations, and options for printing or visualizing information from the planner.
+
+For a policy network approach, simply change the ``[Optimizer]`` settings like so:
+
+```ini
+...
+[Optimizer]
+method='JaxDeepReactivePolicy'
+method_kwargs={'topology': [128, 64], 'activation': 'tanh'}
+...
+```
+
+The configuration file must then be passed to the planner during initialization. 
+For example, the [previous script here](#running-from-within-python) can be modified to set parameters from a config file:
+
+```python
+from pyRDDLGym_jax.core.planner import load_config
+
+# load the config file with planner settings
+planner_args, _, train_args = load_config("/path/to/config.cfg")
+    
+# create the planning algorithm
+planner = JaxBackpropPlanner(rddl=env.model, **planner_args)
+controller = JaxOfflineController(planner, **train_args)
+...
+```
+
+## Simulation
+
+The JAX compiler can be used as a backend for simulating and evaluating RDDL environments:
+
+```python
+import pyRDDLGym
+from pyRDDLGym.core.policy import RandomAgent
+from pyRDDLGym_jax.core.simulator import JaxRDDLSimulator
+
+# create the environment
+env = pyRDDLGym.make("domain", "instance", backend=JaxRDDLSimulator)
+
+# evaluate the random policy
+agent = RandomAgent(action_space=env.action_space,
+                    num_actions=env.max_allowed_actions)
+agent.evaluate(env, verbose=True, render=True)
+```
+
+For some domains, the JAX backend could perform better than the numpy-based one, due to various compiler optimizations. 
+In any event, the simulation results using the JAX backend should (almost) always match the numpy backend.
+
+## Manual Gradient Calculation
+
+For custom applications, it is desirable to compute gradients of the model that can be optimized downstream. 
+Fortunately, we provide a very convenient function for compiling the transition/step function ``P(s, a, s')`` of the environment into JAX.
+
+```python
+import pyRDDLGym
+from pyRDDLGym_jax.core.planner import JaxRDDLCompilerWithGrad
+
+# set up the environment
+env = pyRDDLGym.make("domain", "instance", vectorized=True)
+
+# create the step function
+compiled = JaxRDDLCompilerWithGrad(rddl=env.model)
+compiled.compile()
+step_fn = compiled.compile_transition()
+```
+
+This will return a JAX compiled (pure) function requiring the following inputs:
+- ``key`` is the ``jax.random.PRNGKey`` key for reproducible randomness
+- ``actions`` is the dictionary of action fluent tensors
+- ``subs`` is the dictionary of state-fluent and non-fluent tensors
+- ``model_params`` are the parameters of the differentiable relaxations, such as ``weight``
+
+The function returns a dictionary containing a variety of variables, such as updated pvariables including next-state fluents (``pvar``), reward obtained (``reward``), error codes (``error``).
+It is thus possible to apply any JAX transformation to the output of the function, such as computing gradient using ``jax.grad()`` or batched simulation using ``jax.vmap()``.
+
+Compilation of entire rollouts is also possible by calling the ``compile_rollouts`` function.
+An [example is provided to illustrate how you can define your own policy class and compute the return gradient manually](https://github.com/pyrddlgym-project/pyRDDLGym-jax/blob/main/pyRDDLGym_jax/examples/run_gradient.py).
+
+## Citing pyRDDLGym-jax
+
+The [following citation](https://ojs.aaai.org/index.php/ICAPS/article/view/31480) describes the main ideas of the framework. Please cite it if you found it useful:
+
+```
+@inproceedings{gimelfarb2024jaxplan,
+    title={JaxPlan and GurobiPlan: Optimization Baselines for Replanning in Discrete and Mixed Discrete and Continuous Probabilistic Domains},
+    author={Michael Gimelfarb and Ayal Taitler and Scott Sanner},
+    booktitle={34th International Conference on Automated Planning and Scheduling},
+    year={2024},
+    url={https://openreview.net/forum?id=7IKtmUpLEH}
+}
+```
+
+The utility optimization is discussed in [this paper](https://ojs.aaai.org/index.php/AAAI/article/view/21226):
+
+```
+@inproceedings{patton2022distributional,
+    title={A distributional framework for risk-sensitive end-to-end planning in continuous mdps},
+    author={Patton, Noah and Jeong, Jihwan and Gimelfarb, Mike and Sanner, Scott},
+    booktitle={Proceedings of the AAAI Conference on Artificial Intelligence},
+    volume={36},
+    number={9},
+    pages={9894--9901},
+    year={2022}
+}
+```
+
+Some of the implementation details derive from the following literature, which you may wish to also cite in your research papers:
+- [Deep reactive policies for planning in stochastic nonlinear domains, AAAI 2019](https://ojs.aaai.org/index.php/AAAI/article/view/4744)
+- [Scalable planning with tensorflow for hybrid nonlinear domains, NeurIPS 2017](https://proceedings.neurips.cc/paper/2017/file/98b17f068d5d9b7668e19fb8ae470841-Paper.pdf)
+

{pyRDDLGym_jax-0.2.dist-info → pyRDDLGym_jax-0.4.dist-info}/RECORD

@@ -1,26 +1,26 @@
-pyRDDLGym_jax/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyRDDLGym_jax/__init__.py,sha256=rexmxcBiCOcwctw4wGvk7UxS9MfZn_1CYXp53SoLKlU,19
 pyRDDLGym_jax/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyRDDLGym_jax/core/compiler.py,sha256=K1p99rKdx2PMdsN1jq6ZEtSANUWACWmOzJrGirj5wq8,89176
-pyRDDLGym_jax/core/logic.py,sha256=zujSHiR5KhTO81E5Zn8Gy_xSzVzfDskFCGvZygFRdMI,21930
-pyRDDLGym_jax/core/planner.py,sha256=vEc-Um_3q1QGhlqk-6oq0eGW7iFAbu-6kpSnyKYS9tI,91731
-pyRDDLGym_jax/core/simulator.py,sha256=fp6bep3XwwBWED0w7_4qhiwDjkSka6B2prwdNcPRCMc,8329
-pyRDDLGym_jax/core/tuning.py,sha256=uhpL3UCfSIgxDEvKI8PibwgTafCMLR_8LrRj5cBKLWE,29466
+pyRDDLGym_jax/core/compiler.py,sha256=SnDN3-J84Wv_YVHoDmfM_U4Ob8uaFLGX4vEaeWC-ERY,90037
+pyRDDLGym_jax/core/logic.py,sha256=o1YAjMnXfi8gwb42kAigBmaf9uIYUWal9__FEkWohrk,26733
+pyRDDLGym_jax/core/planner.py,sha256=Hrwfn88bUu1LNZcnFC5psHPzcIUbPeF4Rn1pFO6_qH0,102655
+pyRDDLGym_jax/core/simulator.py,sha256=hWv6pr-4V-SSCzBYgdIPmKdUDMalft-Zh6dzOo5O9-0,8331
+pyRDDLGym_jax/core/tuning.py,sha256=D_kD8wjqMroCdtjE9eksR2UqrqXJqazsAKrMEHwPxYM,29589
 pyRDDLGym_jax/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyRDDLGym_jax/examples/run_gradient.py,sha256=KhXvijRDZ4V7N8NOI2WV8ePGpPna5_vnET61YwS7Tco,2919
-pyRDDLGym_jax/examples/run_gym.py,sha256=tY6xvLCX9gLCYLK2o0gr44j26SHEwOrhyEQF0wNNIWY,1639
-pyRDDLGym_jax/examples/run_plan.py,sha256=Z40aoikg_mN3rXPl-EGU-BQ9QdHl96P1Qvp4GNZeo5c,2499
-pyRDDLGym_jax/examples/run_tune.py,sha256=N3mMCiRsxWtb94xfk6-v2nelkL5VekneeDmaLxPJND4,3318
+pyRDDLGym_jax/examples/run_gym.py,sha256=rXvNWkxe4jHllvbvU_EOMji_2-2k5d4tbBKhpMm_Gaw,1526
+pyRDDLGym_jax/examples/run_plan.py,sha256=OENf8s-SrMlh7CYXNhanQiau35b4atLBJMNjgP88DCg,2463
+pyRDDLGym_jax/examples/run_scipy.py,sha256=wvcpWCvdjvYHntO95a7JYfY2fuCMUTKnqjJikW0PnL4,2291
+pyRDDLGym_jax/examples/run_tune.py,sha256=-M4KoBpg5lshQ4mmU0cnLs2i7-ldSIr_OcxHK7YA6bw,3273
 pyRDDLGym_jax/examples/configs/Cartpole_Continuous_gym_drp.cfg,sha256=pbkz6ccgk5dHXp7cfYbZNFyJobpGyxUZleCy4fvlmaU,336
 pyRDDLGym_jax/examples/configs/Cartpole_Continuous_gym_replan.cfg,sha256=OswO9YD4Xh1pw3R3LkUBb67WLtj5XlE3qnMQ5CKwPsM,332
 pyRDDLGym_jax/examples/configs/Cartpole_Continuous_gym_slp.cfg,sha256=FxZ4xcg2j2PzeH-wUseRR280juQN5bJjoyt6PtI1W7c,329
-pyRDDLGym_jax/examples/configs/HVAC_ippc2023_drp.cfg,sha256=FZSZc93617oglT66U80vF2QAPv18tHR1NqTbVJRjlfs,338
+pyRDDLGym_jax/examples/configs/HVAC_ippc2023_drp.cfg,sha256=FTGFwRAGyeRrbDMh_FV8iv8ZHrlj3Htju4pfPNmKIcw,336
 pyRDDLGym_jax/examples/configs/HVAC_ippc2023_slp.cfg,sha256=wjtz86_Gz0RfQu3bbrz56PTXL8JMernINx7AtJuZCPs,314
-pyRDDLGym_jax/examples/configs/MarsRover_ippc2023_drp.cfg,sha256=MGLcEIixCzdR_UHR4Ydr8hjB1-lff7U2Zj_cZ0iuPqo,335
+pyRDDLGym_jax/examples/configs/MarsRover_ippc2023_drp.cfg,sha256=C_0BFyhGXbtF7N4vyeua2XkORbkj10HELC1GpzM0Uh4,415
 pyRDDLGym_jax/examples/configs/MarsRover_ippc2023_slp.cfg,sha256=Yb4tFzUOj4epCCsofXAZo70lm5C2KzPIzI5PQHsa_Vk,429
 pyRDDLGym_jax/examples/configs/MountainCar_Continuous_gym_slp.cfg,sha256=e7j-1Z66o7F-KZDSf2e8TQRWwkXOPRwrRFkIavK8G7g,327
 pyRDDLGym_jax/examples/configs/MountainCar_ippc2023_slp.cfg,sha256=Z6CxaOxHv4oF6nW7SfSn_HshlQGDlNCPGASTnDTdL7Q,327
-pyRDDLGym_jax/examples/configs/Pendulum_gym_slp.cfg,sha256=gS66TWLSWL9D2DSRU9XK_5geEz2Nq0aBkoF9Oi2tTkc,315
-pyRDDLGym_jax/examples/configs/Pong_slp.cfg,sha256=S45mBj5hTEshdeJ4rdRaty6YliggtEMkLQV6IYxEkyU,315
+pyRDDLGym_jax/examples/configs/Pendulum_gym_slp.cfg,sha256=Uy1mrX-AZMS-KBAhWXJ3c_QAhd4bRSWttDoFGYQ08lQ,315
 pyRDDLGym_jax/examples/configs/PowerGen_Continuous_drp.cfg,sha256=SM5_U4RwvvucHVAOdMG4vqH0Eg43f3WX9ZlV6aFPgTw,341
 pyRDDLGym_jax/examples/configs/PowerGen_Continuous_replan.cfg,sha256=lcqQ7P7X4qAbMlpkKKuYGn2luSZH-yFB7oi-eHj9Qng,332
 pyRDDLGym_jax/examples/configs/PowerGen_Continuous_slp.cfg,sha256=kG1-02ScmwsEwX7QIAZTD7si90Mb06b79G5oqcMQ9Hg,316
@@ -29,18 +29,16 @@ pyRDDLGym_jax/examples/configs/Quadcopter_slp.cfg,sha256=9QNl58PyoJYhmwvrhzUxlLE
 pyRDDLGym_jax/examples/configs/Reservoir_Continuous_drp.cfg,sha256=rrubYvC1q7Ff0ADV0GXtLw-rD9E4m7qfR66qxdYNTD8,339
 pyRDDLGym_jax/examples/configs/Reservoir_Continuous_replan.cfg,sha256=DAb-J2KwvJXViRRSHZe8aJwZiPljC28HtrKJPieeUCY,331
 pyRDDLGym_jax/examples/configs/Reservoir_Continuous_slp.cfg,sha256=QwKzCAFaErrTCHaJwDPLOxPHpNGNuAKMUoZjLLnMrNc,314
-pyRDDLGym_jax/examples/configs/SupplyChain_slp.cfg,sha256=vU_m6KjfNfaPuYosFdAWeYiV1zQGd6eNA17Yn5QB_BI,319
-pyRDDLGym_jax/examples/configs/Traffic_slp.cfg,sha256=03scuHAl6032YhyYy0w5MLMbTibhdbUZFHLhH2WWaPI,370
 pyRDDLGym_jax/examples/configs/UAV_Continuous_slp.cfg,sha256=QiJCJYOrdXXZfOTuPleGswREFxjGlqQSA0rw00YJWWI,318
 pyRDDLGym_jax/examples/configs/Wildfire_MDP_ippc2014_drp.cfg,sha256=PGkgll7h5vhSF13JScKoQ-vpWaAGNJ_PUEhK7jEjNx4,340
 pyRDDLGym_jax/examples/configs/Wildfire_MDP_ippc2014_replan.cfg,sha256=kEDAwsJQ_t9WPzPhIxfS0hRtgOhtFdJFfmPtTTJuwUE,454
 pyRDDLGym_jax/examples/configs/Wildfire_MDP_ippc2014_slp.cfg,sha256=w2wipsA8PE5OBkYVIKajjtCOtiHqmMeY3XQVPAApwFk,371
 pyRDDLGym_jax/examples/configs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyRDDLGym_jax/examples/configs/default_drp.cfg,sha256=AtHBy2G9xXTWb6CfDGeKrC2tycwhe2u-JjLnAVLTugQ,344
+pyRDDLGym_jax/examples/configs/default_drp.cfg,sha256=S2-5hPZtgAwUAFpiCAgSi-cnGhYHSDzMGMmatwhbM78,344
 pyRDDLGym_jax/examples/configs/default_replan.cfg,sha256=VWWPhOYBRq4cWwtrChw5pPqRmlX_nHbMvwciHd9hoLc,357
-pyRDDLGym_jax/examples/configs/default_slp.cfg,sha256=iicFMK1XJRo1OnLPPY9DKKHgt8T0FttZxRT5UYMJCRE,340
-pyRDDLGym_jax-0.2.dist-info/LICENSE,sha256=Y0Gi6H6mLOKN-oIKGZulQkoTJyPZeAaeuZu7FXH-meg,1095
-pyRDDLGym_jax-0.2.dist-info/METADATA,sha256=sXEBaZx1czXcRRMj0vXyJrtJUJHnkorsWgqrWU9axV0,1085
-pyRDDLGym_jax-0.2.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-pyRDDLGym_jax-0.2.dist-info/top_level.txt,sha256=n_oWkP_BoZK0VofvPKKmBZ3NPk86WFNvLhi1BktCbVQ,14
-pyRDDLGym_jax-0.2.dist-info/RECORD,,
+pyRDDLGym_jax/examples/configs/default_slp.cfg,sha256=TG3mtHUnCA7J2Gm9SczENpqAymTnzCE9dj1Z_R-FnVk,340
+pyRDDLGym_jax-0.4.dist-info/LICENSE,sha256=Y0Gi6H6mLOKN-oIKGZulQkoTJyPZeAaeuZu7FXH-meg,1095
+pyRDDLGym_jax-0.4.dist-info/METADATA,sha256=-Kf8PLxf_7MiiYXzlZAf31kV1pT-Rurc7QY7dT3Fwk0,12857
+pyRDDLGym_jax-0.4.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+pyRDDLGym_jax-0.4.dist-info/top_level.txt,sha256=n_oWkP_BoZK0VofvPKKmBZ3NPk86WFNvLhi1BktCbVQ,14
+pyRDDLGym_jax-0.4.dist-info/RECORD,,

{pyRDDLGym_jax-0.2.dist-info → pyRDDLGym_jax-0.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.2.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pyRDDLGym_jax/examples/configs/Pong_slp.cfg

@@ -1,18 +0,0 @@
-[Model]
-logic='FuzzyLogic'
-logic_kwargs={'weight': 1.0}
-tnorm='ProductTNorm'
-tnorm_kwargs={}
-
-[Optimizer]
-method='JaxStraightLinePlan'
-method_kwargs={}
-optimizer='rmsprop'
-optimizer_kwargs={'learning_rate': 0.001}
-batch_size_train=1
-batch_size_test=1
-
-[Training]
-key=42
-epochs=2000
-train_seconds=30