pyRDDLGym-jax 2.3__py3-none-any.whl → 2.5__py3-none-any.whl

pyRDDLGym_jax/core/simulator.py

@@ -19,10 +19,12 @@
 
 
 import time
-from typing import Dict, Optional
+import numpy as np
+from typing import Dict, Optional, Union
 
 import jax
 
+from pyRDDLGym.core.compiler.initializer import RDDLValueInitializer
 from pyRDDLGym.core.compiler.model import RDDLLiftedModel
 from pyRDDLGym.core.debug.exception import (
     RDDLActionPreconditionNotSatisfiedError,
@@ -35,7 +37,7 @@ from pyRDDLGym.core.simulator import RDDLSimulator
 
 from pyRDDLGym_jax.core.compiler import JaxRDDLCompiler
 
-Args = Dict[str, Value]
+Args = Dict[str, Union[np.ndarray, Value]]
 
 
 class JaxRDDLSimulator(RDDLSimulator):
@@ -45,6 +47,7 @@ class JaxRDDLSimulator(RDDLSimulator):
                  raise_error: bool=True,
                  logger: Optional[Logger]=None,
                  keep_tensors: bool=False,
+                 objects_as_strings: bool=True,
                  **compiler_args) -> None:
         '''Creates a new simulator for the given RDDL model with Jax as a backend.
         
@@ -57,6 +60,8 @@ class JaxRDDLSimulator(RDDLSimulator):
         :param logger: to log information about compilation to file
         :param keep_tensors: whether the sampler takes actions and
         returns state in numpy array form
+        param objects_as_strings: whether to return object values as strings (defaults
+        to integer indices if False)
         :param **compiler_args: keyword arguments to pass to the Jax compiler
         '''
         if key is None:
@@ -67,7 +72,8 @@ class JaxRDDLSimulator(RDDLSimulator):
         
         # generate direct sampling with default numpy RNG and operations
         super(JaxRDDLSimulator, self).__init__(
-            rddl, logger=logger, keep_tensors=keep_tensors)
+            rddl, logger=logger, 
+            keep_tensors=keep_tensors, objects_as_strings=objects_as_strings)
     
     def seed(self, seed: int) -> None:
         super(JaxRDDLSimulator, self).seed(seed)
@@ -84,11 +90,11 @@ class JaxRDDLSimulator(RDDLSimulator):
         self.levels = compiled.levels
         self.traced = compiled.traced
         
-        self.invariants = jax.tree_map(jax.jit, compiled.invariants)
-        self.preconds = jax.tree_map(jax.jit, compiled.preconditions)
-        self.terminals = jax.tree_map(jax.jit, compiled.terminations)
+        self.invariants = jax.tree_util.tree_map(jax.jit, compiled.invariants)
+        self.preconds = jax.tree_util.tree_map(jax.jit, compiled.preconditions)
+        self.terminals = jax.tree_util.tree_map(jax.jit, compiled.terminations)
         self.reward = jax.jit(compiled.reward)
-        jax_cpfs = jax.tree_map(jax.jit, compiled.cpfs)
+        jax_cpfs = jax.tree_util.tree_map(jax.jit, compiled.cpfs)
         self.model_params = compiled.model_params
         
         # level analysis
@@ -139,7 +145,6 @@ class JaxRDDLSimulator(RDDLSimulator):
     
     def check_action_preconditions(self, actions: Args, silent: bool=False) -> bool:
         '''Throws an exception if the action preconditions are not satisfied.'''
-        actions = self._process_actions(actions)
         subs = self.subs
         subs.update(actions)
         
