Refactoring is all you need

.github/workflows/linting.yml

@@ -12,7 +12,7 @@ jobs:
       - name: Run black
         uses: psf/black@stable
         with:
-          args: "--check Pyrado setup_deps.py RcsPySim/setup.py"
+          src: "Pyrado setup_deps.py RcsPySim/setup.py"
   isort:
     name: Checking Import Order with isort
     runs-on: ubuntu-latest

.python-version

@@ -0,0 +1 @@
+3.7

Pyrado/pyrado/algorithms/episodic/predefined_lqr.py

@@ -102,7 +102,6 @@ def sampler(self, sampler: ParallelRolloutSampler):
         self._sampler = sampler
 
     def step(self, snapshot_mode: str, meta_info: dict = None):
-
         if isinstance(inner_env(self._env), BallOnPlate5DSim):
             ctrl_gains = to.tensor(
                 [

Pyrado/pyrado/algorithms/meta/adr.py

@@ -431,7 +431,6 @@ def __init__(
         logger: StepLogger = None,
         device: str = "cuda" if to.cuda.is_available() else "cpu",
     ):
-
         """
         Constructor
 
@@ -472,7 +471,6 @@ def get_reward(self, traj: StepSequence) -> to.Tensor:
     def train(
         self, reference_trajectory: StepSequence, randomized_trajectory: StepSequence, num_epoch: int
     ) -> to.Tensor:
-
         reference_batch_generator = reference_trajectory.iterate_rollouts()
         random_batch_generator = randomized_trajectory.iterate_rollouts()
 

Pyrado/pyrado/algorithms/regression/timeseries_prediction.py

@@ -104,7 +104,6 @@ def __init__(
             self._lr_scheduler = lr_scheduler(self.optim, **lr_scheduler_hparam)
 
     def step(self, snapshot_mode: str, meta_info: dict = None):
-
         # Feed one epoch of the training set to the policy
         if self.windowed:
             # Predict

Pyrado/pyrado/algorithms/step_based/dql.py

@@ -192,7 +192,6 @@ def update(self):
             file=sys.stdout,
             leave=False,
         ):
-
             # Sample steps and the associated next step from the replay memory
             steps, next_steps = self._memory.sample(self.batch_size)
             steps.torch(data_type=to.get_default_dtype())

Pyrado/pyrado/algorithms/step_based/gae.py

@@ -239,7 +239,6 @@ def update(self, rollouts: Sequence[StepSequence], use_empirical_returns: bool =
 
         # Iterate over all gathered samples num_epoch times
         for e in range(self.num_epoch):
-
             for batch in tqdm(
                 concat_ros.split_shuffled_batches(
                     self.batch_size, complete_rollouts=isinstance(self.vfcn, RecurrentPolicy)

Pyrado/pyrado/algorithms/step_based/ppo.py

@@ -176,7 +176,6 @@ def update(self, rollouts: Sequence[StepSequence]):
 
         # Iterations over the whole data set
         for e in range(self.num_epoch):
-
             for batch in tqdm(
                 concat_ros.split_shuffled_batches(self.batch_size, complete_rollouts=self._policy.is_recurrent),
                 total=num_iter_from_rollouts(None, concat_ros, self.batch_size),
@@ -412,7 +411,6 @@ def update(self, rollouts: Sequence[StepSequence]):
 
         # Iterations over the whole data set
         for e in range(self.num_epoch):
-
             for batch in tqdm(
                 concat_ros.split_shuffled_batches(
                     self.batch_size,

Pyrado/pyrado/domain_randomization/domain_parameter.py

@@ -393,6 +393,51 @@ def make_broadening(
             clip_up=clip_up,
         )
 
+    @staticmethod
+    def from_domain_randomizer(domain_randomizer, *, target_cov_factor=1.0, init_cov_factor=1 / 100):
+        """
+        Creates a self-paced domain parameter having the same initial and target mean and target variance given by the domain randomizer's variance (scaled by `target_cov_factor`). The initial variance is also given by the domain randomizer's variance (scaled by `init_cov_factor`).
+
+        :param domain_randomizer: randomizer to grab the data from
+        :param target_cov_factor: scaling of the randomizer's variance to get the target variance; defaults to `1`
+        :param init_cov_factor: scaling of the randomizer's variance to get the init variance; defaults to `1/100`
+        :return: the self-paced domain parameter
+        """
+        (
+            name,
+            target_mean,
+            target_cov_flat,
+            init_mean,
+            init_cov_flat,
+        ) = (
+            [],
+            [],
+            [],
+            [],
+            [],
+        )
+        for domain_param in domain_randomizer.domain_params:
+            if not isinstance(domain_param, NormalDomainParam):
+                raise pyrado.TypeErr(
+                    given=domain_param,
+                    expected_type=NormalDomainParam,
+                    msg="each domain_param must be a NormalDomainParam",
+                )
+            name.append(domain_param.name)
+            target_mean.append(domain_param.mean)
+            target_cov_flat.append(target_cov_factor * domain_param.std**2)
+            init_mean.append(domain_param.mean)
+            init_cov_flat.append(init_cov_factor * domain_param.std**2)
+        return SelfPacedDomainParam(
+            name=name,
+            target_mean=to.tensor(target_mean),
+            target_cov_flat=to.tensor(target_cov_flat),
+            init_mean=to.tensor(init_mean),
+            init_cov_flat=to.tensor(init_cov_flat),
+            clip_lo=-pyrado.inf,
+            clip_up=+pyrado.inf,
+        )
+
     @property
     def target_distr(self) -> MultivariateNormal:
         """Get the target distribution."""
@@ -413,6 +458,18 @@ def context_cov(self) -> to.Tensor:
         """Get the current covariance matrix."""
         return self.context_cov_chol @ self.context_cov_chol.T
 
+    def info(self) -> dict:
+        """"""
+        return {
+            "name": self.name,
+            "target_mean": self.target_mean,
+            "target_cov_chol": self.target_cov_chol,
+            "init_mean": self.init_mean,
+            "init_cov_chol": self.init_cov_chol,
+            "clip_lo": self.clip_lo,
+            "clip_up": self.clip_up,
+        }
+
     def adapt(self, domain_distr_param: str, domain_distr_param_value: to.Tensor):
         """
         Update this domain parameter.

Pyrado/pyrado/environments/rcspysim/planar_insert.py

@@ -75,7 +75,6 @@ class PlanarInsertSim(RcsSim, Serializable):
     """
 
     def __init__(self, task_args: dict, collision_config: dict = None, max_dist_force: float = None, **kwargs):
-
         """
         Constructor
 

Pyrado/pyrado/plotting/heatmap.py

@@ -34,7 +34,6 @@
 from matplotlib import colors
 from matplotlib import pyplot as plt
 from matplotlib import ticker
-from pandas.core.indexes.numeric import NumericIndex
 
 import pyrado
 from pyrado.plotting.utils import draw_sep_cbar
@@ -191,10 +190,6 @@ def draw_heatmap(
     :return: handles to the heat map and the color bar figures (`None` if not existent)
     """
     if isinstance(data, pd.DataFrame):
-        if not isinstance(data.index, NumericIndex):
-            raise pyrado.TypeErr(given=data.index, expected_type=NumericIndex)
-        if not isinstance(data.columns, NumericIndex):
-            raise pyrado.TypeErr(given=data.columns, expected_type=NumericIndex)
         # Extract the data
         x = data.columns
         y = data.index

Pyrado/pyrado/policies/feed_forward/poly_time.py

@@ -251,9 +251,7 @@ class TraceablePolySplineTimePolicy(nn.Module):
     t_init: float
     t_curr: float
     overtime_behavior: str
-    act_space_shape: Tuple[
-        int,
-    ]
+    act_space_shape: Tuple[int,]
     act_space_flat_dim: int
 
     def __init__(

Pyrado/pyrado/sampling/parallel_evaluation.py

@@ -106,7 +106,9 @@ def eval_domain_params(
     # Run with progress bar
     with tqdm(leave=False, file=sys.stdout, unit="rollouts", desc="Sampling") as pb:
         # we set the sub seed to zero since every run will have its personal sub sub seed
-        return pool.run_map(functools.partial(_ps_run_one_domain_param, eval=True, seed=seed, sub_seed=0), params, pb)
+        return pool.run_map(
+            functools.partial(_ps_run_one_domain_param, eval=True, seed=seed, sub_seed=0), list(enumerate(params)), pb
+        )
 
 
 def eval_nominal_domain(
@@ -128,7 +130,7 @@ def eval_nominal_domain(
 
     # Run with progress bar
     with tqdm(leave=False, file=sys.stdout, unit="rollouts", desc="Sampling") as pb:
-        return pool.run_map(functools.partial(_ps_run_one_init_state, eval=True), init_states, pb)
+        return pool.run_map(functools.partial(_ps_run_one_init_state, eval=True), list(enumerate(init_states)), pb)
 
 
 def eval_randomized_domain(
@@ -152,7 +154,7 @@ def eval_randomized_domain(
 
     # Run with progress bar
     with tqdm(leave=False, file=sys.stdout, unit="rollouts", desc="Sampling") as pb:
-        return pool.run_map(functools.partial(_ps_run_one_init_state, eval=True), init_states, pb)
+        return pool.run_map(functools.partial(_ps_run_one_init_state, eval=True), list(enumerate(init_states)), pb)
 
 
 def eval_domain_params_with_segmentwise_reset(

Pyrado/pyrado/sampling/parallel_rollout_sampler.py

@@ -276,7 +276,6 @@ def sample(
             disable=(not self.show_progress_bar),
             unit="steps" if self.min_steps is not None else "rollouts",
         ) as pb:
-
             if self.min_steps is None:
                 if init_states is None and domain_params is None:
                     # Simply run min_rollouts times

Pyrado/pyrado/sampling/sequences.py

@@ -99,6 +99,7 @@ def sequence_add_init(x_init, iter, dtype=int):
     :param dtype: data type to cast to (either int of float)
     :return: element at the given iteration and array of the whole sequence
     """
+
     # non-exponential growth
     def iter_function(x_seq, i, x_init):
         return x_seq[0, :] * (i + 1)
@@ -115,6 +116,7 @@ def sequence_rec_double(x_init, iter, dtype=int):
     :param dtype: data type to cast to (either int of float)
     :return: element at the given iteration and array of the whole sequence
     """
+
     # exponential growth
     def iter_function(x_seq, i, x_init):
         return x_seq[i - 1, :] * 2.0
@@ -131,6 +133,7 @@ def sequence_sqrt(x_init, iter, dtype=int):
     :param dtype: data type to cast to (either int of float)
     :return: element at the given iteration and array of the whole sequence
     """
+
     # non-exponential growth
     def iter_function(x_seq, i, x_init):
         return x_seq[0, :] * np.sqrt(i + 1)  # i+1 because sqrt(1) = 1
@@ -147,6 +150,7 @@ def sequence_rec_sqrt(x_init, iter, dtype=int):
     :param dtype: data type to cast to (either int of float)
     :return: element at the given iteration and array of the whole sequence
     """
+
     # exponential growth
     def iter_function(x_seq, i, x_init):
         return x_seq[i - 1, :] * np.sqrt(i + 1)  # i+1 because sqrt(1) = 1
@@ -163,6 +167,7 @@ def sequence_nlog2(x_init, iter, dtype=int):
     :param dtype: data type to cast to (either int of float)
     :return: element at the given iteration and array of the whole sequence
     """
+
     # non-exponential growth
     def iter_function(x_seq, i, x_init):
         return x_seq[0, :] * i * np.log2(i + 2)  # i+2 because log2(1) = 0 and log2(2) = 1

Pyrado/scripts/evaluation/paper_specific/sob_illustrative_example.py

@@ -139,7 +139,6 @@ def check_E_n_Jhat(th_n_opt, n):
     b_Jhat_n_hist = np.empty((num_samples, num_iter))
 
     for s in range(num_samples):
-
         for n in range(1, num_iter + 1):
             n_V = np.random.binomial(n, psi)  # perform n Bernoulli trials
             n_M = n - n_V

Pyrado/scripts/hyperparam_optimization/hopt_qq-su_ppo2.py

@@ -138,7 +138,6 @@ def train_and_eval(trial: optuna.Trial, study_dir: str, seed: int):
 
 
 if __name__ == "__main__":
-
     # Parse command line arguments
     args = get_argparser().parse_args()
 

setup_deps.py

@@ -111,10 +111,11 @@
 resources_dir = osp.join(dependency_dir, "resources")
 
 # Global cmake prefix path
-cmake_prefix_path = [
+cmake_prefix_path = []
+conda_prefix = os.getenv("CONDA_PREFIX")
+if conda_prefix:
     # Anaconda env root directory
-    os.environ["CONDA_PREFIX"]
-]
+    cmake_prefix_path.append(conda_prefix)
 
 # Required packages
 required_packages = [
@@ -314,7 +315,6 @@ def members(ml):
             with tarfile.open(tf.name) as tar:
 
                 def is_within_directory(directory, target):
-
                     abs_directory = os.path.abspath(directory)
                     abs_target = os.path.abspath(target)
 
@@ -323,7 +323,6 @@ def is_within_directory(directory, target):
                     return prefix == abs_directory
 
                 def safe_extract(tar, path=".", members=None, *, numeric_owner=False):
-
                     for member in tar.getmembers():
                         member_path = os.path.join(path, member.name)
                         if not is_within_directory(path, member_path):