@@ -711,6 +711,7 @@ def load_component_class(component_info):
             "load_ml_source": {"required": False, "config": "load_ml_source", "default": False},
             "load_ml_max_days_history": {"required": False, "config": "load_ml_max_days_history", "default": 28},
             "load_ml_database_days": {"required": False, "config": "load_ml_database_days", "default": 90},
+            "load_ml_retrain_interval_hours": {"required": False, "config": "load_ml_retrain_interval_hours", "default": 2},
         },
         "phase": 2,  # Load ML in phase 2 so that any Predbat cloud components (such as GEcloud) have been started and initialised pv_today, etc
         "can_restart": True,
 
@@ -2897,6 +2897,7 @@
     "enable_coarse_fine_levels": {"type": "boolean"},
     "load_power_fill_enable": {"type": "boolean"},
     "load_ml_enable": {"type": "boolean"},
+    "load_ml_retrain_interval_hours": {"type": "integer", "min": 1, "max": 48},
     "gateway_device_id": {"type": "string", "empty": False},
     "gateway_mqtt_host": {"type": "string", "empty": False},
     "gateway_mqtt_port": {"type": "integer", "zero": False},
 
@@ -15,7 +15,7 @@
 
 ComponentBase wrapper that manages the LoadPredictor lifecycle including
 data fetching, periodic training/fine-tuning, prediction generation, and
-status sensor publishing. Retrains every 2 hours and updates predictions
+status sensor publishing. Retrains every 2 hours by default and updates predictions
 every 30 minutes.
 """
 
@@ -31,7 +31,6 @@
 import numpy as np
 
 # Training intervals
-RETRAIN_INTERVAL_SECONDS = 2 * 60 * 60  # 2 hours between training cycles
 PREDICTION_INTERVAL_SECONDS = 30 * 60  # 30 minutes between predictions
 
 # Database schema version - increment when the saved format changes to force a clean rebuild
@@ -51,7 +50,7 @@ class LoadMLComponent(ComponentBase):
     - Falls back to empty predictions when validation fails or model is stale
     """
 
-    def initialize(self, load_ml_enable, load_ml_source=True, load_ml_max_days_history=28, load_ml_database_days=90):
+    def initialize(self, load_ml_enable, load_ml_source=True, load_ml_max_days_history=28, load_ml_database_days=90, load_ml_retrain_interval_hours=2):
         """
         Initialise the ML load forecaster component.
 
@@ -60,6 +59,7 @@ def initialize(self, load_ml_enable, load_ml_source=True, load_ml_max_days_histo
             load_ml_source: Whether using ML as the data source is enabled or not
             load_ml_max_days_history: Maximum number of days of load history to fetch
             load_ml_database_days: Number of days of historical data to store in the database, maximum length for training
+            load_ml_retrain_interval_hours: Hours between training cycles, clamped to 1-48
         """
 
         self.ml_enable = load_ml_enable
