Rename rval to return_value or run_value

autosklearn/automl.py

@@ -2138,10 +2138,10 @@ def has_key(rv, key):
             return rv.additional_info and key in rv.additional_info
 
         table_dict = {}
-        for rkey, rval in self.runhistory_.data.items():
-            if has_key(rval, "num_run"):
-                model_id = rval.additional_info["num_run"]
-                table_dict[model_id] = {"model_id": model_id, "cost": rval.cost}
+        for run_key, run_val in self.runhistory_.data.items():
+            if has_key(run_val, "num_run"):
+                model_id = run_val.additional_info["num_run"]
+                table_dict[model_id] = {"model_id": model_id, "cost": run_val.cost}
 
         # Checking if the dictionary is empty
         if not table_dict:

autosklearn/estimators.py

@@ -1041,31 +1041,31 @@ def additional_info_has_key(rv, key):
             return rv.additional_info and key in rv.additional_info
 
         model_runs = {}
-        for rkey, rval in self.automl_.runhistory_.data.items():
-            if not additional_info_has_key(rval, "num_run"):
+        for run_key, run_val in self.automl_.runhistory_.data.items():
+            if not additional_info_has_key(run_val, "num_run"):
                 continue
             else:
-                model_key = rval.additional_info["num_run"]
+                model_key = run_val.additional_info["num_run"]
                 model_run = {
-                    "model_id": rval.additional_info["num_run"],
-                    "seed": rkey.seed,
-                    "budget": rkey.budget,
-                    "duration": rval.time,
-                    "config_id": rkey.config_id,
-                    "start_time": rval.starttime,
-                    "end_time": rval.endtime,
-                    "status": str(rval.status),
-                    "train_loss": rval.additional_info["train_loss"]
-                    if additional_info_has_key(rval, "train_loss")
+                    "model_id": run_val.additional_info["num_run"],
+                    "seed": run_key.seed,
+                    "budget": run_key.budget,
+                    "duration": run_val.time,
+                    "config_id": run_key.config_id,
+                    "start_time": run_val.starttime,
+                    "end_time": run_val.endtime,
+                    "status": str(run_val.status),
+                    "train_loss": run_val.additional_info["train_loss"]
+                    if additional_info_has_key(run_val, "train_loss")
                     else None,
-                    "config_origin": rval.additional_info["configuration_origin"]
-                    if additional_info_has_key(rval, "configuration_origin")
+                    "config_origin": run_val.additional_info["configuration_origin"]
+                    if additional_info_has_key(run_val, "configuration_origin")
                     else None,
                 }
                 if num_metrics == 1:
-                    model_run["cost"] = rval.cost
+                    model_run["cost"] = run_val.cost
                 else:
-                    for cost_idx, cost in enumerate(rval.cost):
+                    for cost_idx, cost in enumerate(run_val.cost):
                         model_run[f"cost_{cost_idx}"] = cost
                 model_runs[model_key] = model_run
 

autosklearn/evaluation/__init__.py