@@ -180,7 +185,6 @@ class JaxRDDLSimulator(RDDLSimulator):
         '''
         rddl = self.rddl
         keep_tensors = self.keep_tensors
-        actions = self._process_actions(actions)
         subs = self.subs
         subs.update(actions)
         
@@ -196,20 +200,40 @@ class JaxRDDLSimulator(RDDLSimulator):
         # update state
         self.state = {}
         for (state, next_state) in rddl.next_state.items():
+
+            # set state = state' for the next epoch
             subs[state] = subs[next_state]
+
+            # convert object integer to string representation
+            state_values = subs[state]
+            if self.objects_as_strings:
+                ptype = rddl.variable_ranges[state]
+                if ptype not in RDDLValueInitializer.NUMPY_TYPES:
+                    state_values = rddl.index_to_object_string_array(ptype, state_values)
+
+            # optional grounding of state dictionary
             if keep_tensors:
-                self.state[state] = subs[state]
+                self.state[state] = state_values
             else:
-                self.state.update(rddl.ground_var_with_values(state, subs[state]))
+                self.state.update(rddl.ground_var_with_values(state, state_values))
         
         # update observation
         if self._pomdp: 
             obs = {}
             for var in rddl.observ_fluents:
+
+                # convert object integer to string representation
+                obs_values = subs[var]
+                if self.objects_as_strings:
+                    ptype = rddl.variable_ranges[var]
+                    if ptype not in RDDLValueInitializer.NUMPY_TYPES:
+                        obs_values = rddl.index_to_object_string_array(ptype, obs_values)
+
+                # optional grounding of observ-fluent dictionary    
                 if keep_tensors:
-                    obs[var] = subs[var]
+                    obs[var] = obs_values
                 else:
-                    obs.update(rddl.ground_var_with_values(var, subs[var]))
+                    obs.update(rddl.ground_var_with_values(var, obs_values))
         else:
             obs = self.state
         

pyRDDLGym_jax/core/tuning.py

@@ -18,6 +18,7 @@ import datetime
 import threading
 import multiprocessing
 import os
+import termcolor
 import time
 import traceback
 from typing import Any, Callable, Dict, Iterable, Optional, Tuple
@@ -45,8 +46,7 @@ try:
     from pyRDDLGym_jax.core.visualization import JaxPlannerDashboard
 except Exception:
     raise_warning('Failed to load the dashboard visualization tool: '
-                  'please make sure you have installed the required packages.', 
-                  'red')
+                  'please make sure you have installed the required packages.', 'red')
     traceback.print_exc()
     JaxPlannerDashboard = None
 
@@ -159,24 +159,24 @@ class JaxParameterTuning:
         kernel3 = Matern(length_scale=5.0, length_scale_bounds=(1.0, 5.0), nu=2.5)
         return weight1 * kernel1 + weight2 * kernel2 + weight3 * kernel3
         
-    def summarize_hyperparameters(self) -> None:
+    def summarize_hyperparameters(self) -> str:
         hyper_params_table = []
         for (_, param) in self.hyperparams_dict.items():
             hyper_params_table.append(f'        {str(param)}')
         hyper_params_table = '\n'.join(hyper_params_table)
-        print(f'hyperparameter optimizer parameters:\n'
-              f'    tuned_hyper_parameters    =\n{hyper_params_table}\n'
-              f'    initialization_args       ={self.gp_init_kwargs}\n'
-              f'    gp_params                 ={self.gp_params}\n'
-              f'    tuning_iterations         ={self.gp_iters}\n'
-              f'    tuning_timeout            ={self.timeout_tuning}\n'
-              f'    tuning_batch_size         ={self.num_workers}\n'
-              f'    mp_pool_context_type      ={self.pool_context}\n'
-              f'    mp_pool_poll_frequency    ={self.poll_frequency}\n'
-              f'meta-objective parameters:\n'
-              f'    planning_trials_per_iter  ={self.eval_trials}\n'
-              f'    rollouts_per_trial        ={self.rollouts_per_trial}\n'
-              f'    acquisition_fn            ={self.acquisition}')
+        return (f'hyperparameter optimizer parameters:\n'
+                f'    tuned_hyper_parameters    =\n{hyper_params_table}\n'
+                f'    initialization_args       ={self.gp_init_kwargs}\n'
+                f'    gp_params                 ={self.gp_params}\n'
+                f'    tuning_iterations         ={self.gp_iters}\n'
+                f'    tuning_timeout            ={self.timeout_tuning}\n'
+                f'    tuning_batch_size         ={self.num_workers}\n'
+                f'    mp_pool_context_type      ={self.pool_context}\n'
+                f'    mp_pool_poll_frequency    ={self.poll_frequency}\n'
+                f'meta-objective parameters:\n'
+                f'    planning_trials_per_iter  ={self.eval_trials}\n'
+                f'    rollouts_per_trial        ={self.rollouts_per_trial}\n'
+                f'    acquisition_fn            ={self.acquisition}')
         
     @staticmethod
     def annealing_acquisition(n_samples: int, n_delay_samples: int=0,
@@ -346,6 +346,7 @@ class JaxParameterTuning:
         
         # remove keywords that should not be in the tuner
         train_args.pop('dashboard', None)
+        planner_args.pop('parallel_updates', None)
     
         # initialize env for evaluation (need fresh copy to avoid concurrency)
         env = RDDLEnv(domain, instance, vectorized=True, enforce_action_constraints=False)
@@ -368,18 +369,32 @@ class JaxParameterTuning:
     
     def tune_optimizer(self, optimizer: BayesianOptimization) -> None:
         '''Tunes the Bayesian optimization algorithm hyper-parameters.'''
-        print('\n' + f'The current kernel is {repr(optimizer._gp.kernel_)}.')
+        print(f'Kernel: {repr(optimizer._gp.kernel_)}.')
         
-    def tune(self, key: int, log_file: str, show_dashboard: bool=False) -> ParameterValues:
-        '''Tunes the hyper-parameters for Jax planner, returns the best found.'''
+    def tune(self, key: int, 
+             log_file: Optional[str]=None, 
+             show_dashboard: bool=False, 
+             print_hyperparams: bool=False) -> ParameterValues:
+        '''Tunes the hyper-parameters for Jax planner, returns the best found.
         