@@ -86,6 +86,7 @@ def initialize(self, load_ml_enable, load_ml_source=True, load_ml_max_days_histo
         self.ml_time_decay_days = 30
         self.ml_max_load_kw = 50.0
         self.ml_max_model_age_hours = 48
+        self.ml_retrain_interval_seconds = max(1, min(self.ml_max_model_age_hours, load_ml_retrain_interval_hours)) * 60 * 60
         self.ml_weight_decay = 0.01
         self.ml_dropout_rate = 0.1
         self.ml_max_days_history = load_ml_max_days_history
@@ -721,8 +722,8 @@ async def run(self, seconds, first):
         is_initial = not self.initial_training_done
 
         # Retrain if the model is older than the retrain interval (rather than on a fixed tick)
-        retrain_age_seconds = (self.now_utc - self.last_train_time).total_seconds() if self.last_train_time else RETRAIN_INTERVAL_SECONDS
-        should_train = not first and (retrain_age_seconds >= RETRAIN_INTERVAL_SECONDS)
+        retrain_age_seconds = (self.now_utc - self.last_train_time).total_seconds() if self.last_train_time else self.ml_retrain_interval_seconds
+        should_train = not first and (retrain_age_seconds >= self.ml_retrain_interval_seconds)
 
         # Fetch fresh load data periodically (every N minutes)
         should_fetch = first or should_train or ((seconds % PREDICTION_INTERVAL_SECONDS) == 0)
@@ -756,7 +757,7 @@ async def run(self, seconds, first):
                 self.log("ML Component: Initial training is required, delaying until component has started")
                 return True
         elif should_train:
-            self.log("ML Component: Starting fine-tune training (2h interval), model age is {} hours".format(retrain_age_seconds / 3600.0))
+            self.log("ML Component: Starting fine-tune training ({:g}h interval), model age is {} hours".format(self.ml_retrain_interval_seconds / 3600.0, retrain_age_seconds / 3600.0))
         elif should_fetch:
             # If not training either then no need to print anything
             self.log("ML Component: No training needed, model age is {} hours".format(dp2(retrain_age_seconds / 3600.0)))
 
@@ -64,6 +64,7 @@ def test_load_ml(my_predbat=None):
         ("component_stale_midnight_baseline", _test_component_stale_midnight_baseline, "LoadMLComponent baseline handling when publishing crosses midnight"),
         ("car_subtraction_direct", _test_car_subtraction_direct, "Direct car_subtraction method with interpolation and smoothing"),
         ("component_run_data_merge", _test_component_run_data_merge, "LoadMLComponent run() data fetch, save and merge across two runs"),
+        ("component_retrain_interval", _test_component_retrain_interval, "YAML retraining interval, boundaries, startup and prediction cadence"),
         ("component_init_predictor_last_train_time", _test_component_init_predictor_sets_last_train_time, "LoadMLComponent _init_predictor sets last_train_time from embedded training_timestamp"),
         ("nan_inf_robustness", _test_nan_inf_robustness, "LoadPredictor handles NaN, Inf, and None across input channels without NaN loss"),
         ("database_zero_preservation", _test_database_zero_preservation, "Database save/load preserves 0.0 values across roundtrip"),
@@ -981,6 +982,61 @@ def _test_prediction_with_temp():
         assert max_minute >= 2800, f"Predictions should span ~48h (2880 min), got {max_minute} min"
 
 
+def _test_component_retrain_interval():
+    """Exercise YAML-to-component wiring and age-based scheduling without expensive training."""
+    import asyncio
+    from unittest.mock import AsyncMock, Mock
+    from components import Components
+    from mock_base import MockBase
+
+    async def run_test():
+        """Check defaults, configured bounds, clamping and the independent prediction timer."""
+        key = "load_ml_retrain_interval_hours"
+        for args, expected_hours in (({}, 2), ({key: 24}, 24), ({key: 1}, 1), ({key: 48}, 48), ({key: 0}, 1), ({key: -1}, 1), ({key: 49}, 48)):
+            base = MockBase(config_root=None, load_ml_enable=True, load_ml_database_days=0, load_today=["sensor.load_today"], **args)
+            base.log = Mock()
+            base.prediction_started = False
+            registry = Components(base)
+            registry.initialize(only="load_ml", phase=2)
+            component = registry.get_component("load_ml")
+            assert component is not None, registry.component_errors
+            assert component.ml_retrain_interval_seconds == expected_hours * 3600
+            component.data_ready = True
+            component.load_data_age_days = 7
+            component.database_history_loaded = True
+            component._do_fetch = AsyncMock()
+            component._do_training = AsyncMock()
+            component._get_predictions = Mock(return_value={})
+            component._update_model_status = Mock()
+            component._publish_entity = Mock()
+
+            # Use a non-prediction tick to prove retraining follows model age, not uptime.
+            for age_seconds, seconds, first, expected_train, expected_predict in (
+                (expected_hours * 3600 - 1, 30, False, False, False),
+                (expected_hours * 3600, 30, False, True, True),
+                (expected_hours * 3600 + 1, 30, False, True, True),
+                (1800, 1800, False, False, True),
+                (None, 0, True, False, False),
+                (None, 30, False, True, True),
+            ):
+                component.initial_training_done = age_seconds is not None
+                component.last_train_time = base.now_utc - timedelta(seconds=age_seconds) if age_seconds is not None else None
+                component._do_fetch.reset_mock()
+                component._do_training.reset_mock()
+                component._get_predictions.reset_mock()
+                base.log.reset_mock()
+                assert await component.run(seconds=seconds, first=first)
+                assert component._do_training.await_count == int(expected_train), (args, age_seconds, first)
+                assert component._get_predictions.call_count == int(expected_predict), (args, age_seconds, first)
+                assert component._do_fetch.await_count == int(first or expected_predict), (args, age_seconds, first)
+                if expected_train:
+                    component._do_training.assert_awaited_once_with(age_seconds is None)
+                    if age_seconds is not None:
+                        assert any("({}h interval)".format(expected_hours) in call.args[0] for call in base.log.call_args_list)
+
+    asyncio.run(run_test())
+
+
 def _test_component_run_data_merge():
     """Test LoadMLComponent.run() - mocks _fetch_load_data and verifies:
     1. Run 1 (first=True): data is fetched and stored, but training is deferred (no save).
@@ -1104,7 +1160,7 @@ async def mock_save_database_history():
         mock_base.now_utc = mock_base.now_utc + timedelta(minutes=ELAPSED_MINUTES)
 
         # ── Run 2 (first=False, seconds=30) ─────────────────────────────────────
-        # last_train_time is None -> retrain_age_seconds = RETRAIN_INTERVAL_SECONDS -> should_train=True
+        # last_train_time is None -> retrain_age_seconds = configured interval -> should_train=True
         # Expect: shift old keys, merge fresh data, run initial training, save once.
         component._fetch_load_data = AsyncMock(return_value=(fetch_data_2, 7, 3.0, None, None, None, None))
 
@@ -1133,7 +1189,7 @@ async def mock_save_database_history():
 
         # ── Run 3 (first=False, seconds=PREDICTION_INTERVAL_SECONDS) ─────────────
         # last_train_time = 30 min ago (set in mock_do_training to component.now_utc of Run 2).
-        # retrain_age_seconds = 30*60 = 1800 < RETRAIN_INTERVAL_SECONDS (7200) -> should_train=False.
+        # retrain_age_seconds = 30*60 = 1800 < default interval (7200) -> should_train=False.
         # seconds % PREDICTION_INTERVAL_SECONDS == 0 -> should_fetch=True.
         # Expect: fetch+predict+save only, no training.
         component._fetch_load_data = AsyncMock(return_value=(fetch_data_3, 7, 3.0, None, None, None, None))
 
@@ -150,6 +150,12 @@ def test_validate_config(my_predbat):
     _run(my_predbat, {"log_count": 2}, expect_clean=["log_count"])
     _run(my_predbat, {"log_count": 100}, expect_clean=["log_count"])
 
+    print("  [ML retrain interval] whole hours within 1-48 pass; invalid values fail")
+    for hours in (1, 2, 24, 48):
+        _run(my_predbat, {"load_ml_retrain_interval_hours": hours}, expect_clean=["load_ml_retrain_interval_hours"])
+    for hours in (-1, 0, 49, 2.5, "daily"):
+        _run(my_predbat, {"load_ml_retrain_interval_hours": hours}, expect_errors=["load_ml_retrain_interval_hours"])
+
     # ==========================================================================
     # INTEGER_LIST type  (days_previous: {"type": "integer_list"})
     # ==========================================================================
 
@@ -1797,7 +1797,7 @@ This provides more accurate load predictions than simple averaging, especially f
 - Optionally incorporates PV generation and temperature forecast data
 - Trains a multi-layer neural network on your historical patterns
 - Makes autoregressive predictions for 48 hours ahead in 5-minute intervals
-- Fine-tunes periodically (every 2 hours) to adapt to changing patterns
+- Fine-tunes periodically (every 2 hours by default) to adapt to changing patterns
 - Validates predictions and falls back gracefully if accuracy is poor
 - Publishes predictions to `sensor.predbat_load_ml_forecast`
 
@@ -1813,6 +1813,7 @@ For a detailed explanation of how the neural network works and comprehensive con
 | `load_ml_source` | Boolean | No | false | `load_ml_source` | Set to `true` to use ML predictions in Predbat battery planning |
 | `load_ml_max_days_history` | Integer | No | 28 | `load_ml_max_days_history` | Maximum days of load history to fetch from HA on each poll (bounded by HA recorder retention) |
 | `load_ml_database_days` | Integer | No | 90 | `load_ml_database_days` | Days of history to accumulate in the on-disk database (`predbat_ml_history.npz`); set to 0 to disable the database |
+| `load_ml_retrain_interval_hours` | Integer | No | 2 | `load_ml_retrain_interval_hours` | Hours between training cycles (1–48); use 24 for daily retraining. Predictions still update every 30 minutes |
 
 Note: **load_today**, **pv_today** and **car_charging_energy** `apps.yaml` configuration items are also used, but these should already be set in Predbat.
 
@@ -1831,6 +1832,9 @@ predbat:
   # Optional: days of history to accumulate on disk for training (default 90)
   # load_ml_database_days: 90
 
+  # Optional: hours between training cycles (default 2, range 1-48)
+  # load_ml_retrain_interval_hours: 24
+
   # Optional but recommended: enable temperature forecasts
   temperature_enable: true
 ```
 
@@ -30,7 +30,7 @@ The ML Load Prediction component uses a lightweight multi-layer perceptron (MLP)
 - Deep neural network with 3 hidden layers [512, 256, 64 neurons]
 - Optimised with He initialisation and AdamW weight decay for robust training
 - Automatically trains on historical data (requires at least 1 day, recommended 7+ days; fetches up to `load_ml_max_days_history` days from HA and accumulates up to `load_ml_database_days` days in the on-disk database)
-- Fine-tunes periodically (every 2 hours) using full dataset to adapt to changing patterns
+- Fine-tunes periodically (every 2 hours by default) using full dataset to adapt to changing patterns
 - Time-weighted training prioritizes recent data while learning from historical patterns
 - Model persists across restarts
 - Falls back gracefully if predictions are unreliable
@@ -207,12 +207,21 @@ predbat:
 
   # Optional: Number of days of history to accumulate in the on-disk database (default: 90)
   # load_ml_database_days: 90
+
+  # Optional: Retrain once a day instead of every 2 hours
+  # load_ml_retrain_interval_hours: 24
 ```
 
 **Configuration Parameter Details:**
 
 - `load_ml_enable`: Enables the ML component (required), defaults to false.
 - `load_ml_source`: When `true`, Predbat uses ML predictions for battery planning. Set to `false` (the default) to test predictions without affecting battery control
+- `load_ml_retrain_interval_hours`: Hours between training cycles, measured from the model's last training time
+    - **Default**: 2 hours
+    - **Range**: Whole hours from 1 to 48; out-of-range values are clamped to these limits because models become stale after 48 hours
+    - **Example**: Set to `24` for daily retraining to reduce how often training uses CPU
+    - **Unchanged behaviour**: Initial training still runs after startup once enough data is available; predictions still update every 30 minutes
+    - **Apply changes**: Restart Predbat after editing `apps.yaml`; no additional Home Assistant entity is created
 - `load_ml_max_days_history`: Optional maximum days of historical data to fetch from Home Assistant on each poll (every 30 minutes)
     - **Default**: 28 days
     - **Minimum**: 7 days
@@ -383,7 +392,7 @@ Good predictions require:
 4. **Energy Rate Data**: Automatically included - helps model learn consumption patterns based on time-of-use tariffs
 5. **PV Generation Data**: If you have solar panels, include `pv_today` sensor for better correlation
 6. **Clean Data**: Avoid gaps or incorrect readings in historical data
-7. **Recent Training**: Model retrains every 2 hours using full dataset with time-weighted sampling to adapt to changing patterns
+7. **Recent Training**: Model retrains every `load_ml_retrain_interval_hours` (default 2 hours) using full dataset with time-weighted sampling to adapt to changing patterns
 
 ### Understanding MAE (Mean Absolute Error)