buzeraandClaude Opus 5.5
b1577a0c78
Validation: the walk-forward evaluator now replays all zones together with the full model (electrical heat, neighbour exchange, ventilation and recovery) using the parameters frozen at the forecast start and the electrical heat and window openings that actually happened, and scores the base 3-parameter model on the same spans. Forecast Error sensors add base_model_mae and improvement_vs_base (share of the base model's error the new features remove; 0 = no gain, negative = worse). Saved 0.3 statistics load with their own error as the base column. On synthetic apartments, 60-minute error full vs base: gaming office 0.031 vs 0.182 °C (83 % better), bedroom with ventilation 0.026 vs 0.218 °C (88 %), two coupled rooms 0.024 vs 0.037 °C (34 %; gone by 120 min, where the constant-outdoor assumption dominates). The same ventilation week without window sensors shows no improvement, as it should. These check the method, not real-world accuracy. Performance: every term of a zone's 5-minute change is affine in the zone temperatures and the radiator lag, and which layer applies depends only on which inputs exist. compile_step_model reads the coefficients off the real model per zone and step, so the plan search does a few multiply-adds per step. It matches the direct model to 1e-12 and makes a 180-minute, 5-zone search 4.5x faster (0.73 s here, close to the old base-only search). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
664 lines
38 KiB
Python
664 lines
38 KiB
Python
"""Read existing HA entities, learn thermal response, produce shadow MPC decisions."""
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
from collections import deque
|
|
from datetime import datetime, timedelta, timezone
|
|
from functools import partial
|
|
from math import exp
|
|
from typing import Any
|
|
|
|
from homeassistant.core import Event, HomeAssistant, callback
|
|
from homeassistant.config_entries import ConfigEntry
|
|
from homeassistant.helpers.storage import Store
|
|
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
|
|
|
|
from .const import (
|
|
CONF_ROOM_MAX_AGE, CONF_ROOM_STALE_KEEP, CONF_WEATHER_MAX_AGE, ROOM_STALE_KEEP_MAX_MINUTES,
|
|
DOMAIN, CONF_CLIMATE, CONF_HEATER, CONF_ROOMS, CONF_WEIGHTS, WEATHER_SOURCES,
|
|
CONF_HORIZON, CONF_MIN_ON, CONF_MIN_OFF, CONF_SWITCH_COST, CONF_HEAT_COST,
|
|
CONF_BAND, CONF_INTERNAL_HALF_LIFE, CONF_RECOVERY_MINUTES, CONF_VENT_CROSS, CONF_VENT_GUST,
|
|
CONF_VENT_WIND, CONF_WINDOW_OPEN_MINUTES, DEFAULTS, READY_OFF_SAMPLES, READY_ON_SAMPLES, READY_SAMPLES,
|
|
)
|
|
from .data_quality import ReportAgeHistory, freshness
|
|
from .evaluation import ForecastEvaluator, model_snapshot
|
|
from .heat_sources import SUBENTRY_HEAT_SOURCE, HeatSource, HeatSourceTracker, build_sources, normalize_power
|
|
from .learning import FeatureLearner
|
|
from .physics import (
|
|
LAG_LEARN_MAX_UNCERTAINTY, LAG_TAU_SECONDS, Learner, advance_lag,
|
|
lag_from_time_in_state, optimize, relay_segments,
|
|
)
|
|
from .weather_sources import choose_weather_sources, sources_for, normalize
|
|
from .windows import SUBENTRY_WINDOW, VentilationTracker, Window, build_windows, facing_cos, ventilation_vector
|
|
from .zone_model import ZoneModel, compile_step_model, extended_features, feature_vector
|
|
from .zones import SUBENTRY_ZONE, Zone, build_zones, legacy_zone_data, zone_temperature
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
# Relay changes kept between polls; more than this in five minutes is chatter.
|
|
MAX_RELAY_EVENTS = 256
|
|
# Models of zones removed in the UI, kept in case a zone is added back.
|
|
MAX_RETIRED_ROOMS = 24
|
|
|
|
|
|
def entry_zone_list(entry: ConfigEntry, config: dict[str, Any]) -> list[Zone]:
|
|
"""Zones from the entry's zone subentries; one zone per legacy room sensor otherwise."""
|
|
subentries = getattr(entry, "subentries", None) or {}
|
|
items = [(sub.data, sub.subentry_id) for sub in subentries.values()
|
|
if sub.subentry_type == SUBENTRY_ZONE]
|
|
if not items: # not migrated yet (or offline tests): same zones migration creates
|
|
items = [(data, None) for data in legacy_zone_data(
|
|
config.get(CONF_ROOMS, []), config.get(CONF_WEIGHTS))]
|
|
return build_zones(items)
|
|
|
|
|
|
def entry_window_list(entry: ConfigEntry, zones: dict[str, Zone]) -> list[Window]:
|
|
subentries = getattr(entry, "subentries", None) or {}
|
|
return build_windows(((sub.data, sub.subentry_id) for sub in subentries.values()
|
|
if sub.subentry_type == SUBENTRY_WINDOW), zones)
|
|
|
|
|
|
def ventilation_features(config: dict[str, Any], windows: list[Window], zone: str) -> list[str]:
|
|
"""Ventilation terms for a zone with windows; optional ones need their inputs."""
|
|
if not any(w.zone == zone and w.enabled for w in windows):
|
|
return []
|
|
wind = config.get(CONF_VENT_WIND) is True and bool(sources_for(config, "wind"))
|
|
features = ["vent_natural", "recovery"]
|
|
if wind:
|
|
features.append("vent_wind")
|
|
if sources_for(config, "wind_direction"):
|
|
features.append("vent_wind_dir")
|
|
if config.get(CONF_VENT_GUST) is True and sources_for(config, "wind_gust"):
|
|
features.append("vent_gust")
|
|
if config.get(CONF_VENT_CROSS) is True and len({w.zone for w in windows if w.enabled}) > 1:
|
|
features.append("vent_cross")
|
|
return features
|
|
|
|
|
|
def entry_source_list(entry: ConfigEntry, zones: dict[str, Zone]) -> list[HeatSource]:
|
|
subentries = getattr(entry, "subentries", None) or {}
|
|
return build_sources(((sub.data, sub.subentry_id) for sub in subentries.values()
|
|
if sub.subentry_type == SUBENTRY_HEAT_SOURCE), zones)
|
|
|
|
|
|
class HeatingMPCCoordinator(DataUpdateCoordinator[dict[str, Any]]):
|
|
"""The existing generic thermostat stays the only actuator owner."""
|
|
|
|
def __init__(self, hass: HomeAssistant, entry: ConfigEntry) -> None:
|
|
super().__init__(hass, _LOGGER, config_entry=entry, name=DOMAIN,
|
|
update_interval=timedelta(minutes=5))
|
|
self.entry = entry
|
|
self.config = {**DEFAULTS, **entry.data, **entry.options}
|
|
self.zones: dict[str, Zone] = {zone.key: zone for zone in entry_zone_list(entry, self.config)}
|
|
# Zone keys; models, forecasts and statistics are keyed by these.
|
|
self.rooms: list[str] = list(self.zones)
|
|
self.sensors: list[str] = [s for zone in self.zones.values() for s in zone.sensors]
|
|
self.learners: dict[str, Learner] = {room: Learner() for room in self.rooms}
|
|
self.sources = entry_source_list(entry, self.zones)
|
|
self._heat_sources = HeatSourceTracker(self.sources)
|
|
# Extended model per zone: base terms plus electrical heat and adjacent zones.
|
|
self._extended_features = {
|
|
key: extended_features(any(s.zone == key and s.enabled for s in self.sources), zone.neighbors)
|
|
for key, zone in self.zones.items()}
|
|
self.extended: dict[str, FeatureLearner] = {
|
|
key: FeatureLearner(features) for key, features in self._extended_features.items() if features}
|
|
self.windows = entry_window_list(entry, self.zones)
|
|
self._ventilation = VentilationTracker(self.windows, float(self.config[CONF_RECOVERY_MINUTES]))
|
|
self._ventilation_features = {key: ventilation_features(self.config, self.windows, key)
|
|
for key in self.zones}
|
|
self.ventilation: dict[str, FeatureLearner] = {
|
|
key: FeatureLearner(features) for key, features in self._ventilation_features.items() if features}
|
|
self._retired: dict[str, dict[str, Any]] = {}
|
|
self._report_ages = ReportAgeHistory()
|
|
self._evaluator = ForecastEvaluator(LAG_LEARN_MAX_UNCERTAINTY)
|
|
# How each poll was handled since start, to explain slow learning.
|
|
self._sample_results: dict[str, int] = {}
|
|
self._store = Store(hass, 1, f"{DOMAIN}.{entry.entry_id}")
|
|
self._previous: dict[str, Any] | None = None
|
|
# Radiator-lag proxy at the last poll with a valid relay state. Tracked
|
|
# independently of room sensors so lag survives room outages and transitions.
|
|
self._lag: dict[str, Any] | None = None
|
|
# (time, new state) of relay changes since the last poll, from a read-only listener.
|
|
self._relay_events: deque[tuple[datetime, str]] = deque(maxlen=MAX_RELAY_EVENTS)
|
|
self._relay_events_dropped = False
|
|
self._on_samples = 0
|
|
self._off_samples = 0
|
|
|
|
async def async_restore_model(self) -> None:
|
|
stored = await self._store.async_load() or {}
|
|
if not isinstance(stored, dict) or stored.get("schema_version", 1) not in (1, 2):
|
|
_LOGGER.warning("Ignoring unsupported Heating MPC model data")
|
|
return
|
|
# Replacing the actual heating system invalidates heating coefficients.
|
|
# Switching among weather providers does not discard months of learning.
|
|
if stored.get("heater_entity", self.config[CONF_HEATER]) != self.config[CONF_HEATER]:
|
|
_LOGGER.warning("Heating MPC heater changed; starting a fresh thermal model")
|
|
return
|
|
self._evaluator.load(stored.get("evaluation"))
|
|
self._heat_sources = HeatSourceTracker(self.sources, stored.get("heat_sources"))
|
|
saved_models = stored.get("zone_models") if isinstance(stored.get("zone_models"), dict) else {}
|
|
for key, features in self._extended_features.items():
|
|
if features and key in saved_models:
|
|
# Matched by feature name: a new source or neighbour retrains only its term.
|
|
self.extended[key] = FeatureLearner.from_dict(saved_models[key], features)
|
|
self._ventilation = VentilationTracker(self.windows, float(self.config[CONF_RECOVERY_MINUTES]),
|
|
stored.get("ventilation"))
|
|
saved_vent = stored.get("ventilation_models") if isinstance(stored.get("ventilation_models"), dict) else {}
|
|
for key, features in self._ventilation_features.items():
|
|
if features and key in saved_vent:
|
|
self.ventilation[key] = FeatureLearner.from_dict(saved_vent[key], features)
|
|
# Models carry room identity, so changing the room list is safe. Models of
|
|
# rooms no longer configured are retained, most recently removed last.
|
|
for key in ("retired_learners", "learners"): # current learners take precedence
|
|
saved = stored.get(key)
|
|
if not isinstance(saved, dict):
|
|
continue
|
|
for room, data in saved.items():
|
|
if not isinstance(room, str):
|
|
continue
|
|
learner = Learner.from_dict(data)
|
|
if room in self.learners:
|
|
self.learners[room] = learner
|
|
elif learner.count:
|
|
self._retired.pop(room, None)
|
|
self._retired[room] = learner.as_dict()
|
|
while len(self._retired) > MAX_RETIRED_ROOMS:
|
|
self._retired.pop(next(iter(self._retired)))
|
|
self._update_counts()
|
|
|
|
def _update_counts(self) -> None:
|
|
self._on_samples = min(m.on_count for m in self.learners.values())
|
|
self._off_samples = min(m.off_count for m in self.learners.values())
|
|
|
|
def _sensor_quality(self, entity_id: str, now: datetime, limit: float) -> dict:
|
|
state = self.hass.states.get(entity_id)
|
|
if state is None:
|
|
return {"status": "missing", "age_seconds": None}
|
|
if state.state in ("unknown", "unavailable"):
|
|
return {"status": state.state, "age_seconds": None}
|
|
# last_updated is a conservative compatibility fallback for older HA.
|
|
quality = freshness(getattr(state, "last_reported", getattr(state, "last_updated", None)),
|
|
now, limit * 60)
|
|
if quality["status"] in ("valid", "stale"):
|
|
quality["max_age_seconds_24h"] = round(
|
|
self._report_ages.observe(entity_id, now, quality["age_seconds"]), 1)
|
|
return quality
|
|
|
|
@callback
|
|
def async_relay_changed(self, event: Event) -> None:
|
|
"""Record relay state changes as they happen; read-only state listener."""
|
|
old, new = event.data.get("old_state"), event.data.get("new_state")
|
|
if new is None:
|
|
self.record_relay_state(event.time_fired, "removed")
|
|
elif old is None or old.state != new.state:
|
|
self.record_relay_state(new.last_changed, new.state)
|
|
|
|
def record_relay_state(self, when: datetime, state: str) -> None:
|
|
if len(self._relay_events) == self._relay_events.maxlen:
|
|
self._relay_events_dropped = True
|
|
self._relay_events.append((when, state))
|
|
|
|
def _track_lag(self, now: datetime, heater_on: bool, last_changed: datetime) -> bool:
|
|
"""Advance the lag proxy to `now`; return True if the relay held one state throughout.
|
|
|
|
Relay changes since the last poll are integrated at their timestamps. Anything
|
|
ambiguous (missed changes, an outage, clock jumps) restarts the estimate from
|
|
the time spent in the current state, with an explicit error bound.
|
|
"""
|
|
tracker = self._lag
|
|
steady = False
|
|
lag = uncertainty = None
|
|
if tracker is not None and now > tracker["time"]:
|
|
start = tracker["time"]
|
|
changes = [(when, state) for when, state in self._relay_events if start < when <= now]
|
|
# The current state is authoritative; its change event may still be queued,
|
|
# and without a listener it is the only change visible.
|
|
if last_changed > start and (not changes or changes[-1][0] < last_changed):
|
|
changes.append((last_changed, "on" if heater_on else "off"))
|
|
segments = None if self._relay_events_dropped else relay_segments(
|
|
tracker["heater_on"], start.timestamp(),
|
|
[(when.timestamp(), state) for when, state in changes], now.timestamp())
|
|
if segments is not None and segments[-1][0] == heater_on:
|
|
lag = tracker["lag"]
|
|
for command, seconds in segments:
|
|
lag = advance_lag(lag, command, seconds)
|
|
# The lag update is a contraction, so an initial error decays the same way.
|
|
uncertainty = tracker["uncertainty"] * exp(
|
|
-(now - start).total_seconds() / LAG_TAU_SECONDS)
|
|
steady = len(segments) == 1
|
|
if lag is None:
|
|
lag, uncertainty = lag_from_time_in_state(
|
|
heater_on, (now - last_changed).total_seconds())
|
|
self._lag = {"time": now, "heater_on": heater_on, "lag": lag, "uncertainty": uncertainty}
|
|
self._relay_events = deque((e for e in self._relay_events if e[0] > now),
|
|
maxlen=MAX_RELAY_EVENTS)
|
|
self._relay_events_dropped = False
|
|
return steady
|
|
|
|
def _count_result(self, status: dict[str, Any], result: str) -> None:
|
|
"""Record how this poll was handled for learning, and the learning progress."""
|
|
status["sample_result"] = result
|
|
self._sample_results[result] = self._sample_results.get(result, 0) + 1
|
|
status["sample_results_since_start"] = dict(self._sample_results)
|
|
# Least trained room: mean of its three readiness requirements (100 = ready).
|
|
status["learning_progress"] = round(100 * min(
|
|
(min(1.0, m.count / READY_SAMPLES) + min(1.0, m.on_count / READY_ON_SAMPLES)
|
|
+ min(1.0, m.off_count / READY_OFF_SAMPLES)) / 3
|
|
for m in self.learners.values()), 1)
|
|
|
|
def _extended_diagnostics(self, room: str) -> dict[str, Any]:
|
|
model = self.extended.get(room)
|
|
if model is None:
|
|
return {"model_in_use": "base"}
|
|
return {"model_in_use": "extended" if ZoneModel(self.learners[room], model).uses_extended else "base",
|
|
"extended": {"samples": model.count, "on_samples": model.on_count,
|
|
"off_samples": model.off_count,
|
|
"mae_5m": round(model.mae, 4) if model.mae is not None else None,
|
|
"coefficients": model.coefficients()}}
|
|
|
|
def _source_diagnostics(self, quality: dict[str, dict]) -> dict[str, Any]:
|
|
names = {s.key: s.name for s in self.sources}
|
|
result = {}
|
|
for source in self.sources:
|
|
info = self._heat_sources.state.get(source.key, {})
|
|
|
|
def watts(kw):
|
|
return None if kw is None else round(kw * 1000, 1)
|
|
result[source.name] = {
|
|
"zone": self.zones[source.zone].name, "sensor": source.sensor,
|
|
"status": quality[source.key]["status"], "enabled": source.enabled,
|
|
"power_w": info.get("power_w"), "effective_w": info.get("effective_w"),
|
|
"included_in": names.get(source.included_in),
|
|
"baseline_w": info.get("baseline_w"), "baseline_mode": source.baseline_mode,
|
|
"variable_w": watts(info.get("variable_kw")), "thermal_response_w": watts(info.get("response_kw")),
|
|
"settled": info.get("settled", False), "heat_fraction": source.fraction,
|
|
"response_minutes": source.response_minutes,
|
|
}
|
|
return result
|
|
|
|
def _step_model(self, temps: dict[str, float], outside: float, horizon: int,
|
|
weather: dict[str, Any], now: float):
|
|
"""Multi-zone step for the optimizer, or None when only base models apply."""
|
|
models = {key: ZoneModel(self.learners[key], self.extended.get(key), self.ventilation.get(key))
|
|
for key in temps}
|
|
steps = horizon // 5
|
|
ventilation = {key: self._ventilation.forecast(
|
|
key, steps, float(self.config[CONF_WINDOW_OPEN_MINUTES]), weather, now) for key in temps}
|
|
venting = any(models[key].ventilation is not None
|
|
and any(s.get("opening") or s.get("recovery") for s in ventilation[key]) for key in temps)
|
|
if not venting and not any(model.uses_extended for model in models.values()):
|
|
return None
|
|
half_life = float(self.config.get(CONF_INTERNAL_HALF_LIFE, 30))
|
|
forecast = {key: self._heat_sources.zone_forecast(key, steps, half_life) for key in temps}
|
|
return compile_step_model(models, list(temps), steps, lambda key, k: {
|
|
"outside": outside, "internal": forecast[key][k], "ventilation": ventilation[key][k]})
|
|
|
|
def _zone_details(self, temps: dict[str, float], outside: float, internal: dict[str, float | None],
|
|
vent_inputs: dict[str, Any]) -> dict[str, Any]:
|
|
"""What drives each zone right now (°C/h per effect) and how sure each layer is."""
|
|
details = {}
|
|
lag = self._lag["lag"]
|
|
for key, temp in temps.items():
|
|
model = ZoneModel(self.learners[key], self.extended.get(key), self.ventilation.get(key))
|
|
inputs = {"outside": outside, "lag": lag, "internal": internal[key], "temps": temps,
|
|
"ventilation": vent_inputs.get(key) or {}}
|
|
a, b, c = self.learners[key].theta
|
|
coefficients = {"base": {"loss": round(a, 6), "heat": round(b, 6), "bias": round(c, 6)}}
|
|
for layer, learner in (("extended", model.extended), ("ventilation", model.ventilation)):
|
|
if learner is not None:
|
|
coefficients[layer] = {name: {k: info[k] for k in ("value", "std", "confidence", "identified")}
|
|
for name, info in learner.coefficients().items()}
|
|
details[key] = {"temperature": round(temp, 3),
|
|
"model_in_use": "extended" if model.uses_extended else "base",
|
|
"contributions_c_per_h": model.contributions(temp, inputs),
|
|
"coefficients": coefficients}
|
|
return details
|
|
|
|
def _window_diagnostics(self, now: float, weather: dict[str, Any], temps: dict[str, float | None],
|
|
vent_inputs: dict[str, Any], internal: dict[str, float | None]) -> dict[str, Any]:
|
|
windows = {}
|
|
for window in self.windows:
|
|
info = self._ventilation.window_state.get(window.key, {})
|
|
is_open, since = info.get("open"), info.get("since")
|
|
direction = weather.get("wind_direction")
|
|
windows[window.name] = {
|
|
"zone": self.zones[window.zone].name, "sensor": window.sensor, "enabled": window.enabled,
|
|
"state": "unknown" if is_open is None else "open" if is_open else "closed",
|
|
"open_minutes": round((now - since) / 60, 1) if is_open and since else None,
|
|
"azimuth": window.azimuth, "opening_factor": window.opening, "inverted": window.inverted,
|
|
"relative_wind_direction": info.get("relative_wind_direction"),
|
|
"wind_exposure": round(facing_cos(direction, window.azimuth), 3) if direction is not None else None,
|
|
}
|
|
zones = {}
|
|
for key, inputs in vent_inputs.items():
|
|
model = self.ventilation.get(key)
|
|
if inputs is None or model is None:
|
|
continue
|
|
temp, outside = temps.get(key), weather.get("temperature")
|
|
contributions = {}
|
|
if temp is not None and outside is not None:
|
|
terms = ZoneModel(self.learners[key], self.extended.get(key), model).contributions(temp, {
|
|
"outside": outside, "lag": (self._lag or {}).get("lag", 0.0), "internal": internal[key],
|
|
"temps": temps, "ventilation": inputs})
|
|
contributions = {name: terms.get(name, 0.0) for name in ("ventilation", "recovery")}
|
|
zones[self.zones[key].name] = {
|
|
"opening": inputs["opening"], "recovery": round(inputs["recovery"], 3),
|
|
"temperature_before": inputs["t_ref"], "affected": inputs["affected"],
|
|
"contribution_c_per_h": contributions, "samples": model.count,
|
|
"coefficients": model.coefficients()}
|
|
return {"windows": windows, "ventilation": zones,
|
|
"ventilation_events": list(self._ventilation.events)[-5:]}
|
|
|
|
def _prediction_inputs(self) -> tuple:
|
|
"""Values the prediction depends on, used to detect changes during calculation."""
|
|
heater = self.config[CONF_HEATER]
|
|
entities = sorted(set(self.sensors) | set(sources_for(self.config, "temperature")) |
|
|
{self.config[CONF_CLIMATE], heater})
|
|
values = []
|
|
for entity_id in entities:
|
|
state = self.hass.states.get(entity_id)
|
|
if state is None:
|
|
values.append((entity_id, None))
|
|
continue
|
|
attrs = state.attributes
|
|
values.append((entity_id, state.state, attrs.get("unit_of_measurement"),
|
|
attrs.get("temperature"), attrs.get("temperature_unit"),
|
|
state.last_changed if entity_id == heater else None))
|
|
return tuple(values)
|
|
|
|
async def _async_update_data(self) -> dict[str, Any]:
|
|
now = datetime.now(timezone.utc)
|
|
heater = self.hass.states.get(self.config[CONF_HEATER])
|
|
climate = self.hass.states.get(self.config[CONF_CLIMATE])
|
|
# Choose each weather variable independently from ordered sensor sources.
|
|
# Sensor priorities are editable in Options without touching integration code.
|
|
weather_entity_ids = {
|
|
entity_id for metric in WEATHER_SOURCES
|
|
for entity_id in sources_for(self.config, metric)
|
|
}
|
|
snapshot = {entity: self.hass.states.get(entity)
|
|
for entity in set(self.sensors) | weather_entity_ids}
|
|
inputs_before = self._prediction_inputs()
|
|
sensor_quality = {}
|
|
readings: dict[str, float | None] = {}
|
|
keep_stale = self.config.get(CONF_ROOM_STALE_KEEP) is True
|
|
for sensor in self.sensors:
|
|
quality = self._sensor_quality(sensor, now, self.config[CONF_ROOM_MAX_AGE])
|
|
value = None
|
|
# Optionally trust sensors that report only on change, but never a
|
|
# sensor silent for a day: it is most likely dead.
|
|
if quality["status"] == "valid" or (
|
|
keep_stale and quality["status"] == "stale"
|
|
and quality["age_seconds"] <= ROOM_STALE_KEEP_MAX_MINUTES * 60):
|
|
state = snapshot[sensor]
|
|
value = normalize("temperature", state.state, state.attributes.get("unit_of_measurement"))
|
|
if value is None or not 0 <= value <= 45:
|
|
quality["status"] = "invalid_value_or_unit"
|
|
value = None
|
|
quality["used"] = value is not None
|
|
sensor_quality[sensor] = quality
|
|
readings[sensor] = value
|
|
# A zone is usable while at least one of its sensors is; sensor weights
|
|
# combine them. Which sensors were used matters for learning (see below).
|
|
temps: dict[str, float | None] = {}
|
|
compositions: dict[str, frozenset[str]] = {}
|
|
zone_quality = {}
|
|
for key, zone in self.zones.items():
|
|
temps[key], compositions[key] = zone_temperature(zone, readings)
|
|
zone_quality[key] = {"name": zone.name, "used": temps[key] is not None,
|
|
"sensors": {s: sensor_quality[s] for s in zone.sensors}}
|
|
weather_states = {}
|
|
weather_quality = {}
|
|
for entity_id in weather_entity_ids:
|
|
quality = self._sensor_quality(entity_id, now, self.config[CONF_WEATHER_MAX_AGE])
|
|
weather_quality[entity_id] = quality
|
|
if quality["status"] == "valid":
|
|
state = snapshot[entity_id]
|
|
weather_states[entity_id] = (state.state, state.attributes.get("unit_of_measurement"))
|
|
weather, active_sources, weather_comparisons = choose_weather_sources(
|
|
self.config, weather_states
|
|
)
|
|
metric_quality = {}
|
|
for metric in WEATHER_SOURCES:
|
|
metric_quality[metric] = {}
|
|
for entity_id in sources_for(self.config, metric):
|
|
quality = dict(weather_quality[entity_id])
|
|
if quality["status"] == "valid" and entity_id not in weather_comparisons[metric]:
|
|
quality["status"] = "invalid_value_or_unit"
|
|
metric_quality[metric][entity_id] = quality
|
|
outside = weather["temperature"]
|
|
status: dict[str, Any] = {
|
|
"input_quality": {"zones": zone_quality, "weather": metric_quality},
|
|
"status": "waiting_for_sensors", "proposal": None, "prediction_60m": {},
|
|
"temperatures": {r: round(t, 3) for r, t in temps.items() if t is not None},
|
|
"zone_names": {key: zone.name for key, zone in self.zones.items()},
|
|
"on_samples": self._on_samples, "off_samples": self._off_samples,
|
|
"samples": min(learner.count for learner in self.learners.values()),
|
|
"mode": climate.state if climate else "unavailable",
|
|
"weather": {k: v for k, v in weather.items() if v is not None},
|
|
"weather_active_sources": {k: v for k, v in active_sources.items() if v},
|
|
"weather_comparison": {k: v for k, v in weather_comparisons.items() if v},
|
|
"weather_model_inputs": ["temperature"],
|
|
"retired_zone_models": sorted(self._retired),
|
|
"excluded_zones": [room for room in self.rooms if temps[room] is None],
|
|
}
|
|
# Electrical heat sources: processed every poll so their responses stay continuous.
|
|
source_readings: dict[str, float | None] = {}
|
|
source_quality = {}
|
|
for source in self.sources:
|
|
quality = self._sensor_quality(source.sensor, now, self.config[CONF_ROOM_MAX_AGE])
|
|
watts = None
|
|
if quality["status"] == "valid":
|
|
state = self.hass.states.get(source.sensor)
|
|
watts = normalize_power(state.state, state.attributes.get("unit_of_measurement"))
|
|
if watts is None:
|
|
quality["status"] = "invalid_value_or_unit"
|
|
source_readings[source.key] = watts
|
|
source_quality[source.key] = quality
|
|
self._heat_sources.update(now.timestamp(), source_readings)
|
|
internal = {key: self._heat_sources.zone_input(key) for key in self.zones}
|
|
if self.sources:
|
|
status["heat_sources"] = self._source_diagnostics(source_quality)
|
|
# Windows: tracked every poll; unknown states stay unknown, never "closed".
|
|
window_states = {}
|
|
for window in self.windows:
|
|
state = self.hass.states.get(window.sensor)
|
|
window_states[window.key] = ((state.state, state.last_changed.timestamp()) if state else (None, None))
|
|
self._ventilation.update(now.timestamp(), window_states, temps, weather)
|
|
vent_inputs = {key: self._ventilation.zone_inputs(key, weather) for key in self.zones}
|
|
if self.windows:
|
|
status.update(self._window_diagnostics(now.timestamp(), weather, temps, vent_inputs, internal))
|
|
heater_valid = heater is not None and heater.state in ("on", "off")
|
|
heater_on = heater_valid and heater.state == "on"
|
|
steady = False
|
|
if heater_valid:
|
|
steady = self._track_lag(now, heater_on, heater.last_changed)
|
|
status["heat_lag"] = round(self._lag["lag"], 3)
|
|
status["heat_lag_uncertainty"] = round(self._lag["uncertainty"], 3)
|
|
else:
|
|
self._lag = None
|
|
self._relay_events.clear()
|
|
self._relay_events_dropped = False
|
|
# Rooms without a usable reading are left out and the others carry on;
|
|
# only the shared inputs, or losing every room, pause the integration.
|
|
vals: dict[str, float] = {room: float(t) for room, t in temps.items() if t is not None}
|
|
if not heater_valid or climate is None or outside is None or not vals:
|
|
self._previous = None
|
|
self._evaluator.reset_window()
|
|
status["forecast_accuracy"] = self._evaluator.summary(self.rooms)
|
|
self._count_result(status, "waiting_for_inputs")
|
|
return status
|
|
|
|
# A zone learns only across a poll pair where it was usable at both ends with
|
|
# the same sensors: a sensor dropping out shifts the mean by its offset.
|
|
pairs = [room for room in vals if self._previous and room in self._previous["temps"]
|
|
and self._previous["compositions"].get(room) == compositions[room]]
|
|
learned = False
|
|
if not pairs:
|
|
changed = self._previous and any(
|
|
room in self._previous["temps"] and self._previous["compositions"].get(room)
|
|
!= compositions[room] for room in vals)
|
|
status["sample_result"] = "sensors_changed" if changed else "first_sample"
|
|
else:
|
|
dt = (now - self._previous["time"]).total_seconds()
|
|
# Do not fit across a relay change, a provider/fallback switch or an
|
|
# uncertain lag estimate (restart, relay outage, several changes).
|
|
if not 270 <= dt <= 330:
|
|
status["sample_result"] = "interval_out_of_range"
|
|
elif not steady or heater_on != self._previous["heater_on"]:
|
|
status["sample_result"] = "relay_changed"
|
|
elif self._previous["outside_source"] != active_sources["temperature"]:
|
|
status["sample_result"] = "outside_source_changed"
|
|
elif self._lag["uncertainty"] > LAG_LEARN_MAX_UNCERTAINTY:
|
|
status["sample_result"] = "lag_uncertain"
|
|
else:
|
|
# Window open, unknown or recovering: not envelope loss; keep it out of
|
|
# the closed-window models and give it to the ventilation model.
|
|
vented = [room for room in pairs if (vent_inputs.get(room) or {}).get("affected")]
|
|
clean = [room for room in pairs if room not in vented]
|
|
accepted = [
|
|
self.learners[room].learn(
|
|
self._previous["temps"][room], vals[room],
|
|
self._previous["outside"], self._lag["lag"], dt, heater_on)
|
|
for room in clean
|
|
]
|
|
before = {"outside": self._previous["outside"], "lag": self._lag["lag"],
|
|
"temps": self._previous["temps"]}
|
|
for room in pairs:
|
|
start = self._previous["temps"][room]
|
|
change = (vals[room] - start) * 300 / dt
|
|
inputs = {**before, "internal": internal[room]}
|
|
if room in clean:
|
|
# Extended models learn the same interval when all their inputs are known.
|
|
model = self.extended.get(room)
|
|
x = model and feature_vector(model.features, start, inputs)
|
|
if x:
|
|
model.learn(x, change, heater_on)
|
|
continue
|
|
model = self.ventilation.get(room)
|
|
x = model and ventilation_vector(model.features, start, before["outside"], vent_inputs[room])
|
|
if x:
|
|
main = ZoneModel(self.learners[room], self.extended.get(room)).main_delta(start, inputs)
|
|
model.learn(x, change - main, heater_on)
|
|
if clean:
|
|
status["sample_result"] = "learned" if all(accepted) else "partly_rejected"
|
|
self._update_counts()
|
|
else:
|
|
status["sample_result"] = "ventilation"
|
|
learned = True
|
|
|
|
self._count_result(status, status["sample_result"])
|
|
self._previous = {
|
|
"time": now, "temps": vals, "outside": outside, "heater_on": heater_on,
|
|
"outside_source": active_sources["temperature"], "compositions": compositions,
|
|
}
|
|
# Parameters after this poll's learning: forecasts from here use only data so far.
|
|
self._evaluator.observe(
|
|
now, vals, outside, self._lag["lag"], self._lag["uncertainty"],
|
|
{room: tuple(self.learners[room].theta) for room in vals},
|
|
models={room: model_snapshot(ZoneModel(self.learners[room], self.extended.get(room),
|
|
self.ventilation.get(room))) for room in vals},
|
|
inputs={room: {"internal": internal[room], "ventilation": vent_inputs.get(room)} for room in vals})
|
|
status["forecast_accuracy"] = self._evaluator.summary(self.rooms)
|
|
if learned:
|
|
# Persist at each sample so restart does not erase hours of training.
|
|
await self._store.async_save({
|
|
"schema_version": 2,
|
|
"learners": {room: learner.as_dict() for room, learner in self.learners.items()},
|
|
# Optional keys; older 0.2.x readers ignore them and keep working.
|
|
"retired_learners": self._retired,
|
|
"zone_models": {key: model.as_dict() for key, model in self.extended.items()},
|
|
"heat_sources": self._heat_sources.as_dict(),
|
|
"ventilation_models": {key: model.as_dict() for key, model in self.ventilation.items()},
|
|
"ventilation": self._ventilation.as_dict(),
|
|
"evaluation": self._evaluator.as_dict(),
|
|
"on_samples": self._on_samples, "off_samples": self._off_samples,
|
|
"heater_entity": self.config[CONF_HEATER],
|
|
"outside_source": active_sources["temperature"],
|
|
})
|
|
# Comfort weights are validated when zones are parsed (invalid -> 1.0).
|
|
weights = {r: self.zones[r].comfort_weight for r in self.rooms}
|
|
# Left-out zones take their weight with them; the rest are re-normalized.
|
|
used_weights = {room: weights[room] for room in vals}
|
|
weighted_temp = sum(used_weights[r] * vals[r] for r in vals) / sum(used_weights.values())
|
|
status.update({
|
|
"weighted_temperature": round(weighted_temp, 3),
|
|
"weight_coverage": round(sum(used_weights.values()) / sum(weights.values()), 3),
|
|
"outside_temperature": outside,
|
|
"reference_heat": heater_on,
|
|
"on_samples": self._on_samples,
|
|
"off_samples": self._off_samples,
|
|
"samples": min(learner.count for learner in self.learners.values()),
|
|
"models": {
|
|
room: {"name": self.zones[room].name,
|
|
"loss": round(model.theta[0], 6),
|
|
"heat": round(model.theta[1], 6),
|
|
"bias": round(model.theta[2], 6),
|
|
"samples": model.count,
|
|
"on_samples": model.on_count, "off_samples": model.off_count,
|
|
"rejected_samples": model.rejected_count,
|
|
"mae_5m": round(model.mae, 4) if model.mae is not None else None,
|
|
**self._extended_diagnostics(room)}
|
|
for room, model in self.learners.items()
|
|
},
|
|
})
|
|
status["zone_details"] = self._zone_details(vals, outside, internal, vent_inputs)
|
|
if climate.state != "heat":
|
|
status["status"] = "paused"
|
|
return status
|
|
try:
|
|
target = normalize("temperature", climate.attributes["temperature"],
|
|
climate.attributes.get("temperature_unit",
|
|
self.hass.config.units.temperature_unit))
|
|
if target is None or not 5 <= target <= 35:
|
|
raise ValueError
|
|
except (TypeError, KeyError, ValueError):
|
|
status["status"] = "waiting_for_target"
|
|
return status
|
|
status["target"] = target
|
|
# Do not act on a cold model: every room used needs ~17 hours of samples
|
|
# plus both relay conditions.
|
|
used_models = [self.learners[room] for room in vals]
|
|
if (min(m.count for m in used_models) < READY_SAMPLES
|
|
or min(m.on_count for m in used_models) < READY_ON_SAMPLES
|
|
or min(m.off_count for m in used_models) < READY_OFF_SAMPLES):
|
|
status["status"] = "learning"
|
|
return status
|
|
try:
|
|
# 180-minute exhaustive search can take several seconds on RPi5;
|
|
# never block Home Assistant's event loop with CPU work.
|
|
job = partial(
|
|
optimize,
|
|
vals, outside, self._lag["lag"], target, used_weights,
|
|
{room: self.learners[room] for room in vals},
|
|
heater_on, (now - heater.last_changed).total_seconds(),
|
|
horizon_minutes=int(self.config[CONF_HORIZON]),
|
|
minimum_on_minutes=int(self.config[CONF_MIN_ON]),
|
|
minimum_off_minutes=int(self.config[CONF_MIN_OFF]),
|
|
switching_cost=float(self.config[CONF_SWITCH_COST]),
|
|
heating_cost=float(self.config[CONF_HEAT_COST]),
|
|
comfort_band=float(self.config[CONF_BAND]),
|
|
target_offsets={room: self.zones[room].target_offset for room in vals},
|
|
step_model=self._step_model(vals, outside, int(self.config[CONF_HORIZON]),
|
|
weather, now.timestamp()),
|
|
)
|
|
# Discard a result if a value used by the prediction changed while
|
|
# saving or while the worker calculated the hypothetical plan. Optional
|
|
# diagnostic weather sensors are not prediction inputs.
|
|
output = await self.hass.async_add_executor_job(job)
|
|
if self._prediction_inputs() != inputs_before:
|
|
status["status"] = "inputs_changed"
|
|
return status
|
|
except (ValueError, RuntimeError, OverflowError) as err:
|
|
_LOGGER.warning("MPC prediction failed: %s", err)
|
|
status["status"] = "prediction_error"
|
|
return status
|
|
status.update({
|
|
"status": "ready", "proposal": output["proposal"],
|
|
"prediction_60m": output["predicted_60m"],
|
|
"prediction_end": output["predicted_end"],
|
|
"plan_15min": output["plan_15min"], "objective": output["cost"],
|
|
"prediction_trajectory": output["trajectory_15min"],
|
|
"model_quality_note": "5-minute in-sample MAE; not a validated 60-minute forecast error",
|
|
})
|
|
return status
|