0.6.10

Author: winedarksea

TODO.md

@@ -11,10 +11,12 @@
 * Series will largely be consistent in period, or at least up-sampled to regular intervals
 * The most recent data will generally be the most important
 * Forecasts are desired for the future immediately following the most recent data.
+* trimmed_mean to AverageValueNaive
 
-# 0.6.9 🇺🇦 🇺🇦 🇺🇦
-* expanded regressor options for MultivariateRegression, NeuralForecast (currently only available directly, not from AutoTS class)
-* matse bug fix on all 0 history
+# 0.6.10 🇺🇦 🇺🇦 🇺🇦
+* assorted minor bug fixes
+* bug in mosaic model selection fixed
+* added crosshair_lite mosaic
 
 ### Unstable Upstream Pacakges (those that are frequently broken by maintainers)
 * Pytorch-Forecasting

autots/__init__.py

@@ -26,7 +26,7 @@
 from autots.models.cassandra import Cassandra
 
 
-__version__ = '0.6.9'
+__version__ = '0.6.10'
 
 TransformTS = GeneralTransformer
 

autots/evaluator/auto_model.py

@@ -1549,14 +1549,12 @@ def virtual_memory():
             template_result.model_count += 1
             if verbose > 0:
                 if validation_round >= 1:
-                    base_print = (
-                        "Model Number: {} of {} with model {} for Validation {}{}".format(
-                            str(template_result.model_count),
-                            template.shape[0],
-                            model_str,
-                            str(validation_round),
-                            str(additional_msg),
-                        )
+                    base_print = "Model Number: {} of {} with model {} for Validation {}{}".format(
+                        str(template_result.model_count),
+                        template.shape[0],
+                        model_str,
+                        str(validation_round),
+                        str(additional_msg),
                     )
                 else:
                     base_print = (

autots/evaluator/auto_ts.py

@@ -505,16 +505,26 @@ def get_new_params(method='random'):
                 'smape_weighting': random.choices([0, 1, 5, 10], [0.3, 0.2, 0.3, 0.1])[
                     0
                 ],
-                'mae_weighting': random.choices([0, 1, 3, 5, 0.1], [0.1, 0.3, 0.3, 0.3, 0.1])[0],
-                'rmse_weighting': random.choices([0, 1, 3, 5, 0.1], [0.1, 0.3, 0.3, 0.3, 0.1])[0],
+                'mae_weighting': random.choices(
+                    [0, 1, 3, 5, 0.1], [0.1, 0.3, 0.3, 0.3, 0.1]
+                )[0],
+                'rmse_weighting': random.choices(
+                    [0, 1, 3, 5, 0.1], [0.1, 0.3, 0.3, 0.3, 0.1]
+                )[0],
                 'made_weighting': random.choices([0, 1, 3, 5], [0.7, 0.3, 0.1, 0.05])[
                     0
                 ],
-                'mage_weighting': random.choices([0, 1, 3, 5, 0.01], [0.8, 0.1, 0.1, 0.0, 0.2])[0],
+                'mage_weighting': random.choices(
+                    [0, 1, 3, 5, 0.01], [0.8, 0.1, 0.1, 0.0, 0.2]
+                )[0],
                 'mle_weighting': random.choices([0, 1, 3, 5], [0.8, 0.1, 0.1, 0.0])[0],
                 'imle_weighting': random.choices([0, 1, 3, 5], [0.8, 0.1, 0.1, 0.0])[0],
-                'spl_weighting': random.choices([0, 1, 3, 5, 0.1], [0.1, 0.3, 0.3, 0.3, 0.1])[0],
-                'oda_weighting': random.choices([0, 1, 3, 5, 0.1], [0.8, 0.1, 0.1, 0.0, 0.1])[0],
+                'spl_weighting': random.choices(
+                    [0, 1, 3, 5, 0.1], [0.1, 0.3, 0.3, 0.3, 0.1]
+                )[0],
+                'oda_weighting': random.choices(
+                    [0, 1, 3, 5, 0.1], [0.8, 0.1, 0.1, 0.0, 0.1]
+                )[0],
                 'mqae_weighting': random.choices([0, 1, 3, 5], [0.4, 0.2, 0.1, 0.0])[0],
                 'dwae_weighting': random.choices([0, 1, 3, 5], [0.8, 0.1, 0.1, 0.0])[0],
                 'maxe_weighting': random.choices([0, 1, 3, 5], [0.8, 0.1, 0.1, 0.0])[0],
@@ -1544,7 +1554,9 @@ def validation_agg(self):
         )
         return self
 
-    def _return_best_model(self, metric_weighting=None, allow_horizontal=True, n=1, template_cols=None):
+    def _return_best_model(
+        self, metric_weighting=None, allow_horizontal=True, n=1, template_cols=None
+    ):
         """Sets best model based on validation results.
 
         Args:
@@ -1614,7 +1626,9 @@ def _set_best_model(self, metric_weighting=None, allow_horizontal=True, n=1):
         self.parse_best_model()
         return self
 
-    def _best_non_horizontal(self, metric_weighting=None, series=None, n=1, template_cols=None):
+    def _best_non_horizontal(
+        self, metric_weighting=None, series=None, n=1, template_cols=None
+    ):
         if self.validation_results is None:
             if not self.initial_results.model_results.empty:
                 self = self.validation_agg()
@@ -2177,10 +2191,14 @@ def export_template(
                 extra_mods = []
                 if min_metrics is not None:
                     for metric in min_metrics:
-                        extra_mods.append(export_template.nsmallest(1, columns=metric).copy())
+                        extra_mods.append(
+                            export_template.nsmallest(1, columns=metric).copy()
+                        )
                 if max_metrics is not None:
                     for metric in max_metrics:
-                        extra_mods.append(export_template.nlargest(1, columns=metric).copy())
+                        extra_mods.append(
+                            export_template.nlargest(1, columns=metric).copy()
+                        )
                 if str(max_per_model_class).isdigit():
                     export_template = (
                         export_template.sort_values('Score', ascending=True)
@@ -2191,7 +2209,9 @@ def export_template(
                 export_template = export_template.nsmallest(n, columns=['Score'])
                 if extra_mods:
                     extra_mods = pd.concat(extra_mods)
-                    export_template = pd.concat([export_template, extra_mods]).drop_duplicates()
+                    export_template = pd.concat(
+                        [export_template, extra_mods]
+                    ).drop_duplicates()
                 if self.best_model_id not in export_template['ID']:
                     export_template = pd.concat(
                         [
@@ -2469,12 +2489,22 @@ def _generate_mosaic_template(
         )
         runtime_weighting = self.metric_weighting.get("runtime_weighting", 0)
         if runtime_weighting != 0:
-            local_results = initial_results.model_results.copy().groupby("ID")["TotalRuntimeSeconds"].mean()
-            runtimes = local_results.loc[initial_results.full_mae_ids].to_numpy()[:, np.newaxis, np.newaxis]
+            local_results = (
+                initial_results.model_results.copy()
+                .groupby("ID")["TotalRuntimeSeconds"]
+                .mean()
+            )
+            runtimes = local_results.loc[initial_results.full_mae_ids].to_numpy()[
+                :, np.newaxis, np.newaxis
+            ]
             # not fully confident in this scaler, trying to put runtime loosely in reference to mae scale
-            mae_min = initial_results.per_series_mae.loc[initial_results.model_results.set_index("ID")['mae'].idxmin()]
+            mae_min = initial_results.per_series_mae.loc[
+                initial_results.model_results.set_index("ID")['mae'].idxmin()
+            ]
             mae_min = np.min(mae_min[mae_min > 0])
-            basic_scaler = initial_results.model_results['TotalRuntimeSeconds'].mean() / mae_min
+            basic_scaler = (
+                initial_results.model_results['TotalRuntimeSeconds'].mean() / mae_min
+            )
             # making runtime weighting even smaller because generally want this to be a very small component
             weight_per_value + (runtimes / basic_scaler) * (runtime_weighting / 10)
 
@@ -2496,7 +2526,9 @@ def _generate_mosaic_template(
                 # process for crosshair
                 crs_hr = mosaic_config.get("crosshair")
                 if crs_hr:
-                    full_mae_err = [generate_crosshair_score(x, method=crs_hr) for x in errs]
+                    full_mae_err = [
+                        generate_crosshair_score(x, method=crs_hr) for x in errs
+                    ]
                 else:
                     full_mae_err = errs
                 # refine to n_models if necessary

autots/models/ensemble.py

@@ -1578,12 +1578,12 @@ def generate_crosshair_score(error_matrix, method=None):
         arr_size = error_matrix.size
         base_weight = 0.001 / arr_size
         sum_error = np.sum(error_matrix) * base_weight
-    
+
         cross_base = error_matrix * (base_weight * 50)
         row_sums = cross_base.sum(axis=1)
         col_sums = cross_base.sum(axis=0)
         outer_sum = np.add.outer(row_sums, col_sums)
-    
+
         return error_matrix + sum_error + outer_sum
 
 

autots/models/neural_forecast.py

@@ -72,7 +72,13 @@ def __init__(
         self.df_train = None
         self.static_regressor = None
 
-    def fit(self, df, future_regressor=None, static_regressor=None, regressor_per_series=None):
+    def fit(
+        self,
+        df,
+        future_regressor=None,
+        static_regressor=None,
+        regressor_per_series=None,
+    ):
         """Train algorithm given data supplied.
 
         Args:
@@ -242,7 +248,9 @@ def fit(self, df, future_regressor=None, static_regressor=None, regressor_per_se
                     local_copy = local_copy.reset_index()
                     local_copy['unique_id'] = str(key)
                     full_df.append(local_copy)
-                silly_format = silly_format.merge(pd.concat(full_df), on=['unique_id', 'ds'], how='left').fillna(0)
+                silly_format = silly_format.merge(
+                    pd.concat(full_df), on=['unique_id', 'ds'], how='left'
+                ).fillna(0)
         self.nf = NeuralForecast(models=models, freq=freq)
         if self.static_regressor is None:
             self.nf.fit(df=silly_format)
@@ -256,7 +264,11 @@ def fit(self, df, future_regressor=None, static_regressor=None, regressor_per_se
         return self
 
     def predict(
-        self, forecast_length=None, future_regressor=None, just_point_forecast=False, regressor_per_series=None
+        self,
+        forecast_length=None,
+        future_regressor=None,
+        just_point_forecast=False,
+        regressor_per_series=None,
     ):
         predictStartTime = datetime.datetime.now()
         if self.regression_type in ['User', 'user', True]:
@@ -279,7 +291,9 @@ def predict(
                     local_copy = local_copy.reset_index()
                     local_copy['unique_id'] = str(key)
                     full_df.append(local_copy)
-                futr_df = futr_df.merge(pd.concat(full_df), on=['unique_id', 'ds'], how='left').fillna(0)
+                futr_df = futr_df.merge(
+                    pd.concat(full_df), on=['unique_id', 'ds'], how='left'
+                ).fillna(0)
             self.futr_df = futr_df
             long_forecast = self.nf.predict(futr_df=futr_df)
         else:
@@ -378,7 +392,9 @@ def get_new_params(self, method: str = 'random'):
         )[0]
         point_quantile = None
         if loss == "MQLoss":
-            point_quantile = random.choices([None, 0.35, 0.45, 0.55, 0.65, 0.7], [0.5, 0.1, 0.1, 0.1, 0.1, 0.1])[0]
+            point_quantile = random.choices(
+                [None, 0.35, 0.45, 0.55, 0.65, 0.7], [0.5, 0.1, 0.1, 0.1, 0.1, 0.1]
+            )[0]
         if models == "TFT":
             model_args = {
                 "n_head": random.choice([2, 4]),

autots/models/sklearn.py

@@ -254,7 +254,9 @@ def rolling_x_regressor_regressor(
         X = pd.concat([X, future_regressor], axis=1)
     if regressor_per_series is not None:
         # this is actually wrong, merging on an index value that is off by one
-        X = X.merge(regressor_per_series, left_index=True, right_index=True, how='left').bfill()
+        X = X.merge(
+            regressor_per_series, left_index=True, right_index=True, how='left'
+        ).bfill()
     if static_regressor is not None:
         X['series_id'] = df.columns[0]
         X = X.merge(static_regressor, left_on="series_id", right_index=True, how='left')
@@ -1287,7 +1289,9 @@ def generate_regressor_params(
             param_dict = {
                 'C': random.choices([1.0, 0.5, 2.0, 0.25], [0.6, 0.1, 0.1, 0.1])[0],
                 'tol': random.choices([1e-4, 1e-3, 1e-5], [0.6, 0.1, 0.1])[0],
-                "loss": random.choice(['epsilon_insensitive', 'squared_epsilon_insensitive']),
+                "loss": random.choice(
+                    ['epsilon_insensitive', 'squared_epsilon_insensitive']
+                ),
                 "max_iter": random.choice([500, 1000]),
             }
         else:
@@ -3421,7 +3425,9 @@ def get_new_params(self, method: str = 'random'):
             regression_choice = random.choices([None, 'User'], [0.7, 0.3])[0]
         coint_lag = 1
         if "deep" in method:
-            coint_choice = random.choices([None, "BTCD", "Johansen"], [0.8, 0.1, 0.1])[0]
+            coint_choice = random.choices([None, "BTCD", "Johansen"], [0.8, 0.1, 0.1])[
+                0
+            ]
         else:
             coint_choice = None
         if coint_choice is not None:

autots/tools/percentile.py

@@ -111,8 +111,11 @@ def nan_quantile(arr, q, method="linear", axis=0, errors="raise"):
     """
     return nan_percentile(arr, q * 100, method=method, axis=axis, errors=errors)
 
+
 def trimmed_mean(data, percent, axis=0):
     limit = int(np.ceil(percent * data.shape[axis]))
     sorted_data = np.sort(data, axis=axis)
-    trimmed = sorted_data.take(indices=range(limit, data.shape[axis] - limit), axis=axis)
+    trimmed = sorted_data.take(
+        indices=range(limit, data.shape[axis] - limit), axis=axis
+    )
     return np.mean(trimmed, axis=axis)