Improve planner with 14-day safety buffer

batteryswap_example/planners/best.pickle

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d298671d2c8f3c4374b5f2d75edae3e7eceff08985f857bd406ebc9e3f450df4
-size 6525860
+oid sha256:f8971ab518a017a7ee9be0c377fc31e15fe8f79fc3195f1ac9b336ac4f98d4e2
+size 6525899

batteryswap_example/train.py

@@ -25,40 +25,147 @@ log = structlog.get_logger()
 
 
 class OrderedPlanner(Planner):
-    def __init__(self, rul_estimator):
+    def __init__(
+        self,
+        rul_estimator,
+        safety_days=14,
+        max_swaps_per_day=6,
+    ):
         self.rul_estimator = rul_estimator
+        self.safety_days = safety_days
+        self.max_swaps_per_day = max_swaps_per_day
 
     def plan(self, battery_data, locations, travel_costs, settings):
 
-        # Remaining Useful Life estimation
-        # FIXME: consider balance of over/under-estimation
-        percentile = 'p50'
+       
+        # Predict Remaining Useful Life
+        
+        percentile = "p50"
+
         rul = self.rul_estimator.predict(battery_data)
         rul_days = rul[percentile]
-        # convert to a date
-        start_time = battery_data.reset_index()['end_time'].max().normalize()
-        predict_eol = start_time + pandas.to_timedelta(rul_days, unit='D')
-
-        loc = locations.copy().set_index('battery')
-        loc['eol_time'] = predict_eol
-        order = loc.sort_values('eol_time', ascending=True)
-
-        # Planner
-        # Stupid heuristic: Do one swap per day
-        # FIXME: take travel distances into account
-        # FIXME: take co-location into account
-        # FIXME: take daily and weekly limits into account
-        days = start_time + pandas.to_timedelta(numpy.arange(len(order)), unit='D')
+
+        start_time = (
+            battery_data
+            .reset_index()["end_time"]
+            .max()
+            .normalize()
+        )
+
+        predicted_eol = (
+            start_time
+            + pandas.to_timedelta(rul_days, unit="D")
+        )
+
+   
+        # Create location table
+      
+        loc = locations.copy().set_index("battery")
+
+        loc["predicted_eol"] = predicted_eol
+
+        # Replace BEFORE predicted EOL.
+        #
+        # Late swaps are much more expensive than early swaps,
+        # so give ourselves a safety margin.
+        loc["target_day"] = (
+            loc["predicted_eol"]
+            - pandas.to_timedelta(self.safety_days, unit="D")
+        )
+        loc["target_day"] = loc["target_day"].dt.normalize()
+
+        # Never schedule before the planning period starts
+        loc["target_day"] = loc["target_day"].clip(lower=start_time)
+
+        
+        # Find location columns
+        
+        # We want batteries in the same building/room to appear
+        # close together in the ordering.
+        #
+        location_columns = []
+
+        for candidate in [
+            "building",
+            "building_id",
+            "room",
+            "room_id",
+        ]:
+            if candidate in loc.columns:
+                location_columns.append(candidate)
+
+        
+        # Sort by urgency first, then location
+        
+        sort_columns = ["target_day"] + location_columns
+
+        order = loc.sort_values(
+            sort_columns,
+            ascending=True,
+        )
+
+        
+        #  Schedule several batteries per day
+        # Baseline:
+        # battery 1 -> day 1
+        # battery 2 -> day 2
+        # battery 3 -> day 3
+        # ...
+        #
+        # V3:
+        # batteries 1-6  -> day 1
+        # batteries 7-12 -> day 2
+        # ...
+        #
+        # This should strongly reduce late swaps.
+        #
+        planned_days = []
+
+        current_day = start_time
+        swaps_today = 0
+
+        for battery, row in order.iterrows():
+
+            desired_day = max(
+                start_time,
+                row["target_day"],
+            )
+
+            # If target date is later than our current day,
+            # move forward to that date.
+            if desired_day > current_day:
+                current_day = desired_day
+                swaps_today = 0
+
+            # Daily capacity reached -> next day
+            if swaps_today >= self.max_swaps_per_day:
+                current_day += pandas.Timedelta(days=1)
+                swaps_today = 0
+
+            planned_days.append(current_day)
+
+            swaps_today += 1
+
+        # Normalize only AFTER all planned days have been created
+        planned_days = pandas.to_datetime(planned_days).normalize()
+        #Construct final plan
         plan = pandas.DataFrame({
-            'day': days,
-            'battery': order.index,
+            "day": planned_days,
+            "battery": order.index,
         })
 
-        check_plan_valid(plan, locations, start_time=start_time)
+        check_plan_valid(
+            plan,
+            locations,
+            start_time=start_time,
+        )
 
         return plan
 
 
+
+
+
 class DummyRULModel(RULModel):
     # RUL model that predicts (no information rate)
     # FIXME: make a model that actually uses the data to improve predictions