@@ -71,7 +71,7 @@ def fit_predict_try_except_decorator(
         #     File "auto-sklearn/autosklearn/evaluation/train_evaluator.py", line 616, in fit_predict_and_loss,  # noqa E501
         #     status=status
         #     File "auto-sklearn/autosklearn/evaluation/abstract_evaluator.py", line 320, in finish_up  # noqa E501
-        #     self.queue.put(rval_dict)
+        #     self.queue.put(return_value_dict)
         #     File "miniconda/3-4.5.4/envs/autosklearn/lib/python3.7/multiprocessing/queues.py", line 87, in put  # noqa E501
         #     self._start_thread()
         #     File "miniconda/3-4.5.4/envs/autosklearn/lib/python3.7/multiprocessing/queues.py", line 170, in _start_thread  # noqa E501

autosklearn/evaluation/abstract_evaluator.py

@@ -429,15 +429,15 @@ def finish_up(
         if test_loss is not None:
             additional_run_info["test_loss"] = test_loss
 
-        rval_dict = {
+        return_value_dict = {
             "loss": loss,
             "additional_run_info": additional_run_info,
             "status": status,
         }
         if final_call:
-            rval_dict["final_queue_element"] = True
+            return_value_dict["final_queue_element"] = True
 
-        self.queue.put(rval_dict)
+        self.queue.put(return_value_dict)
         return self.duration, loss_, self.seed, additional_run_info_
 
     def calculate_auxiliary_losses(

autosklearn/evaluation/util.py

@@ -12,19 +12,19 @@ def read_queue(
     stack = []
     while True:
         try:
-            rval = queue_.get(timeout=1)
+            return_value = queue_.get(timeout=1)
         except queue.Empty:
             break
 
         # Check if there is a special placeholder value which tells us that
         # we don't have to wait until the queue times out in order to
         # retrieve the final value!
-        if "final_queue_element" in rval:
-            del rval["final_queue_element"]
+        if "final_queue_element" in return_value:
+            del return_value["final_queue_element"]
             do_break = True
         else:
             do_break = False
-        stack.append(rval)
+        stack.append(return_value)
         if do_break:
             break
 

autosklearn/experimental/selector.py

@@ -297,17 +297,17 @@ def _predict(
             wins = wins / np.sum(wins)
             predictions[X.index[x_idx]] = wins
 
-        rval = {
+        return_value = {
             task_id: {
                 strategy: predictions[task_id][strategy_idx]
                 for strategy_idx, strategy in enumerate(self.strategies_)
             }
             for task_id in X.index
         }
-        rval = pd.DataFrame(rval).transpose().astype(float)
-        rval = rval[self.strategies_]
-        rval = rval.fillna(0.0)
-        return rval
+        return_value = pd.DataFrame(return_value).transpose().astype(float)
+        return_value = return_value[self.strategies_]
+        return_value = return_value.fillna(0.0)
+        return return_value
 
     def fit_pairwise_model(self, X, y, weights, rng, configuration):
         raise NotImplementedError()
@@ -346,14 +346,14 @@ def fit(
     ) -> None:
         self.X_ = X
         self.strategies_ = y.columns
-        self.rval_ = np.array(
+        self.return_value_ = np.array(
             [
                 (len(self.strategies_) - self.default_strategies.index(strategy) - 1)
                 / (len(self.strategies_) - 1)
                 for strategy in self.strategies_
             ]
         )
-        self.rval_ = self.rval_ / np.sum(self.rval_)
+        self.return_value_ = self.return_value_ / np.sum(self.return_value_)
         self.selector.fit(X, y, minima, maxima)
 
     def _predict(
@@ -377,7 +377,7 @@ def _predict(
                 prediction.loc[task_id] = pd.Series(
                     {
                         strategy: value
-                        for strategy, value in zip(self.strategies_, self.rval_)
+                        for strategy, value in zip(self.strategies_, self.return_value_)
                     }
                 )
 

autosklearn/metalearning/metalearning/kNearestDatasets/kND.py

@@ -122,17 +122,17 @@ def kNearestDatasets(self, x, k=1, return_distance=False):
 
         assert k == neighbor_indices.shape[1]
 
-        rval = [
+        return_value = [
             self.metafeatures.index[i]
             # Neighbor indices is 2d, each row is the indices for one
             # dataset in x.
             for i in neighbor_indices[0]
         ]
 
         if return_distance is False:
-            return rval
+            return return_value
         else:
-            return rval, distances[0]
+            return return_value, distances[0]
 
     def kBestSuggestions(self, x, k=1, exclude_double_configurations=True):
         assert type(x) == pd.Series

autosklearn/pipeline/base.py

@@ -495,15 +495,15 @@ def __repr__(self):
             dataset_properties_string.append("}")
             dataset_properties_string = "".join(dataset_properties_string)
 
-            rval = "%s(%s,\n%s)" % (
+            return_value = "%s(%s,\n%s)" % (
                 class_name,
                 configuration,
                 dataset_properties_string,
             )
         else:
-            rval = "%s(%s)" % (class_name, configuration_string)
+            return_value = "%s(%s)" % (class_name, configuration_string)
 
-        return rval
+        return return_value
 
     def _get_pipeline_steps(self, dataset_properties):
         raise NotImplementedError()

scripts/2015_nips_paper/run/score_ensemble.py

@@ -227,14 +227,14 @@ def evaluate(input_directory, validation_files, test_files, ensemble_size=50):
 
     ensemble_time = time.time() - start
 
-    rval = {
+    return_value = {
         "ensemble_time": ensemble_time,
         "time_function_evaluation": time_function_evaluation,
         "ensemble_error": ensemble_error,
         "ensemble_test_error": ensemble_test_error,
     }
 
-    return rval
+    return return_value
 
 
 if __name__ == "__main__":

test/test_evaluation/test_test_evaluator.py

@@ -80,10 +80,10 @@ def test_datasets(self):
                 )
 
                 evaluator.fit_predict_and_loss()
-                rval = read_queue(evaluator.queue)
-                self.assertEqual(len(rval), 1)
-                self.assertEqual(len(rval[0]), 3)
-                self.assertTrue(np.isfinite(rval[0]["loss"]))
+                return_value = read_queue(evaluator.queue)
+                self.assertEqual(len(return_value), 1)
+                self.assertEqual(len(return_value[0]), 3)
+                self.assertTrue(np.isfinite(return_value[0]["loss"]))
 
 
 class FunctionsTest(unittest.TestCase):
@@ -124,11 +124,11 @@ def test_eval_test(self):
             port=self.port,
             additional_components=dict(),
         )
-        rval = read_queue(self.queue)
-        self.assertEqual(len(rval), 1)
-        self.assertAlmostEqual(rval[0]["loss"], 0.07999999999999996)
-        self.assertEqual(rval[0]["status"], StatusType.SUCCESS)
-        self.assertNotIn("bac_metric", rval[0]["additional_run_info"])
+        return_value = read_queue(self.queue)
+        self.assertEqual(len(return_value), 1)
+        self.assertAlmostEqual(return_value[0]["loss"], 0.07999999999999996)
+        self.assertEqual(return_value[0]["status"], StatusType.SUCCESS)
+        self.assertNotIn("bac_metric", return_value[0]["additional_run_info"])
 
     def test_eval_test_multi_objective(self):
         metrics = {
@@ -151,12 +151,12 @@ def test_eval_test_multi_objective(self):
             port=self.port,
             additional_components=dict(),
         )
-        rval = read_queue(self.queue)
-        self.assertEqual(len(rval), 1)
+        return_value = read_queue(self.queue)
+        self.assertEqual(len(return_value), 1)
         for metric, loss in metrics.items():
-            self.assertAlmostEqual(rval[0]["loss"][metric.name], loss)
-        self.assertEqual(rval[0]["status"], StatusType.SUCCESS)
-        self.assertNotIn("bac_metric", rval[0]["additional_run_info"])
+            self.assertAlmostEqual(return_value[0]["loss"][metric.name], loss)
+        self.assertEqual(return_value[0]["status"], StatusType.SUCCESS)
+        self.assertNotIn("bac_metric", return_value[0]["additional_run_info"])
 
     def test_eval_test_all_loss_functions(self):
         eval_t(
@@ -175,8 +175,8 @@ def test_eval_test_all_loss_functions(self):
             port=self.port,
             additional_components=dict(),
         )
-        rval = read_queue(self.queue)
-        self.assertEqual(len(rval), 1)
+        return_value = read_queue(self.queue)
+        self.assertEqual(len(return_value), 1)
 
         # Note: All metric here should be minimized
         fixture = {
@@ -195,7 +195,7 @@ def test_eval_test_all_loss_functions(self):
             "num_run": -1,
         }
 
-        additional_run_info = rval[0]["additional_run_info"]
+        additional_run_info = return_value[0]["additional_run_info"]
         for key, value in fixture.items():
             self.assertAlmostEqual(additional_run_info[key], fixture[key], msg=key)
         self.assertEqual(
@@ -204,5 +204,5 @@ def test_eval_test_all_loss_functions(self):
             msg=sorted(additional_run_info.items()),
         )
         self.assertIn("duration", additional_run_info)
-        self.assertAlmostEqual(rval[0]["loss"], 0.040000000000000036)
-        self.assertEqual(rval[0]["status"], StatusType.SUCCESS)
+        self.assertAlmostEqual(return_value[0]["loss"], 0.040000000000000036)
+        self.assertEqual(return_value[0]["status"], StatusType.SUCCESS)