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

pyRDDLGym_jax/core/tuning.py

@@ -9,7 +9,7 @@ import warnings
 warnings.filterwarnings("ignore")
 
 from bayes_opt import BayesianOptimization
-from bayes_opt.util import UtilityFunction
+from bayes_opt.acquisition import AcquisitionFunction, UpperConfidenceBound
 import jax
 import numpy as np
 
@@ -26,7 +26,6 @@ from pyRDDLGym_jax.core.planner import (
 
 Kwargs = Dict[str, Any]
 
-
 # ===============================================================================
 # 
 # GENERIC TUNING MODULE
@@ -37,6 +36,9 @@ Kwargs = Dict[str, Any]
 # 3. deep reactive policies
 # 
 # ===============================================================================
+COLUMNS = ['pid', 'worker', 'iteration', 'target', 'best_target', 'acq_params']
+
+
 class JaxParameterTuning:
     '''A general-purpose class for tuning a Jax planner.'''
     
@@ -53,7 +55,7 @@ class JaxParameterTuning:
                  num_workers: int=1,
                  poll_frequency: float=0.2,
                  gp_iters: int=25,
-                 acquisition: Optional[UtilityFunction]=None,
+                 acquisition: Optional[AcquisitionFunction]=None,
                  gp_init_kwargs: Optional[Kwargs]=None,
                  gp_params: Optional[Kwargs]=None) -> None:
         '''Creates a new instance for tuning hyper-parameters for Jax planners
@@ -113,10 +115,9 @@ class JaxParameterTuning:
         self.gp_params = gp_params
         
         # create acquisition function
-        self.acq_args = None
         if acquisition is None:
             num_samples = self.gp_iters * self.num_workers
-            acquisition, self.acq_args = JaxParameterTuning._annealing_utility(num_samples)
+            acquisition = JaxParameterTuning._annealing_acquisition(num_samples)
         self.acquisition = acquisition
     
     def summarize_hyperparameters(self) -> None:
@@ -133,23 +134,15 @@ class JaxParameterTuning:
               f'    planning_trials_per_iter  ={self.eval_trials}\n'
               f'    planning_iters_per_trial  ={self.train_epochs}\n'
               f'    planning_timeout_per_trial={self.timeout_training}\n'
-              f'    acquisition_fn            ={type(self.acquisition).__name__}')
-        if self.acq_args is not None:
-            print(f'using default acquisition function:\n'
-                  f'    utility_kind ={self.acq_args[0]}\n'
-                  f'    initial_kappa={self.acq_args[1]}\n'
-                  f'    kappa_decay  ={self.acq_args[2]}')
+              f'    acquisition_fn            ={self.acquisition}')
         
     @staticmethod
-    def _annealing_utility(n_samples, n_delay_samples=0, kappa1=10.0, kappa2=1.0):
-        kappa_decay = (kappa2 / kappa1) ** (1.0 / (n_samples - n_delay_samples))
-        utility_fn = UtilityFunction(
-            kind='ucb',
+    def _annealing_acquisition(n_samples, n_delay_samples=0, kappa1=10.0, kappa2=1.0):
+        acq_fn = UpperConfidenceBound(
             kappa=kappa1,
-            kappa_decay=kappa_decay,
-            kappa_decay_delay=n_delay_samples)
-        utility_args = ['ucb', kappa1, kappa_decay]
-        return utility_fn, utility_args
+            exploration_decay=(kappa2 / kappa1) ** (1.0 / (n_samples - n_delay_samples)),
+            exploration_decay_delay=n_delay_samples)
+        return acq_fn
     
     def _pickleable_objective_with_kwargs(self):
         raise NotImplementedError
@@ -160,7 +153,7 @@ class JaxParameterTuning:
         pid = os.getpid()
         return index, pid, params, target
 
-    def tune(self, key: jax.random.PRNGKey, 
+    def tune(self, key: jax.random.PRNGKey,
              filename: str,
              save_plot: bool=False) -> Dict[str, Any]:
         '''Tunes the hyper-parameters for Jax planner, returns the best found.'''
@@ -178,32 +171,28 @@ class JaxParameterTuning:
             for (name, hparam) in self.hyperparams_dict.items()
         }
         optimizer = BayesianOptimization(
-            f=None,  # probe() is not called
+            f=None,
+            acquisition_function=self.acquisition,
             pbounds=hyperparams_bounds,
             allow_duplicate_points=True,  # to avoid crash
             random_state=np.random.RandomState(key),
             **self.gp_init_kwargs
         )
         optimizer.set_gp_params(**self.gp_params)
-        utility = self.acquisition
         
         # suggest initial parameters to evaluate
         num_workers = self.num_workers
-        suggested, kappas = [], []
+        suggested, acq_params = [], []
         for _ in range(num_workers):
-            utility.update_params()
-            probe = optimizer.suggest(utility)
-            suggested.append(probe)  
-            kappas.append(utility.kappa)
+            probe = optimizer.suggest()
+            suggested.append(probe) 
+            acq_params.append(vars(optimizer.acquisition_function))
         
         # clear and prepare output file
         filename = self._filename(filename, 'csv')
         with open(filename, 'w', newline='') as file:
             writer = csv.writer(file)
-            writer.writerow(
-                ['pid', 'worker', 'iteration', 'target', 'best_target', 'kappa'] + \
-                list(hyperparams_bounds.keys())
-            )
+            writer.writerow(COLUMNS + list(hyperparams_bounds.keys()))
                 
         # start multiprocess evaluation
         worker_ids = list(range(num_workers))
@@ -219,8 +208,8 @@ class JaxParameterTuning:
             
             # continue with next iteration
             print('\n' + '*' * 25 + 
-                  '\n' + f'[{datetime.timedelta(seconds=elapsed)}] ' + 
-                  f'starting iteration {it}' + 
+                  f'\n[{datetime.timedelta(seconds=elapsed)}] ' + 
+                  f'starting iteration {it + 1}' + 
                   '\n' + '*' * 25)
             key, *subkeys = jax.random.split(key, num=num_workers + 1)
             rows = [None] * num_workers
@@ -256,10 +245,9 @@ class JaxParameterTuning:
                         optimizer.register(params, target)
                         
                         # update acquisition function and suggest a new point
-                        utility.update_params()  
-                        suggested[index] = optimizer.suggest(utility)
-                        old_kappa = kappas[index]
-                        kappas[index] = utility.kappa
+                        suggested[index] = optimizer.suggest()
+                        old_acq_params = acq_params[index]
+                        acq_params[index] = vars(optimizer.acquisition_function)
                         
                         # transform suggestion back to natural space
                         rddl_params = {
@@ -272,8 +260,8 @@ class JaxParameterTuning:
                             best_params, best_target = rddl_params, target
                         
                         # write progress to file in real time
-                        rows[index] = [pid, index, it, target, best_target, old_kappa] + \
-                                      list(rddl_params.values())
+                        info_i = [pid, index, it, target, best_target, old_acq_params]
+                        rows[index] = info_i + list(rddl_params.values())
                         
             # write results of all processes in current iteration to file
             with open(filename, 'a', newline='') as file:
@@ -308,16 +296,20 @@ class JaxParameterTuning:
             raise_warning(f'failed to import packages matplotlib or sklearn, '
                           f'aborting plot of search space\n{e}', 'red')
         else:
-            data = np.loadtxt(filename, delimiter=',', dtype=object)
-            data, target = data[1:, 3:], data[1:, 2]
-            data = data.astype(np.float64)
-            target = target.astype(np.float64)
+            with open(filename, 'r') as file:
+                data_iter = csv.reader(file, delimiter=',')
+                data = [row for row in data_iter]
+            data = np.asarray(data, dtype=object)
+            hparam = data[1:, len(COLUMNS):].astype(np.float64)
+            target = data[1:, 3].astype(np.float64)
             target = (target - np.min(target)) / (np.max(target) - np.min(target))
             embedding = MDS(n_components=2, normalized_stress='auto')
-            data1 = embedding.fit_transform(data)
-            sc = plt.scatter(data1[:, 0], data1[:, 1], c=target, s=4.,
-                             cmap='seismic', edgecolor='gray',
-                             linewidth=0.01, alpha=0.4)
+            hparam_low = embedding.fit_transform(hparam)
+            sc = plt.scatter(hparam_low[:, 0], hparam_low[:, 1], c=target, s=5,
+                             cmap='seismic', edgecolor='gray', linewidth=0)
+            ax = plt.gca()
+            for i in range(len(target)):
+                ax.annotate(str(i), (hparam_low[i, 0], hparam_low[i, 1]), fontsize=3)         
             plt.colorbar(sc)
             plt.savefig(self._filename('gp_points', 'pdf'))
             plt.clf()
@@ -342,9 +334,11 @@ def objective_slp(params, kwargs, key, index):
         std, lr, w, wa = param_values
     else:
         std, lr, w = param_values
-        wa = None                      
+        wa = None         
+    key, subkey = jax.random.split(key)             
     if kwargs['verbose']:
-        print(f'[{index}] key={key}, std={std}, lr={lr}, w={w}, wa={wa}...', flush=True)
+        print(f'[{index}] key={subkey[0]}, '
+              f'std={std}, lr={lr}, w={w}, wa={wa}...', flush=True)
         
     # initialize planning algorithm
     planner = JaxBackpropPlanner(
@@ -358,7 +352,6 @@ def objective_slp(params, kwargs, key, index):
     model_params = {name: w for name in planner.compiled.model_params}
     
     # initialize policy
-    key, subkey = jax.random.split(key)
     policy = JaxOfflineController(
         planner=planner,
         key=subkey,
@@ -384,7 +377,7 @@ def objective_slp(params, kwargs, key, index):
         key, subkey = jax.random.split(key)
         total_reward = policy.evaluate(env, seed=np.array(subkey)[0])['mean']
         if kwargs['verbose']:
-            print(f'    [{index}] trial {trial + 1} key={subkey}, '
+            print(f'    [{index}] trial {trial + 1} key={subkey[0]}, '
                   f'reward={total_reward}', flush=True)
         average_reward += total_reward / kwargs['eval_trials']        
     if kwargs['verbose']:
@@ -474,8 +467,10 @@ def objective_replan(params, kwargs, key, index):
     else:
         std, lr, w, T = param_values
         wa = None        
+    key, subkey = jax.random.split(key)
     if kwargs['verbose']:
-        print(f'[{index}] key={key}, std={std}, lr={lr}, w={w}, wa={wa}, T={T}...', flush=True)
+        print(f'[{index}] key={subkey[0]}, '
+              f'std={std}, lr={lr}, w={w}, wa={wa}, T={T}...', flush=True)
 
     # initialize planning algorithm
     planner = JaxBackpropPlanner(
@@ -490,7 +485,6 @@ def objective_replan(params, kwargs, key, index):
     model_params = {name: w for name in planner.compiled.model_params}
     
     # initialize controller
-    key, subkey = jax.random.split(key)
     policy = JaxOnlineController(
         planner=planner,
         key=subkey,
@@ -516,7 +510,7 @@ def objective_replan(params, kwargs, key, index):
         key, subkey = jax.random.split(key)
         total_reward = policy.evaluate(env, seed=np.array(subkey)[0])['mean']
         if kwargs['verbose']:
-            print(f'    [{index}] trial {trial + 1} key={subkey}, '
+            print(f'    [{index}] trial {trial + 1} key={subkey[0]}, '
                   f'reward={total_reward}', flush=True)
         average_reward += total_reward / kwargs['eval_trials']        
     if kwargs['verbose']:
@@ -602,9 +596,11 @@ def objective_drp(params, kwargs, key, index):
     ]
     
     # unpack hyper-parameters
-    lr, w, layers, neurons = param_values                      
+    lr, w, layers, neurons = param_values   
+    key, subkey = jax.random.split(key)                   
     if kwargs['verbose']:
-        print(f'[{index}] key={key}, lr={lr}, w={w}, layers={layers}, neurons={neurons}...', flush=True)
+        print(f'[{index}] key={subkey[0]}, '
+              f'lr={lr}, w={w}, layers={layers}, neurons={neurons}...', flush=True)
            
     # initialize planning algorithm
     planner = JaxBackpropPlanner(
@@ -618,7 +614,6 @@ def objective_drp(params, kwargs, key, index):
     model_params = {name: w for name in planner.compiled.model_params}
     
     # initialize policy
-    key, subkey = jax.random.split(key)
     policy = JaxOfflineController(
         planner=planner,
         key=subkey,
@@ -644,7 +639,7 @@ def objective_drp(params, kwargs, key, index):
         key, subkey = jax.random.split(key)
         total_reward = policy.evaluate(env, seed=np.array(subkey)[0])['mean']
         if kwargs['verbose']:
-            print(f'    [{index}] trial {trial + 1} key={subkey}, '
+            print(f'    [{index}] trial {trial + 1} key={subkey[0]}, '
                   f'reward={total_reward}', flush=True)
         average_reward += total_reward / kwargs['eval_trials']
     if kwargs['verbose']:

pyRDDLGym_jax/examples/configs/Cartpole_Continuous_gym_replan.cfg

@@ -16,4 +16,5 @@ rollout_horizon=30
 [Training]
 key=42
 epochs=1000
-train_seconds=1
+train_seconds=1
+print_summary=False

pyRDDLGym_jax/examples/configs/PowerGen_Continuous_replan.cfg

@@ -16,4 +16,5 @@ rollout_horizon=5
 [Training]
 key=42
 epochs=2000
-train_seconds=1
+train_seconds=1
+print_summary=False

pyRDDLGym_jax/examples/configs/Reservoir_Continuous_replan.cfg

@@ -16,4 +16,5 @@ rollout_horizon=5
 [Training]
 key=42
 epochs=500
-train_seconds=1
+train_seconds=1
+print_summary=False

pyRDDLGym_jax/examples/configs/Wildfire_MDP_ippc2014_replan.cfg

@@ -6,9 +6,9 @@ tnorm_kwargs={}
 
 [Optimizer]
 method='JaxStraightLinePlan'
-method_kwargs={'initializer': 'normal', 'initializer_kwargs': {'stddev': 0.001}}
+method_kwargs={}
 optimizer='rmsprop'
-optimizer_kwargs={'learning_rate': 0.001}
+optimizer_kwargs={'learning_rate': 0.1}
 batch_size_train=32
 batch_size_test=32
 rollout_horizon=5
@@ -17,4 +17,5 @@ rollout_horizon=5
 key=42
 epochs=1000
 train_seconds=1
-policy_hyperparams={'cut-out': 10.0, 'put-out': 10.0}
+policy_hyperparams={'cut-out': 10.0, 'put-out': 10.0}
+print_summary=False

pyRDDLGym_jax/examples/configs/default_replan.cfg

@@ -17,4 +17,5 @@ rollout_horizon=5
 key=42
 epochs=2000
 train_seconds=1
-policy_hyperparams=2.0
+policy_hyperparams=2.0
+print_summary=False

pyRDDLGym_jax/examples/run_tune.py

@@ -59,9 +59,7 @@ def main(domain, instance, method, trials=5, iters=20, workers=4):
                           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}')
+    tuning.tune(key=train_args['key'], filename=f'gp_{method}', save_plot=True)
 
 
 if __name__ == "__main__":

{pyRDDLGym_jax-0.4.dist-info → pyRDDLGym_jax-0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyRDDLGym-jax
-Version: 0.4
+Version: 0.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
@@ -13,16 +13,18 @@ Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 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
+Provides-Extra: extra
+Requires-Dist: bayesian-optimization >=2.0.0 ; extra == 'extra'
+Requires-Dist: rddlrepository >=2.0 ; extra == 'extra'
 
 # pyRDDLGym-jax
 
@@ -57,17 +59,17 @@ To use the compiler or planner without the automated hyper-parameter tuning, you
 - ``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``.
+To run the automated tuning optimization, you will also need ``bayesian-optimization>=2.0.0``.
 
-You can install this package, together with all of its requirements, via pip:
+You can install pyRDDLGym-jax with all requirements using pip:
 
 ```shell
-pip install rddlrepository pyRDDLGym-jax
+pip install pyRDDLGym-jax[extra]
 ```
 
 ## 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:
+A basic run script is provided to run the Jax Planner on any domain in ``rddlrepository`` from the install directory of pyRDDLGym-jax:
 
 ```shell
 python -m pyRDDLGym_jax.examples.run_plan <domain> <instance> <method> <episodes>
@@ -91,8 +93,8 @@ python -m pyRDDLGym_jax.examples.run_tune <domain> <instance> <method> <trials>
 ```
 
 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)
+- ``domain`` is the domain identifier as specified in rddlrepository
+- ``instance`` is the instance identifier
 - ``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

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

@@ -1,18 +1,18 @@
 pyRDDLGym_jax/__init__.py,sha256=rexmxcBiCOcwctw4wGvk7UxS9MfZn_1CYXp53SoLKlU,19
 pyRDDLGym_jax/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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/logic.py,sha256=s00vbLZgBA_EVzREiMLR3Ru2zrtGJu0b3agtNYGnN7E,28937
+pyRDDLGym_jax/core/planner.py,sha256=p_5BpOK3RHBZFUmKZ1P1VKaBl_Pz9Vx6OPB7P57nYyQ,106336
 pyRDDLGym_jax/core/simulator.py,sha256=hWv6pr-4V-SSCzBYgdIPmKdUDMalft-Zh6dzOo5O9-0,8331
-pyRDDLGym_jax/core/tuning.py,sha256=D_kD8wjqMroCdtjE9eksR2UqrqXJqazsAKrMEHwPxYM,29589
+pyRDDLGym_jax/core/tuning.py,sha256=TeKcBT9IxSeb5MShPWL8KuL4G7OPlMBFvRTjyehHv4M,29442
 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=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/run_tune.py,sha256=_Q6WWMHYnWReU8Q0dbrS6Evaw-1LsN8TFcJWe5QV7xo,3196
 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_replan.cfg,sha256=0_9-r1wJncP1C1hbWCBAZJxRnNFGboQn-H3kyyDlH_8,353
 pyRDDLGym_jax/examples/configs/Cartpole_Continuous_gym_slp.cfg,sha256=FxZ4xcg2j2PzeH-wUseRR280juQN5bJjoyt6PtI1W7c,329
 pyRDDLGym_jax/examples/configs/HVAC_ippc2023_drp.cfg,sha256=FTGFwRAGyeRrbDMh_FV8iv8ZHrlj3Htju4pfPNmKIcw,336
 pyRDDLGym_jax/examples/configs/HVAC_ippc2023_slp.cfg,sha256=wjtz86_Gz0RfQu3bbrz56PTXL8JMernINx7AtJuZCPs,314
@@ -22,23 +22,23 @@ pyRDDLGym_jax/examples/configs/MountainCar_Continuous_gym_slp.cfg,sha256=e7j-1Z6
 pyRDDLGym_jax/examples/configs/MountainCar_ippc2023_slp.cfg,sha256=Z6CxaOxHv4oF6nW7SfSn_HshlQGDlNCPGASTnDTdL7Q,327
 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_replan.cfg,sha256=uFduTjWwQxAVuKnNsmPLQB92MaBPmaHC59HNu8117FE,353
 pyRDDLGym_jax/examples/configs/PowerGen_Continuous_slp.cfg,sha256=kG1-02ScmwsEwX7QIAZTD7si90Mb06b79G5oqcMQ9Hg,316
 pyRDDLGym_jax/examples/configs/Quadcopter_drp.cfg,sha256=yGMBWiVZT8KdZ1PhQ4kIxPvnjht1ss0UheTV-Nt9oaA,364
 pyRDDLGym_jax/examples/configs/Quadcopter_slp.cfg,sha256=9QNl58PyoJYhmwvrhzUxlLEy8vGbmwE6lRuOdvhLjGQ,317
 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_replan.cfg,sha256=dGs2ZC6xZwU7_Wz68u2bSPbGBRCRjIb8XDVuK-ejOZA,352
 pyRDDLGym_jax/examples/configs/Reservoir_Continuous_slp.cfg,sha256=QwKzCAFaErrTCHaJwDPLOxPHpNGNuAKMUoZjLLnMrNc,314
 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_replan.cfg,sha256=01kb0ZyP7kd7Jy0sNuw0mXJUZQGfWuqdTkcGLz0172M,409
 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=S2-5hPZtgAwUAFpiCAgSi-cnGhYHSDzMGMmatwhbM78,344
-pyRDDLGym_jax/examples/configs/default_replan.cfg,sha256=VWWPhOYBRq4cWwtrChw5pPqRmlX_nHbMvwciHd9hoLc,357
+pyRDDLGym_jax/examples/configs/default_replan.cfg,sha256=4ndUgyFELiFAWhsfnkDqg_LO3fhza24bkMxFgg7Xnmg,378
 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.5.dist-info/LICENSE,sha256=Y0Gi6H6mLOKN-oIKGZulQkoTJyPZeAaeuZu7FXH-meg,1095
+pyRDDLGym_jax-0.5.dist-info/METADATA,sha256=TIAuFrlsilIcT1lWHdshjECEuBDO4yElSMGB_gH2EDM,12842
+pyRDDLGym_jax-0.5.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+pyRDDLGym_jax-0.5.dist-info/top_level.txt,sha256=n_oWkP_BoZK0VofvPKKmBZ3NPk86WFNvLhi1BktCbVQ,14
+pyRDDLGym_jax-0.5.dist-info/RECORD,,

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

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