Improve RUL prediction with time-series features

batteryswap_example/train.py

@@ -8,7 +8,7 @@ import pathlib
 import os
 
 
-from sklearn.dummy import DummyRegressor
+from sklearn.ensemble import ExtraTreesRegressor
 import pandas as pd
 import numpy
 import numpy as np
@@ -80,18 +80,127 @@ class DummyRULModel(RULModel):
         self.use_total_elapsed_days = True
 
     def _compute_features(self, unit_df: pd.DataFrame) -> np.ndarray:
-        unit_df = unit_df.sort_values(self.time_col)
+        unit_df = unit_df.sort_index(level=self.time_col).copy()
+        if len(unit_df) == 0:
+            raise ValueError("Received empty battery time series")
 
         all_stats = {}
-        # FIXME: actually compute some features 
+
+        # Convert timestamps to elapsed days
+        times = pd.to_datetime(
+            unit_df.index.get_level_values(self.time_col)
+            )
+        elapsed_days = (
+            times - times[0]
+            ).total_seconds().to_numpy() / 86400.0
+        
+
+        # General history features
+        all_stats["n_obs"] = float(len(unit_df))
+        all_stats["history_days"] = (
+            float(elapsed_days[-1]) if len(elapsed_days) > 1 else 0.0
+            )
+
+        # Features for voltage and temperature
+        for col in self.value_cols:
+            values = pd.to_numeric(
+                unit_df[col],
+                errors="coerce"
+                )
+
+            valid = values.notna()
+
+            if valid.sum() == 0:
+                all_stats[f"{col}_latest"] = 0.0
+                all_stats[f"{col}_mean"] = 0.0
+                all_stats[f"{col}_std"] = 0.0
+                all_stats[f"{col}_min"] = 0.0
+                all_stats[f"{col}_max"] = 0.0
+                all_stats[f"{col}_change"] = 0.0
+                all_stats[f"{col}_slope"] = 0.0
+                continue
+
+            x = values[valid].to_numpy(dtype=float)
+            t = elapsed_days[valid.to_numpy()]
+
+            all_stats[f"{col}_latest"] = float(x[-1])
+            all_stats[f"{col}_mean"] = float(np.mean(x))
+            all_stats[f"{col}_std"] = float(np.std(x))
+            all_stats[f"{col}_min"] = float(np.min(x))
+            all_stats[f"{col}_max"] = float(np.max(x))
+            all_stats[f"{col}_change"] = float(x[-1] - x[0])
+            
+            # Recent-window features
+            for window_days in (7, 14, 30):
+                cutoff = t[-1] - window_days
+                recent_mask = t >= cutoff
+
+                recent_x = x[recent_mask]
+                recent_t = t[recent_mask]
+
+                prefix = f"{col}_{window_days}d"
+
+                if len(recent_x) > 0:
+                    all_stats[f"{prefix}_mean"] = float(np.mean(recent_x))
+                    all_stats[f"{prefix}_std"] = float(np.std(recent_x))
+                    all_stats[f"{prefix}_min"] = float(np.min(recent_x))
+                    all_stats[f"{prefix}_max"] = float(np.max(recent_x))
+                    all_stats[f"{prefix}_change"] = float(
+                        recent_x[-1] - recent_x[0]
+                        )
+
+                    if len(recent_x) >= 2 and np.ptp(recent_t) > 0:
+                        recent_slope = np.polyfit(
+                            recent_t,
+                            recent_x,
+                            1
+                            )[0]
+                    else:
+                        recent_slope = 0.0
+
+                    all_stats[f"{prefix}_slope"] = float(recent_slope)
+                else:
+                    all_stats[f"{prefix}_mean"] = 0.0
+                    all_stats[f"{prefix}_std"] = 0.0
+                    all_stats[f"{prefix}_min"] = 0.0
+                    all_stats[f"{prefix}_max"] = 0.0
+                    all_stats[f"{prefix}_change"] = 0.0
+                    all_stats[f"{prefix}_slope"] = 0.0
+            
+            # Recent level compared with overall level
+            if len(x) > 0:
+                recent_7_mask = t >= (t[-1] - 7)
+                recent_7 = x[recent_7_mask]
+
+                if len(recent_7) > 0:
+                    all_stats[f"{col}_recent7_vs_mean"] = float(
+                        np.mean(recent_7) - np.mean(x)
+                        )
+                else:
+                    all_stats[f"{col}_recent7_vs_mean"] = 0.0
+                    
+            # Trend per day
+            if len(x) >= 2 and np.ptp(t) > 0:
+                slope = np.polyfit(t, x, 1)[0]
+            else:
+                slope = 0.0
+
+            all_stats[f"{col}_slope"] = float(slope)
 
         feature_names = sorted(all_stats.keys())
-        self._feature_names_ = feature_names  # stored for inspection/debugging
-        return np.array([all_stats[k] for k in feature_names], dtype=float)
+        self._feature_names_ = feature_names
+
+        return np.array(
+            [all_stats[k] for k in feature_names],
+            dtype=float,
+            )
 
     def _build_feature_matrix(self, timeseries: pd.DataFrame) -> tuple[np.ndarray, list]:
         rows, ids = [], []
-        for unit_id, unit_df in timeseries.groupby(self.group_col):
+        for unit_id, unit_df in timeseries.groupby(
+            self.group_col,
+            observed=True
+            ):
             if len(unit_df) < 2:
                 continue
             rows.append(self._compute_features(unit_df))
@@ -103,13 +212,21 @@ class DummyRULModel(RULModel):
         y = np.array([rul[unit_id] for unit_id in ids])
 
         # FIXME: actually use an estimator that learns
-        self.model = DummyRegressor(strategy='median')
+        self.model = ExtraTreesRegressor(
+            n_estimators=300,
+            min_samples_leaf=2,
+            random_state=42,
+            n_jobs=-1,
+            )
         self.model.fit(X, y)
         return self
 
     def predict(self, timeseries: pd.DataFrame) -> pd.DataFrame:
         rows, ids = [], []
-        for unit_id, unit_df in timeseries.groupby(self.group_col):
+        for unit_id, unit_df in timeseries.groupby(
+            self.group_col,
+            observed=True
+            ):
             rows.append(self._compute_features(unit_df))
             ids.append(unit_id)