-        self.summarize_hyperparameters()
+        :param key: RNG key to seed the hyper-parameter optimizer
+        :param log_file: optional path to file where tuning progress will be saved
+        :param show_dashboard: whether to display tuning results in a dashboard
+        :param print_hyperparams: whether to print a hyper-parameter summary of the 
+        optimizer
+        '''
         
-        # clear and prepare output file
-        with open(log_file, 'w', newline='') as file:
-            writer = csv.writer(file)
-            writer.writerow(COLUMNS + list(self.hyperparams_dict.keys()))
+        if self.verbose:
+            print(JaxBackpropPlanner.summarize_system())
+        if print_hyperparams:
+            print(self.summarize_hyperparameters())
         
+        # clear and prepare output file
+        if log_file is not None:
+            with open(log_file, 'w', newline='') as file:
+                writer = csv.writer(file)
+                writer.writerow(COLUMNS + list(self.hyperparams_dict.keys()))
+            
         # create a dash-board for visualizing experiment runs
         if show_dashboard and JaxPlannerDashboard is not None:
             dashboard = JaxPlannerDashboard()
@@ -445,13 +460,15 @@ class JaxParameterTuning:
                 # check if there is enough time left for another iteration
                 elapsed = time.time() - start_time
                 if elapsed >= self.timeout_tuning:
-                    print(f'global time limit reached at iteration {it}, aborting')
+                    message = termcolor.colored(
+                        f'[INFO] Global time limit reached at iteration {it}.', 'green')
+                    print(message)
                     break
                 
                 # continue with next iteration
                 print('\n' + '*' * 80 + 
                       f'\n[{datetime.timedelta(seconds=elapsed)}] ' + 
-                      f'starting iteration {it + 1}' + 
+                      f'Starting iteration {it + 1}' + 
                       '\n' + '*' * 80)
                 key, *subkeys = jax.random.split(key, num=num_workers + 1)
                 rows = [None] * num_workers
@@ -507,15 +524,19 @@ class JaxParameterTuning:
                 
                 # print best parameter if found
                 if best_target > old_best_target:
-                    print(f'* found new best average reward {best_target:.6f}')
+                    message = termcolor.colored(
+                        f'[INFO] Found new best average reward {best_target:.6f}.', 
+                        'green')
+                    print(message)
                 
                 # tune the optimizer here
                 self.tune_optimizer(optimizer)
                 
                 # write results of all processes in current iteration to file
-                with open(log_file, 'a', newline='') as file:
-                    writer = csv.writer(file)
-                    writer.writerows(rows)
+                if log_file is not None:
+                    with open(log_file, 'a', newline='') as file:
+                        writer = csv.writer(file)
+                        writer.writerows(rows)
                     
                 # update the dashboard tuning
                 if show_dashboard:
@@ -528,7 +549,7 @@ class JaxParameterTuning:
         
         # print summary of results
         elapsed = time.time() - start_time
-        print(f'summary of hyper-parameter optimization:\n'
+        print(f'Summary of hyper-parameter optimization:\n'
               f'    time_elapsed         ={datetime.timedelta(seconds=elapsed)}\n'
               f'    iterations           ={it + 1}\n'
               f'    best_hyper_parameters={best_params}\n'

pyRDDLGym_jax/entry_point.py

@@ -2,24 +2,56 @@ import argparse
 
 from pyRDDLGym_jax.examples import run_plan, run_tune
 
+EPILOG = 'For complete documentation, see https://pyrddlgym.readthedocs.io/en/latest/jax.html.'
+
 def main():
-    parser = argparse.ArgumentParser(description="Command line parser for the JaxPlan planner.")
+    parser = argparse.ArgumentParser(prog='jaxplan',
+                                     description="command line parser for the jaxplan planner",
+                                     epilog=EPILOG)
     subparsers = parser.add_subparsers(dest="jaxplan", required=True)
 
     # planning
-    parser_plan = subparsers.add_parser("plan", help="Executes JaxPlan on a specified RDDL problem and method (slp, drp, or replan).")
-    parser_plan.add_argument('args', nargs=argparse.REMAINDER)
+    parser_plan = subparsers.add_parser("plan", 
+                                        help="execute jaxplan on a specified RDDL problem",
+                                        epilog=EPILOG)
+    parser_plan.add_argument('domain', type=str,  
+                             help='name of domain in rddlrepository or a valid file path')
+    parser_plan.add_argument('instance', type=str, 
+                             help='name of instance in rddlrepository or a valid file path')
+    parser_plan.add_argument('method', type=str, 
+                             help='training method to apply: [slp, drp] are offline methods, and [replan] are online')
+    parser_plan.add_argument('-e', '--episodes', type=int, required=False, default=1, 
+                             help='number of training or evaluation episodes')
 
     # tuning
-    parser_tune = subparsers.add_parser("tune", help="Tunes JaxPlan on a specified RDDL problem and method (slp, drp, or replan).")
-    parser_tune.add_argument('args', nargs=argparse.REMAINDER)
+    parser_tune = subparsers.add_parser("tune", 
+                                        help="tune jaxplan on a specified RDDL problem",
+                                        epilog=EPILOG)
+    parser_tune.add_argument('domain', type=str,  
+                             help='name of domain in rddlrepository or a valid file path')
+    parser_tune.add_argument('instance', type=str, 
+                             help='name of instance in rddlrepository or a valid file path')
+    parser_tune.add_argument('method', type=str, 
+                             help='training method to apply: [slp, drp] are offline methods, and [replan] are online')
+    parser_tune.add_argument('-t', '--trials', type=int, required=False, default=5, 
+                             help='number of evaluation rollouts per hyper-parameter choice')
+    parser_tune.add_argument('-i', '--iters', type=int, required=False, default=20, 
+                             help='number of iterations of bayesian optimization')
+    parser_tune.add_argument('-w', '--workers', type=int, required=False, default=4, 
+                             help='number of parallel hyper-parameters to evaluate per iteration')
+    parser_tune.add_argument('-d', '--dashboard', type=bool, required=False, default=False, 
+                             help='show the dashboard')
+    parser_tune.add_argument('-f', '--filepath', type=str, required=False, default='', 
+                             help='where to save the config file of the best hyper-parameters')
 
     # dispatch
     args = parser.parse_args()
     if args.jaxplan == "plan":
-        run_plan.run_from_args(args.args)
+        run_plan.main(args.domain, args.instance, args.method, args.episodes)
     elif args.jaxplan == "tune":
-        run_tune.run_from_args(args.args)
+        run_tune.main(args.domain, args.instance, args.method, 
+                      args.trials, args.iters, args.workers, args.dashboard, 
+                      args.filepath)
     else:
         parser.print_help()
 

pyRDDLGym_jax/examples/configs/tuning_drp.cfg

@@ -11,6 +11,7 @@ optimizer='rmsprop'
 optimizer_kwargs={'learning_rate': LEARNING_RATE_TUNE}
 batch_size_train=32
 batch_size_test=32
+print_warnings=False
 
 [Training]
 train_seconds=30

pyRDDLGym_jax/examples/configs/tuning_replan.cfg

@@ -12,6 +12,7 @@ optimizer_kwargs={'learning_rate': LEARNING_RATE_TUNE}
 batch_size_train=32
 batch_size_test=32
 rollout_horizon=ROLLOUT_HORIZON_TUNE
+print_warnings=False
 
 [Training]
 train_seconds=1

pyRDDLGym_jax/examples/configs/tuning_slp.cfg

@@ -11,6 +11,7 @@ optimizer='rmsprop'
 optimizer_kwargs={'learning_rate': LEARNING_RATE_TUNE}
 batch_size_train=32
 batch_size_test=32
+print_warnings=False
 
 [Training]
 train_seconds=30

pyRDDLGym_jax/examples/run_plan.py

@@ -26,7 +26,7 @@ from pyRDDLGym_jax.core.planner import (
 )
 
     
-def main(domain, instance, method, episodes=1):
+def main(domain: str, instance: str, method: str, episodes: int=1) -> None:
     
     # set up the environment
     env = pyRDDLGym.make(domain, instance, vectorized=True)
@@ -36,8 +36,8 @@ def main(domain, instance, method, episodes=1):
         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 {config_path} was not found, '
-                          f'using default_{method}.cfg.', 'red')
+            raise_warning(f'[WARN] Config file {config_path} was not found, '
+                          f'using default_{method}.cfg.', 'yellow')
             config_path = os.path.join(abs_path, 'configs', f'default_{method}.cfg') 
     elif os.path.isfile(method):
         config_path = method

pyRDDLGym_jax/examples/run_scipy.py

@@ -31,8 +31,8 @@ def main(domain, instance, method, episodes=1):
     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')
+        raise_warning(f'[WARN] Config file {config_path} was not found, '
+                      f'using default_slp.cfg.', 'yellow')
         config_path = os.path.join(abs_path, 'configs', 'default_slp.cfg') 
     planner_args, _, train_args = load_config(config_path)
 

pyRDDLGym_jax/examples/run_tune.py

@@ -36,7 +36,9 @@ def power_10(x):
     return 10.0 ** x
 
 
-def main(domain, instance, method, trials=5, iters=20, workers=4, dashboard=False):
+def main(domain: str, instance: str, method: str, 
+         trials: int=5, iters: int=20, workers: int=4, dashboard: bool=False, 
+         filepath: str='') -> None:
     
     # set up the environment   
     env = pyRDDLGym.make(domain, instance, vectorized=True)
@@ -68,6 +70,9 @@ def main(domain, instance, method, trials=5, iters=20, workers=4, dashboard=Fals
     tuning.tune(key=42, 
                 log_file=f'gp_{method}_{domain}_{instance}.csv', 
                 show_dashboard=dashboard)
+    if filepath is not None and filepath:
+        with open(filepath, "w") as file:
+            file.write(tuning.best_config)
     
     # evaluate the agent on the best parameters
     planner_args, _, train_args = load_config_from_string(tuning.best_config)
@@ -80,7 +85,7 @@ def main(domain, instance, method, trials=5, iters=20, workers=4, dashboard=Fals
 
 def run_from_args(args):
     if len(args) < 3:
-        print('python run_tune.py <domain> <instance> <method> [<trials>] [<iters>] [<workers>] [<dashboard>]')
+        print('python run_tune.py <domain> <instance> <method> [<trials>] [<iters>] [<workers>] [<dashboard>] [<filepath>]')
         exit(1)
     if args[2] not in ['drp', 'slp', 'replan']:
         print('<method> in [drp, slp, replan]')
@@ -90,6 +95,7 @@ def run_from_args(args):
     if len(args) >= 5: kwargs['iters'] = int(args[4])
     if len(args) >= 6: kwargs['workers'] = int(args[5])
     if len(args) >= 7: kwargs['dashboard'] = bool(args[6])
+    if len(args) >= 8: kwargs['filepath'] = bool(args[7])
     main(**kwargs) 
 
 

{pyrddlgym_jax-2.3.dist-info → pyrddlgym_jax-2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pyRDDLGym-jax
-Version: 2.3
+Version: 2.5
 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
@@ -39,6 +39,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python
@@ -116,7 +117,7 @@ pip install pyRDDLGym-jax[extra,dashboard]
 A basic run script is provided to train JaxPlan on any RDDL problem:
 
 ```shell
-jaxplan plan <domain> <instance> <method> <episodes>
+jaxplan plan <domain> <instance> <method> --episodes <episodes>
 ```
 
 where:
@@ -241,7 +242,7 @@ More documentation about this and other new features will be coming soon.
 A basic run script is provided to run automatic Bayesian hyper-parameter tuning for the most sensitive parameters of JaxPlan:
 
 ```shell
-jaxplan tune <domain> <instance> <method> <trials> <iters> <workers> <dashboard>
+jaxplan tune <domain> <instance> <method> --trials <trials> --iters <iters> --workers <workers> --dashboard <dashboard> --filepath <filepath>
 ```
 
 where:
@@ -251,7 +252,8 @@ where:
 - ``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``
-- ``dashboard`` is whether the optimizations are tracked in the dashboard application.
+- ``dashboard`` is whether the optimizations are tracked in the dashboard application
+- ``filepath`` is the optional file path where a config file with the best hyper-parameter setting will be saved.
 
 It is easy to tune a custom range of the planner's hyper-parameters efficiently. 
 First create a config file template with patterns replacing concrete parameter values that you want to tune, e.g.:
@@ -291,23 +293,16 @@ env = pyRDDLGym.make(domain, instance, vectorized=True)
 with open('path/to/config.cfg', 'r') as file: 
     config_template = file.read() 
     
-# map parameters in the config that will be tuned
+# tune weight from 10^-1 ... 10^5 and lr from 10^-5 ... 10^1
 def power_10(x):
-    return 10.0 ** x
-    
-hyperparams = [
-    Hyperparameter('TUNABLE_WEIGHT', -1., 5., power_10),  # tune weight from 10^-1 ... 10^5
-    Hyperparameter('TUNABLE_LEARNING_RATE', -5., 1., power_10),   # tune lr from 10^-5 ... 10^1
-]
+    return 10.0 ** x    
+hyperparams = [Hyperparameter('TUNABLE_WEIGHT', -1., 5., power_10),
+               Hyperparameter('TUNABLE_LEARNING_RATE', -5., 1., power_10)]
     
 # build the tuner and tune
 tuning = JaxParameterTuning(env=env,
-                            config_template=config_template,
-                            hyperparams=hyperparams,
-                            online=False,
-                            eval_trials=trials,
-                            num_workers=workers,
-                            gp_iters=iters)
+                            config_template=config_template, hyperparams=hyperparams,
+                            online=False, eval_trials=trials, num_workers=workers, gp_iters=iters)
 tuning.tune(key=42, log_file='path/to/log.csv')
 ```
   

{pyrddlgym_jax-2.3.dist-info → pyrddlgym_jax-2.5.dist-info}/RECORD

@@ -1,20 +1,20 @@
-pyRDDLGym_jax/__init__.py,sha256=ab_pLSTaKv50-5b6lazl75TqhQi0bNsErQ8JlBepVII,19
-pyRDDLGym_jax/entry_point.py,sha256=dxDlO_5gneEEViwkLCg30Z-KVzUgdRXaKuFjoZklkA0,974
+pyRDDLGym_jax/__init__.py,sha256=VoxLo_sy8RlJIIyu7szqL-cdMGBJdQPg-aSeyOVVIkY,19
+pyRDDLGym_jax/entry_point.py,sha256=K0zy1oe66jfBHkHHCM6aGHbbiVqnQvDhDb8se4uaKHE,3319
 pyRDDLGym_jax/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyRDDLGym_jax/core/compiler.py,sha256=fLOdJED-Cxtm_IT4LRiZ461Alp9Qjr0vBsOnw1s__EY,82612
-pyRDDLGym_jax/core/logic.py,sha256=0NNm0OaeKv46K0VNY6vL0PHOUFZPNxqQLOvQYkHCswM,56093
-pyRDDLGym_jax/core/planner.py,sha256=0rluBXKGNHRPEPfegOWcx9__cJHr8KjZdDJtG7i1JjI,122793
-pyRDDLGym_jax/core/simulator.py,sha256=DnPL93WVCMZqtqMUoiJdfWcH9pEvNgGfDfO4NV0wIS0,9271
-pyRDDLGym_jax/core/tuning.py,sha256=RKKtDZp7unvfbhZEoaunZtcAn5xtzGYqXBB_Ij_Aapc,24205
+pyRDDLGym_jax/core/compiler.py,sha256=uFCtoipsIa3MM9nGgT3X8iCViPl2XSPNXh0jMdzN0ko,82895
+pyRDDLGym_jax/core/logic.py,sha256=lfc2ak_ap_ajMEFlB5EHCRNgJym31dNyA-5d-7N4CZA,56271
+pyRDDLGym_jax/core/planner.py,sha256=M6GKzN7Ml57B4ZrFZhhkpsQCvReKaCQNzer7zeHCM9E,140275
+pyRDDLGym_jax/core/simulator.py,sha256=ayCATTUL3clLaZPQ5OUg2bI_c26KKCTq6TbrxbMsVdc,10470
+pyRDDLGym_jax/core/tuning.py,sha256=BWcQZk02TMLexTz1Sw4lX2EQKvmPbp7biC51M-IiNUw,25153
 pyRDDLGym_jax/core/visualization.py,sha256=4BghMp8N7qtF0tdyDSqtxAxNfP9HPrQWTiXzAMJmx7o,70365
 pyRDDLGym_jax/core/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyRDDLGym_jax/core/assets/favicon.ico,sha256=RMMrI9YvmF81TgYG7FO7UAre6WmYFkV3B2GmbA1l0kM,175085
 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=rXvNWkxe4jHllvbvU_EOMji_2-2k5d4tbBKhpMm_Gaw,1526
-pyRDDLGym_jax/examples/run_plan.py,sha256=v2AvwgIa4Ejr626vBOgWFJIQvay3IPKWno02ztIFCYc,2768
-pyRDDLGym_jax/examples/run_scipy.py,sha256=wvcpWCvdjvYHntO95a7JYfY2fuCMUTKnqjJikW0PnL4,2291
-pyRDDLGym_jax/examples/run_tune.py,sha256=WbGO8RudIK-cPMAMKvI8NbFQAqkG-Blbnta3Efsep6c,3828
+pyRDDLGym_jax/examples/run_plan.py,sha256=4y7JHqTxY5O1ltP6N7rar0jMiw7u9w1nuAIOcmDaAuE,2806
+pyRDDLGym_jax/examples/run_scipy.py,sha256=7uVnDXb7D3NTJqA2L8nrcYDJP-k0ba9dl9YqA2CD9ac,2301
+pyRDDLGym_jax/examples/run_tune.py,sha256=F5KWgtoCPbf7XHB6HW9LjxarD57U2LvuGdTz67OL1DY,4114
 pyRDDLGym_jax/examples/configs/Cartpole_Continuous_gym_drp.cfg,sha256=mE8MqhOlkHeXIGEVrnR3QY6I-_iy4uxFYRA71P1bmtk,347
 pyRDDLGym_jax/examples/configs/Cartpole_Continuous_gym_replan.cfg,sha256=nFFYHCKQUMn8x-OpJwu2pwe1tycNSJ8iAIwSkCBn33E,370
 pyRDDLGym_jax/examples/configs/Cartpole_Continuous_gym_slp.cfg,sha256=eJ3HvHjODoKdtX7u-AM51xQaHJnYgzEy2t3omNG2oCs,340
@@ -38,12 +38,12 @@ pyRDDLGym_jax/examples/configs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 pyRDDLGym_jax/examples/configs/default_drp.cfg,sha256=XeMWAAG_OFZo7JAMxS5-XXroZaeVMzfM0NswmEobIns,373
 pyRDDLGym_jax/examples/configs/default_replan.cfg,sha256=CK4cEz8ReXyAZPLaLG9clIIRXAqM3IplUCxbLt_V2lY,407
 pyRDDLGym_jax/examples/configs/default_slp.cfg,sha256=mJo0woDevhQCSQfJg30ULVy9qGIJDIw73XCe6pyIPtg,369
-pyRDDLGym_jax/examples/configs/tuning_drp.cfg,sha256=CQMpSCKTkGioO7U82mHMsYWFRsutULx0V6Wrl3YzV2U,504
-pyRDDLGym_jax/examples/configs/tuning_replan.cfg,sha256=m_0nozFg_GVld0tGv92Xao_KONFJDq_vtiJKt5isqI8,501
-pyRDDLGym_jax/examples/configs/tuning_slp.cfg,sha256=KHu8II6CA-h_HblwvWHylNRjSvvGS3VHxN7JQNR4p_Q,464
-pyrddlgym_jax-2.3.dist-info/LICENSE,sha256=Y0Gi6H6mLOKN-oIKGZulQkoTJyPZeAaeuZu7FXH-meg,1095
-pyrddlgym_jax-2.3.dist-info/METADATA,sha256=MS6tckyg-bAQBGZJ112VQPZm5at660EfhntCnfrlUbE,17021
-pyrddlgym_jax-2.3.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-pyrddlgym_jax-2.3.dist-info/entry_points.txt,sha256=Q--z9QzqDBz1xjswPZ87PU-pib-WPXx44hUWAFoBGBA,59
-pyrddlgym_jax-2.3.dist-info/top_level.txt,sha256=n_oWkP_BoZK0VofvPKKmBZ3NPk86WFNvLhi1BktCbVQ,14
-pyrddlgym_jax-2.3.dist-info/RECORD,,
+pyRDDLGym_jax/examples/configs/tuning_drp.cfg,sha256=zocZn_cVarH5i0hOlt2Zu0NwmXYBmTTghLaXLtQOGto,526
+pyRDDLGym_jax/examples/configs/tuning_replan.cfg,sha256=9oIhtw9cuikmlbDgCgbrTc5G7hUio-HeAv_3CEGVclY,523
+pyRDDLGym_jax/examples/configs/tuning_slp.cfg,sha256=QqnyR__5-HhKeCDfGDel8VIlqsjxRHk4SSH089zJP8s,486
+pyrddlgym_jax-2.5.dist-info/licenses/LICENSE,sha256=Y0Gi6H6mLOKN-oIKGZulQkoTJyPZeAaeuZu7FXH-meg,1095
+pyrddlgym_jax-2.5.dist-info/METADATA,sha256=XAaEJfbsYW-txxZhFZ6o_HmvqxkIMTqBF9LbV-KdTzI,17058
+pyrddlgym_jax-2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyrddlgym_jax-2.5.dist-info/entry_points.txt,sha256=Q--z9QzqDBz1xjswPZ87PU-pib-WPXx44hUWAFoBGBA,59
+pyrddlgym_jax-2.5.dist-info/top_level.txt,sha256=n_oWkP_BoZK0VofvPKKmBZ3NPk86WFNvLhi1BktCbVQ,14
+pyrddlgym_jax-2.5.dist-info/RECORD,,

{pyrddlgym_jax-2.3.dist-info → pyrddlgym_jax-2.5.dist-info}/WHEEL

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