Add Flask ML service (app, predictor, thingsboard client)

ml_service/app.py

@@ -0,0 +1,1756 @@
+import json
+import os
+import tempfile
+import zipfile
+from datetime import datetime, timezone
+from collections import deque
+from pathlib import Path
+from threading import Lock
+
+from dotenv import load_dotenv
+import numpy as np
+import requests
+from flask import Flask, jsonify, request
+from flask_cors import CORS
+
+# Load environment variables from the repository root .env file if available.
+ROOT_DIR = Path(__file__).resolve().parent.parent
+load_dotenv(ROOT_DIR / ".env")
+
+
+def _normalize_model_dir(value: str | None) -> str:
+  if not value:
+    return "src/nilm_models_v9"
+  normalized = value.strip()
+  if normalized.startswith("@file:"):
+    normalized = normalized[len("@file:"):]
+  if normalized.startswith("file://"):
+    normalized = normalized[len("file://"):]
+  if normalized.startswith("file:"):
+    normalized = normalized[len("file:"):]
+  return normalized
+
+_model_dir = Path(_normalize_model_dir(os.environ.get("NILM_MODEL_DIR")))
+MODEL_DIR = _model_dir if _model_dir.is_absolute() else (ROOT_DIR / _model_dir)
+MODEL_DIR = MODEL_DIR.resolve()
+_DUMMY_FILE = Path(__file__).resolve().parent / "dummy_blynk_samples.json"
+_MODEL_TEXT_FILES = ("config.json", "metadata.json", "labels.json", "meta_nilm.json")
+_MODEL_BINARY_FILES = ("model.weights.h5",)
+_NOTEBOOK_GLOB = "*.ipynb"
+_MODEL_ARCHIVE_GLOB = "*.keras"
+
+app = Flask(__name__)
+_cors_raw = os.environ.get("CORS_ORIGINS", "*").strip()
+_cors_origins = (
+  [origin.strip() for origin in _cors_raw.split(",") if origin.strip()]
+  if _cors_raw and _cors_raw != "*"
+  else "*"
+)
+CORS(
+  app,
+  resources={r"/*": {"origins": _cors_origins}},
+  supports_credentials=False,
+  methods=["GET", "POST", "OPTIONS"],
+  allow_headers=["Content-Type", "Accept"],
+)
+
+_MODEL = None
+_LABELS_CACHE = None
+_LABEL_SOURCE_CACHE = None
+_LABELS_CACHE_KEY = None
+_MODEL_META_CACHE = None
+_EMA_PROBS = None
+_PRED_QUEUE = deque(maxlen=5)
+_PRED_DEVICE_QUEUE = deque(maxlen=5)
+_PREV_POWER = None
+_LATEST_RESULT = None
+_REQUEST_COUNT = 0
+_SEQ_BUFFER = deque(maxlen=99)
+_LAST_RAW_SAMPLE = None
+_LOCK = Lock()
+_V9_PREDICTOR = None
+_V9_PREDICTOR_KEY: tuple[str, int, int] | None = None
+
+
+def _get_v9_predictor():
+  global _V9_PREDICTOR, _V9_PREDICTOR_KEY
+  meta_path = MODEL_DIR / "meta_nilm.json"
+  keras_path = MODEL_DIR / "best_nilm_model.keras"
+  cache_key = None
+  if meta_path.exists() and keras_path.exists():
+    meta_stat = meta_path.stat()
+    keras_stat = keras_path.stat()
+    cache_key = (
+      str(MODEL_DIR),
+      meta_stat.st_mtime_ns,
+      keras_stat.st_size,
+    )
+
+  if _V9_PREDICTOR is None or _V9_PREDICTOR_KEY != cache_key:
+    from nilm_v9_predictor import NilmV9Predictor
+
+    _V9_PREDICTOR = NilmV9Predictor(MODEL_DIR)
+    _V9_PREDICTOR_KEY = cache_key
+  return _V9_PREDICTOR
+
+
+def _predictor_to_response(pred: dict, sample: dict):
+  meta = _read_model_meta()
+  if _LABEL_SOURCE_CACHE is None:
+    _load_labels()
+  label_source = _LABEL_SOURCE_CACHE or "meta_nilm.json:devices"
+
+  input_shape = meta.get("input_shape") or [30, 8]
+  seq_len = int(input_shape[0]) if input_shape else 30
+  received_len = int(pred.get("buffer_fill") or 0)
+  raw_status = str(pred.get("buffer_status") or "").lower()
+
+  if raw_status == "warming":
+    buffer_status = "WARMING"
+  elif raw_status == "ready":
+    buffer_status = "READY"
+  elif received_len < max(10, seq_len // 3):
+    buffer_status = "WARMING"
+  elif received_len < seq_len:
+    buffer_status = "LOADING"
+  else:
+    buffer_status = "READY"
+
+  label = str(pred.get("label") or "idle")
+  if label == "filling_buffer":
+    label = "idle"
+
+  active_devices = list(pred.get("active_devices") or [])
+  prob_map = {device: float(probability) for device, probability in pred.get("probs") or []}
+  devices = meta.get("devices") or _load_labels()
+  device_probs = [
+    {"device": device, "probability": round(prob_map.get(device, 0.0) * 100.0, 1)}
+    for device in devices
+    if isinstance(device, str)
+  ]
+
+  predictor_confidence = pred.get("confidence")
+  if isinstance(predictor_confidence, (int, float)):
+    chosen_confidence = float(predictor_confidence)
+  elif active_devices:
+    active_probs = [prob_map.get(device, 0.0) for device in active_devices]
+    max_prob = max(active_probs) if active_probs else 0.0
+    min_prob = min(active_probs) if active_probs else 0.0
+    chosen_confidence = (0.3 * min_prob + 0.7 * max_prob) * 100.0
+  else:
+    chosen_confidence = max(0.0, 1.0 - max(prob_map.values(), default=0.0)) * 100.0
+
+  return {
+    "success": True,
+    "label": label,
+    "confidence": round(chosen_confidence, 1),
+    "index": 0,
+    "model_version": pred.get("model_version") or meta.get("model_name") or "unknown_model",
+    "label_source": label_source,
+    "timestamp": _now_iso(),
+    "problem_type": meta.get("problem_type") or "multilabel",
+    "active_devices": active_devices,
+    "device_probs": device_probs,
+    "buffer": {
+      "received": received_len,
+      "window": seq_len,
+      "status": buffer_status,
+      "bar": _format_buffer_bar(received_len, seq_len),
+    },
+    "raw_top": {
+      "label": label,
+      "confidence": round(chosen_confidence, 1),
+      "index": 0,
+    },
+    "raw_second": {
+      "label": label,
+      "confidence": round(chosen_confidence, 1),
+      "index": 0,
+    },
+  }
+
+
+def _read_json(path: Path):
+  return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _read_text(path: Path):
+  return path.read_text(encoding="utf-8")
+
+
+def _sanitize_keras_config(value):
+  if isinstance(value, dict):
+    return {
+      key: _sanitize_keras_config(item)
+      for key, item in value.items()
+      if key not in {"quantization_config"}
+    }
+  if isinstance(value, list):
+    return [_sanitize_keras_config(item) for item in value]
+  return value
+
+
+def _get_custom_objects(tf):
+  try:
+    register = tf.keras.saving.register_keras_serializable(package="nilm_v9")
+  except AttributeError:
+    try:
+      register = tf.keras.utils.register_keras_serializable(package="nilm_v9")
+    except AttributeError:
+      register = lambda cls: cls
+
+  @register
+  class TemporalSum(tf.keras.layers.Layer):
+    def call(self, inputs):
+      return tf.reduce_sum(inputs, axis=1)
+
+    def get_config(self):
+      return super().get_config()
+
+  def weighted_bce(y_true, y_pred):
+    return tf.reduce_mean(tf.keras.losses.binary_crossentropy(y_true, y_pred))
+
+  def exact_match(y_true, y_pred):
+    pred_bin = tf.cast(y_pred >= 0.5, tf.float32)
+    match = tf.reduce_all(tf.equal(pred_bin, y_true), axis=1)
+    return tf.reduce_mean(tf.cast(match, tf.float32))
+
+  return {
+    "TemporalSum": TemporalSum,
+    "weighted_bce": weighted_bce,
+    "exact_match": exact_match,
+  }
+
+
+def _load_model_from_archive(keras_file: Path, tf, custom_objects):
+  with zipfile.ZipFile(keras_file) as archive:
+    sanitized_config = _sanitize_keras_config(json.loads(archive.read("config.json").decode("utf-8")))
+    weights_bytes = archive.read("model.weights.h5")
+
+  with tempfile.TemporaryDirectory() as temp_dir:
+    weights_path = Path(temp_dir) / "model.weights.h5"
+    weights_path.write_bytes(weights_bytes)
+
+    model = tf.keras.models.model_from_json(json.dumps(sanitized_config), custom_objects=custom_objects)
+    model.load_weights(str(weights_path))
+    return model
+
+
+def _load_model_from_files(root: Path, tf, custom_objects):
+  config_path = root / "config.json"
+  weights_path = root / "model.weights.h5"
+  sanitized_config = _sanitize_keras_config(_read_json(config_path))
+  model = tf.keras.models.model_from_json(json.dumps(sanitized_config), custom_objects=custom_objects)
+  model.load_weights(str(weights_path))
+  return model
+
+
+def _model_root() -> Path:
+  return MODEL_DIR if MODEL_DIR.is_dir() else MODEL_DIR.parent
+
+
+def _find_keras_file() -> Path | None:
+  if MODEL_DIR.is_file() and MODEL_DIR.suffix == ".keras":
+    return MODEL_DIR
+
+  if MODEL_DIR.is_dir():
+    preferred = MODEL_DIR / "best_nilm_model.keras"
+    if preferred.exists():
+      return preferred
+
+    candidates = sorted(MODEL_DIR.glob(_MODEL_ARCHIVE_GLOB))
+    if candidates:
+      return candidates[0]
+
+  return None
+
+
+def _get_model_files():
+  root = _model_root()
+  files = []
+  for name in (*_MODEL_TEXT_FILES, *_MODEL_BINARY_FILES):
+    path = root / name
+    files.append(
+      {
+        "name": name,
+        "exists": path.exists(),
+        "size_bytes": path.stat().st_size if path.exists() else None,
+        "type": "text" if name in _MODEL_TEXT_FILES else "binary",
+      }
+    )
+
+  keras_file = _find_keras_file()
+  if keras_file is not None:
+    files.append(
+      {
+        "name": keras_file.name,
+        "exists": True,
+        "size_bytes": keras_file.stat().st_size,
+        "type": "binary",
+      }
+    )
+  return files
+
+
+def _resolve_model_file(name: str):
+  normalized = Path(name).name
+  allowed_files = set(_MODEL_TEXT_FILES) | set(_MODEL_BINARY_FILES)
+  keras_file = _find_keras_file()
+  if keras_file is not None:
+    allowed_files.add(keras_file.name)
+
+  if normalized not in allowed_files:
+    raise ValueError("File tidak diizinkan. Gunakan config.json, metadata.json, labels.json, meta_nilm.json, model.weights.h5, atau file .keras model")
+
+  root = _model_root()
+  if normalized == keras_file.name if keras_file is not None else False:
+    return keras_file
+
+  return root / normalized
+
+
+def _extract_notebook_classes():
+  candidates = sorted(MODEL_DIR.glob(_NOTEBOOK_GLOB))
+  for notebook_path in candidates:
+    try:
+      notebook = _read_json(notebook_path)
+    except Exception:
+      continue
+
+    for cell in notebook.get("cells", []):
+      for line in cell.get("source", []):
+        if "\"classes\":" in line.lower():
+          try:
+            snippet = line[line.index("{"):]
+            payload = json.loads(snippet)
+            classes = payload.get("classes")
+            if isinstance(classes, list) and all(isinstance(item, str) for item in classes):
+              return [item.strip() for item in classes if item.strip()], notebook_path.name
+          except Exception:
+            continue
+    for cell in notebook.get("cells", []):
+      source = "".join(cell.get("source", []))
+      marker = "CLASSES = ["
+      if marker not in source:
+        continue
+      try:
+        start = source.index(marker) + len(marker)
+        end = source.index("]", start)
+        raw_items = source[start:end].splitlines()
+        classes = [item.strip().strip(",").strip("'\"") for item in raw_items]
+        classes = [item for item in classes if item]
+        if classes:
+          return classes, notebook_path.name
+      except Exception:
+        continue
+  return None, None
+
+
+def _read_model_meta():
+  global _MODEL_META_CACHE
+  if _MODEL_META_CACHE is not None:
+    return _MODEL_META_CACHE
+
+  root = _model_root()
+  meta_path = root / "meta_nilm.json"
+  if not meta_path.exists():
+    meta_path = root / "metadata.json"
+
+  if meta_path.exists():
+    meta = _read_json(meta_path)
+    model_name = meta.get("model_version") or "unknown_model"
+    input_shape = []
+    if isinstance(meta.get("window_size"), int) and isinstance(meta.get("n_features"), int):
+      input_shape = [meta["window_size"], meta["n_features"]]
+
+    devices = meta.get("devices")
+    has_device_list = isinstance(devices, list) and all(isinstance(item, str) for item in devices)
+    problem_type = "multilabel" if has_device_list else "multiclass"
+    output_units = meta.get("n_classes")
+    if not isinstance(output_units, int) or output_units <= 0:
+      if problem_type == "multilabel" and isinstance(meta.get("n_devices"), int) and meta["n_devices"] > 0:
+        output_units = meta["n_devices"]
+      elif isinstance(meta.get("classes"), list):
+        output_units = len([item for item in meta["classes"] if isinstance(item, str) and item.strip()])
+      else:
+        session_to_label = meta.get("session_to_label")
+        if isinstance(session_to_label, dict):
+          output_units = len(session_to_label)
+
+    if has_device_list:
+      devices = [item.strip() for item in devices if isinstance(item, str) and item.strip()]
+    else:
+      devices = None
+
+    _MODEL_META_CACHE = {
+      "model_name": model_name,
+      "input_shape": input_shape,
+      "output_units": output_units,
+      "problem_type": problem_type,
+      "devices": devices,
+      "threshold": meta.get("threshold"),
+      "device_thresholds": meta.get("device_thresholds"),
+      "smooth_n": meta.get("smooth_n"),
+      "session_to_label": meta.get("session_to_label"),
+      "scaler_mean": meta.get("scaler_mean"),
+      "scaler_scale": meta.get("scaler_scale"),
+      "noise_floor_w": meta.get("noise_floor_w"),
+      "transition_delta": meta.get("transition_delta"),
+      "conf_thresh": meta.get("conf_thresh"),
+      "power_range": meta.get("power_range"),
+      "device_display": meta.get("device_display"),
+      "feature_cols": meta.get("feature_cols"),
+    }
+    return _MODEL_META_CACHE
+
+  config = _read_json(root / "config.json")
+  layers = config.get("config", {}).get("layers", [])
+  input_layer = next((layer for layer in layers if layer.get("class_name") == "InputLayer"), None)
+  output_layer = next(
+    (
+      layer
+      for layer in reversed(layers)
+      if layer.get("class_name") == "Dense" and layer.get("config", {}).get("activation") == "softmax"
+    ),
+    None,
+  )
+
+  input_shape = (input_layer or {}).get("config", {}).get("batch_shape") or []
+  input_shape = [value for value in input_shape if isinstance(value, int)]
+  output_units = (output_layer or {}).get("config", {}).get("units")
+  model_name = config.get("config", {}).get("name") or "unknown_model"
+
+  _MODEL_META_CACHE = {
+    "model_name": model_name,
+    "input_shape": input_shape,
+    "output_units": output_units,
+    "problem_type": "multiclass",
+  }
+  return _MODEL_META_CACHE
+
+
+def _load_labels():
+  global _LABELS_CACHE, _LABEL_SOURCE_CACHE, _LABELS_CACHE_KEY
+  root = _model_root()
+  labels_path = root / "labels.json"
+  meta_path = root / "meta_nilm.json"
+  cache_key = None
+
+  if meta_path.exists():
+    stat = meta_path.stat()
+    cache_key = (str(meta_path), stat.st_mtime_ns, stat.st_size)
+  elif labels_path.exists():
+    stat = labels_path.stat()
+    cache_key = (str(labels_path), stat.st_mtime_ns, stat.st_size)
+
+  if _LABELS_CACHE is not None and _LABELS_CACHE_KEY == cache_key:
+    return _LABELS_CACHE
+
+  _LABELS_CACHE = None
+  _LABEL_SOURCE_CACHE = None
+  _LABELS_CACHE_KEY = cache_key
+  meta = _read_model_meta()
+  output_units = meta.get("output_units")
+
+  if meta_path.exists():
+    meta = _read_json(meta_path)
+    devices = meta.get("devices")
+    classes = meta.get("classes")
+    labels = []
+
+    if isinstance(devices, list) and all(isinstance(item, str) for item in devices):
+      labels = [item.strip() for item in devices if item.strip()]
+      _LABEL_SOURCE_CACHE = "meta_nilm.json:devices"
+    elif classes is None:
+      session_to_label = meta.get("session_to_label")
+      if isinstance(session_to_label, dict):
+        seen = set()
+        for label in session_to_label.values():
+          if isinstance(label, str):
+            label = label.strip()
+            if label and label not in seen:
+              seen.add(label)
+              labels.append(label)
+      else:
+        raise ValueError("meta_nilm.json invalid: field 'classes' harus array string, field 'devices' harus array string, atau field 'session_to_label' harus object string")
+      _LABEL_SOURCE_CACHE = "meta_nilm.json:session_to_label"
+    else:
+      if not isinstance(classes, list) or not all(isinstance(item, str) for item in classes):
+        raise ValueError("meta_nilm.json invalid: field 'classes' harus array string")
+      labels = [item.strip() for item in classes if item.strip()]
+      _LABEL_SOURCE_CACHE = "meta_nilm.json:classes"
+
+    if isinstance(output_units, int) and output_units > 0 and len(labels) != output_units:
+      raise ValueError(f"Jumlah label runtime ({len(labels)}) tidak cocok dengan output model ({output_units})")
+  elif labels_path.exists():
+    configured_labels = _read_json(labels_path).get("labels", [])
+    if not isinstance(configured_labels, list) or not all(isinstance(item, str) for item in configured_labels):
+      raise ValueError("labels.json invalid: field 'labels' harus array string")
+
+    labels = [item.strip() for item in configured_labels if isinstance(item, str) and item.strip()]
+
+    if isinstance(output_units, int) and output_units > 0:
+      if len(labels) > output_units:
+        raise ValueError(f"labels.json tidak boleh melebihi {output_units} label, sekarang {len(labels)}")
+      if len(labels) < output_units:
+        labels.extend(f"unknown_{index}" for index in range(len(labels), output_units))
+    _LABEL_SOURCE_CACHE = "labels.json"
+  else:
+    notebook_labels, notebook_name = _extract_notebook_classes()
+    if (
+      isinstance(output_units, int)
+      and output_units > 0
+      and isinstance(notebook_labels, list)
+      and len(notebook_labels) == output_units
+    ):
+      labels = notebook_labels
+      _LABEL_SOURCE_CACHE = f"notebook:{notebook_name}"
+    elif isinstance(output_units, int) and output_units > 0:
+      labels = [f"unknown_{index}" for index in range(output_units)]
+      _LABEL_SOURCE_CACHE = "generated"
+    else:
+      raise ValueError("labels.json tidak ditemukan dan output_units model tidak dapat dibaca")
+
+  labels = [item.strip() for item in labels if isinstance(item, str) and item.strip()]
+  _LABELS_CACHE = labels
+  return _LABELS_CACHE
+
+
+def _get_label_source():
+  if _LABEL_SOURCE_CACHE is None:
+    _load_labels()
+  return _LABEL_SOURCE_CACHE
+
+
+def _ensure_runtime_state():
+  global _SEQ_BUFFER, _PRED_QUEUE, _PRED_DEVICE_QUEUE
+  meta = _read_model_meta()
+  input_shape = meta.get("input_shape") or []
+  seq_len = int(input_shape[0]) if len(input_shape) >= 2 and isinstance(input_shape[0], int) else 99
+  smooth_n = int(meta.get("smooth_n") or 5)
+  smooth_n = max(1, smooth_n)
+
+  if _SEQ_BUFFER.maxlen != seq_len:
+    _SEQ_BUFFER = deque(list(_SEQ_BUFFER)[-seq_len:], maxlen=seq_len)
+
+  if _PRED_QUEUE.maxlen != smooth_n:
+    _PRED_QUEUE = deque(list(_PRED_QUEUE)[-smooth_n:], maxlen=smooth_n)
+
+  if _PRED_DEVICE_QUEUE.maxlen != smooth_n:
+    _PRED_DEVICE_QUEUE = deque(list(_PRED_DEVICE_QUEUE)[-smooth_n:], maxlen=smooth_n)
+
+
+def _label_to_device_key(label: str, devices: list[str]):
+  if not isinstance(label, str):
+    return None
+
+  normalized = label.strip()
+  if not normalized:
+    return None
+  if normalized == "idle":
+    return frozenset()
+  if normalized == "full_load" and devices:
+    return frozenset(devices)
+
+  parts = [item.strip() for item in normalized.split("+") if item.strip()]
+  return frozenset(parts) if parts else frozenset()
+
+
+def _active_devices_from_label(label: str, devices: list[str]):
+  key = _label_to_device_key(label, devices)
+  if key is None:
+    return []
+
+  device_set = set(devices)
+  return [device for device in devices if device in key and device in device_set]
+
+
+def _join_active_devices(active_labels, devices: list[str]):
+  if not isinstance(active_labels, (list, tuple, set)):
+    return "idle"
+
+  active_set = {item.strip() for item in active_labels if isinstance(item, str) and item.strip()}
+  ordered = [device for device in devices if device in active_set]
+  return "+".join(ordered) if ordered else "idle"
+
+
+def _resolve_multilabel_label(active_labels, meta: dict):
+  devices = meta.get("devices")
+  if not isinstance(devices, list):
+    devices = []
+
+  lookup = _multilabel_name_lookup(meta)
+  active_set = frozenset(
+    item.strip()
+    for item in (active_labels or [])
+    if isinstance(item, str) and item.strip() and item.strip() in devices
+  )
+  if active_set in lookup:
+    return lookup[active_set]
+
+  joined = _join_active_devices(active_labels, devices)
+  key = _label_to_device_key(joined, devices)
+  if key is not None and key in lookup:
+    return lookup[key]
+
+  return joined if joined else "idle"
+
+
+def _multilabel_name_lookup(meta: dict):
+  devices = meta.get("devices")
+  if not isinstance(devices, list):
+    return {frozenset(): "idle"}
+
+  lookup = {frozenset(): "idle"}
+  session_to_label = meta.get("session_to_label")
+  if isinstance(session_to_label, dict):
+    for label in session_to_label.values():
+      key = _label_to_device_key(label, devices)
+      if key is not None and key not in lookup:
+        lookup[key] = label.strip()
+  return lookup
+
+
+def _get_model():
+  global _MODEL
+  if _MODEL is not None:
+    return _MODEL
+
+  try:
+    import tensorflow as tf
+  except Exception as exc:
+    raise RuntimeError(f"TensorFlow/Keras tidak tersedia: {exc}") from exc
+
+  custom_objects = _get_custom_objects(tf)
+
+  model_source = MODEL_DIR
+  keras_file = _find_keras_file()
+  if keras_file is not None:
+    model_source = keras_file
+
+  try:
+    if keras_file is not None:
+      _MODEL = tf.keras.models.load_model(
+        str(model_source),
+        custom_objects=custom_objects,
+        compile=False,
+        safe_mode=False,
+      )
+    else:
+      _MODEL = _load_model_from_files(_model_root(), tf, custom_objects)
+  except Exception as exc:
+    root = _model_root()
+    config_path = root / "config.json"
+    weights_path = root / "model.weights.h5"
+
+    try:
+      if keras_file is not None:
+        _MODEL = _load_model_from_archive(keras_file, tf, custom_objects)
+      elif config_path.exists() and weights_path.exists():
+        _MODEL = _load_model_from_files(root, tf, custom_objects)
+      else:
+        raise RuntimeError(f"Gagal load model dari {model_source}: {exc}") from exc
+    except Exception as rebuild_exc:
+      raise RuntimeError(f"Gagal load model dari {model_source}: {rebuild_exc}") from rebuild_exc
+
+  return _MODEL
+
+
+def _now_iso():
+  return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def _blynk_update(pin: str, value: str | float | int):
+  token = (os.environ.get("BLYNK_AUTH_TOKEN") or "").strip()
+  if not token:
+    raise RuntimeError("BLYNK_AUTH_TOKEN belum di-set di environment")
+
+  base = (os.environ.get("BLYNK_BASE_URL") or "https://blynk.cloud/external/api").rstrip("/")
+  url = f"{base}/update"
+  response = requests.get(url, params={"token": token, pin: value}, timeout=10)
+  if response.status_code != 200:
+    raise RuntimeError(f"Blynk update {pin} gagal ({response.status_code}): {response.text}")
+
+
+def _parse_sequence(payload):
+  if not isinstance(payload, dict):
+    raise ValueError("Body JSON harus object")
+
+  sequence = payload.get("sequence")
+  if sequence is None:
+    raise ValueError("Field 'sequence' wajib ada")
+
+  arr = np.array(sequence, dtype=np.float32)
+  received_len = int(arr.shape[0]) if arr.ndim >= 2 else (1 if arr.size else 0)
+  meta = _read_model_meta()
+  input_shape = meta.get("input_shape") or []
+  seq_len = int(input_shape[0]) if len(input_shape) >= 2 and isinstance(input_shape[0], int) else 99
+
+  if arr.size == 0:
+    arr = np.zeros((1, 8), dtype=np.float32)
+    received_len = 0
+
+  if arr.ndim == 1:
+    if arr.size == 8:
+      arr = arr.reshape((1, 8))
+    elif arr.size == seq_len * 8:
+      arr = arr.reshape((seq_len, 8))
+    else:
+      raise ValueError(f"Shape sequence tidak valid: {arr.shape}")
+
+  if arr.ndim != 2 or arr.shape[1] != 8:
+    raise ValueError(f"Shape sequence harus (*, 8), dapat {arr.shape}")
+
+  if arr.shape[0] > seq_len:
+    arr = arr[-seq_len:, :]
+
+  if arr.shape[0] < seq_len:
+    repeat = int(np.ceil(seq_len / arr.shape[0]))
+    arr = np.tile(arr, (repeat, 1))[:seq_len]
+
+  return arr, received_len
+
+
+def _apply_smoothing(probs: np.ndarray, alpha: float):
+  global _EMA_PROBS
+  if _EMA_PROBS is None:
+    _EMA_PROBS = probs.astype(np.float32)
+    return probs
+
+  alpha = float(alpha)
+  alpha = 0.0 if alpha < 0 else 1.0 if alpha > 1 else alpha
+  _EMA_PROBS = (alpha * probs) + ((1.0 - alpha) * _EMA_PROBS)
+  return _EMA_PROBS
+
+
+def _majority_vote_label():
+  if not _PRED_QUEUE:
+    return None
+
+  counts = {}
+  order = {}
+  for index, label in enumerate(_PRED_QUEUE):
+    counts[label] = counts.get(label, 0) + 1
+    if label not in order:
+      order[label] = index
+
+  return max(counts, key=lambda label: (counts[label], -order[label]))
+
+
+def _device_threshold(device: str, meta: dict) -> float:
+  overrides = meta.get("device_thresholds")
+  if isinstance(overrides, dict):
+    value = overrides.get(device)
+    if isinstance(value, (int, float)):
+      return float(value)
+  return float(meta.get("threshold") or 0.5)
+
+
+def _active_devices_from_probs(probs: np.ndarray, labels: list[str], devices: list[str], meta: dict):
+  active = []
+  for device in devices:
+    if device not in labels:
+      continue
+    index = labels.index(device)
+    if float(probs[index]) >= _device_threshold(device, meta):
+      active.append(device)
+  return active
+
+
+def _solo_power_range_fits(device: str, power_w: float, power_range: dict, margin: float = 1.15) -> bool:
+  rng = power_range.get(device)
+  if not isinstance(rng, list) or len(rng) < 2:
+    return False
+  return float(rng[0]) <= power_w <= float(rng[1]) * margin
+
+
+def _best_power_match_label(power_w: float, meta: dict):
+  """Cocokkan daya agregat ke session label terdekat di meta power_range."""
+  power_range = meta.get("power_range") or {}
+  noise_floor = float(meta.get("noise_floor_w") or 3.0)
+  if power_w < noise_floor:
+    return "idle"
+
+  candidates = []
+  for label, rng in power_range.items():
+    if label == "idle" or not isinstance(rng, list) or len(rng) < 2:
+      continue
+    lo, hi = float(rng[0]), float(rng[1]) * 1.15
+    if lo <= power_w <= hi:
+      center = (float(rng[0]) + float(rng[1])) / 2.0
+      candidates.append((abs(power_w - center), label))
+
+  if not candidates:
+    return None
+  candidates.sort(key=lambda item: item[0])
+  return candidates[0][1]
+
+
+def _finalize_multilabel_devices(
+  probs: np.ndarray,
+  labels: list[str],
+  devices: list[str],
+  meta: dict,
+  power_w: float,
+):
+  """
+  Gabungkan output model + sidik jari daya (power_range) agar deteksi selaras training v9.
+  """
+  noise_floor = float(meta.get("noise_floor_w") or 3.0)
+  if power_w < noise_floor:
+    return []
+
+  power_range = meta.get("power_range") or {}
+  model_active = _active_devices_from_probs(probs, labels, devices, meta)
+  power_label = _best_power_match_label(power_w, meta)
+  power_active = _active_devices_from_label(power_label, devices) if power_label not in (None, "idle") else []
+  model_label = _resolve_multilabel_label(model_active, meta)
+  max_prob = float(np.max(probs)) if probs.size else 0.0
+
+  if power_label == "idle":
+    return []
+
+  if model_label == power_label or set(model_active) == set(power_active):
+    return model_active
+
+  if max_prob < 0.52 and power_active:
+    return power_active
+
+  if power_w <= 18 and power_label == "charger_hp":
+    return power_active or ["charger_hp"]
+
+  if power_w >= 195 and "hair_dryer" not in (power_label or ""):
+    model_active = [d for d in model_active if d != "hair_dryer"]
+
+  if power_w < 45 and power_active:
+    without_high = [d for d in model_active if d not in ("hair_dryer", "laptop")]
+    if not without_high or max_prob < 0.55:
+      return power_active
+
+  pruned = []
+  for device in model_active:
+    if _solo_power_range_fits(device, power_w, power_range):
+      pruned.append(device)
+    elif device == "charger_hp" and power_label and "charger_hp" in power_label:
+      pruned.append(device)
+
+  if pruned:
+    return pruned
+  if power_active:
+    return power_active
+  return model_active
+
+
+def _majority_vote_active_devices(devices: list[str]):
+  if not _PRED_DEVICE_QUEUE:
+    return []
+
+  votes_needed = (len(_PRED_DEVICE_QUEUE) // 2) + 1
+  counts = {device: 0 for device in devices}
+  for pred_set in _PRED_DEVICE_QUEUE:
+    for device in pred_set:
+      if device in counts:
+        counts[device] += 1
+
+  return [device for device in devices if counts[device] >= votes_needed]
+
+
+def _format_buffer_bar(current: int, total: int, width: int = 20):
+  total = max(1, int(total))
+  current = max(0, min(int(current), total))
+  width = max(5, int(width))
+  filled = int(round((current / total) * width))
+  return "[" + ("#" * filled) + ("-" * (width - filled)) + "]"
+
+
+def _as_float(value, default=0.0):
+  try:
+    return float(value)
+  except Exception:
+    return float(default)
+
+
+def _make_json_safe(value):
+  if isinstance(value, dict):
+    return {str(k): _make_json_safe(v) for k, v in value.items()}
+  if isinstance(value, list):
+    return [_make_json_safe(v) for v in value]
+  if isinstance(value, tuple):
+    return tuple(_make_json_safe(v) for v in value)
+  if isinstance(value, np.generic):
+    return value.item()
+  if isinstance(value, (np.ndarray,)):
+    return _make_json_safe(value.tolist())
+  return value
+
+
+def _power_from_sample(sample):
+  if not isinstance(sample, dict):
+    return 0.0
+  return _as_float(sample.get("power", sample.get("P")), 0.0)
+
+
+def _build_feature_vector(sample: dict):
+  v = _as_float(sample.get("voltage", sample.get("V")))
+  i = _as_float(sample.get("current", sample.get("I")))
+  p = _as_float(sample.get("power", sample.get("P")))
+  pf = _as_float(sample.get("power_factor", sample.get("PF")))
+  hz = _as_float(sample.get("frequency", sample.get("Hz")))
+
+  pf = max(0.0, min(pf, 1.0))
+  apparent_power = v * i
+  reactive_power = apparent_power * np.sqrt(max(0.0, 1.0 - (pf ** 2)))
+  power_ratio = p / (apparent_power + 1e-6)
+
+  return np.array(
+    [v, i, p, pf, hz, apparent_power, reactive_power, power_ratio],
+    dtype=np.float32,
+  )
+
+
+def _scale_sequence(sequence: np.ndarray, meta: dict):
+  scaler_mean = meta.get("scaler_mean")
+  scaler_scale = meta.get("scaler_scale")
+  if (
+    isinstance(scaler_mean, list)
+    and isinstance(scaler_scale, list)
+    and len(scaler_mean) == sequence.shape[1]
+    and len(scaler_scale) == sequence.shape[1]
+  ):
+    mean_arr = np.array(scaler_mean, dtype=np.float32)
+    scale_arr = np.array([float(s) if float(s) != 0.0 else 1.0 for s in scaler_scale], dtype=np.float32)
+    return (sequence - mean_arr) / scale_arr
+
+  return sequence
+
+
+def _apparent_power_from_sample(sample):
+  if not isinstance(sample, dict):
+    return 0.0
+  v = _as_float(sample.get("voltage", sample.get("V")))
+  i = _as_float(sample.get("current", sample.get("I")))
+  return v * i
+
+
+def _should_reset_buffer_for_device_change(sample):
+  global _PREV_POWER
+  if not isinstance(sample, dict):
+    return False
+
+  current_power = _power_from_sample(sample)
+  apparent_power = _apparent_power_from_sample(sample)
+  if _PREV_POWER is None:
+    _PREV_POWER = apparent_power
+    return False
+
+  meta = _read_model_meta()
+  transition_delta = float(meta.get("transition_delta") or 30.0)
+  noise_floor_w = float(meta.get("noise_floor_w") or 3.0)
+
+  should_reset = (
+    abs(apparent_power - _PREV_POWER) > transition_delta
+    or (_PREV_POWER <= noise_floor_w and current_power > noise_floor_w)
+    or (_PREV_POWER > noise_floor_w and current_power <= noise_floor_w)
+  )
+  _PREV_POWER = apparent_power
+  return should_reset
+
+
+def _normalize_sample(payload):
+  if not isinstance(payload, dict):
+    raise ValueError("Body JSON harus object")
+
+  for key in ("sample", "telemetry", "data"):
+    candidate = payload.get(key)
+    if isinstance(candidate, dict):
+      return candidate
+
+  if all(key in payload for key in ("voltage", "current", "power")):
+    return payload
+
+  return payload
+
+
+def _sample_to_dict(sample):
+  return {
+    "voltage": _as_float(sample.get("voltage", sample.get("V"))),
+    "current": _as_float(sample.get("current", sample.get("I"))),
+    "power": _as_float(sample.get("power", sample.get("P"))),
+    "energy": _as_float(sample.get("energy", sample.get("E"))),
+    "power_factor": _as_float(sample.get("power_factor", sample.get("PF"))),
+    "frequency": _as_float(sample.get("frequency", sample.get("Hz"))),
+  }
+
+
+def _device_probs_payload(labels, probs, devices=None):
+  order = devices if isinstance(devices, list) and devices else labels
+  label_to_index = {label: index for index, label in enumerate(labels)}
+  payload = []
+
+  for device in order:
+    index = label_to_index.get(device)
+    if index is None:
+      continue
+    payload.append(
+      {
+        "device": device,
+        "probability": round(float(probs[index]) * 100.0, 1),
+      }
+    )
+
+  for index, label in enumerate(labels):
+    if label in order:
+      continue
+    payload.append(
+      {
+        "device": label,
+        "probability": round(float(probs[index]) * 100.0, 1),
+      }
+    )
+
+  return payload
+
+
+def _build_latest_result(sample, response_payload):
+  sample_data = _sample_to_dict(sample)
+  data = {
+    **sample_data,
+    "device_detected": response_payload["label"],
+    "confidence": response_payload["confidence"],
+    "model_version": response_payload["model_version"],
+    "timestamp": response_payload["timestamp"],
+  }
+
+  if response_payload.get("active_devices") is not None:
+    data["active_devices"] = response_payload["active_devices"]
+  if response_payload.get("device_probs") is not None:
+    data["device_probs"] = response_payload["device_probs"]
+
+  buffer = response_payload.get("buffer") or {}
+  if buffer.get("status"):
+    data["buffer_status"] = buffer["status"]
+
+  return {
+    "success": True,
+    "data": data,
+    "meta": {
+      "label_source": response_payload.get("label_source"),
+      "buffer": response_payload.get("buffer"),
+      "raw_top": response_payload.get("raw_top"),
+      "raw_second": response_payload.get("raw_second"),
+      "problem_type": response_payload.get("problem_type"),
+    },
+  }
+
+
+def _min_buffer_len(meta: dict) -> int:
+  input_shape = meta.get("input_shape") or []
+  seq_len = int(input_shape[0]) if len(input_shape) >= 2 and isinstance(input_shape[0], int) else 30
+  return max(10, seq_len // 3)
+
+
+def _build_warming_response(sample, received_len: int = 0):
+  """Response saat buffer belum cukup (selaras dengan nilm_inference.py MIN_BUF)."""
+  meta = _read_model_meta()
+  if _LABEL_SOURCE_CACHE is None:
+    _load_labels()
+  label_source = _LABEL_SOURCE_CACHE or "meta_nilm.json:devices"
+
+  input_shape = meta.get("input_shape") or []
+  seq_len = int(input_shape[0]) if len(input_shape) >= 2 and isinstance(input_shape[0], int) else 30
+  devices = meta.get("devices")
+  if not isinstance(devices, list) or not devices:
+    devices = _load_labels()
+
+  min_buf = _min_buffer_len(meta)
+  confidence = max(5.0, min(25.0, (received_len / max(min_buf, 1)) * 20.0))
+
+  return {
+    "success": True,
+    "label": "idle",
+    "confidence": round(confidence, 1),
+    "index": 0,
+    "model_version": meta.get("model_name") or "unknown_model",
+    "label_source": label_source,
+    "timestamp": _now_iso(),
+    "problem_type": meta.get("problem_type") or "multilabel",
+    "active_devices": [],
+    "device_probs": [
+      {"device": device, "probability": 0.0}
+      for device in devices
+      if isinstance(device, str) and device.strip()
+    ],
+    "buffer": {
+      "received": received_len,
+      "window": seq_len,
+      "status": "WARMING",
+      "bar": _format_buffer_bar(received_len, seq_len),
+    },
+    "raw_top": {"label": "idle", "confidence": round(confidence, 1), "index": 0},
+    "raw_second": {"label": "idle", "confidence": round(confidence, 1), "index": 0},
+  }
+
+
+def _build_idle_response(sample, received_len: int = 0):
+  """Response idle tanpa inferensi model (buffer kosong atau daya di bawah noise floor)."""
+  meta = _read_model_meta()
+  if _LABEL_SOURCE_CACHE is None:
+    _load_labels()
+  label_source = _LABEL_SOURCE_CACHE or "meta_nilm.json:devices"
+
+  input_shape = meta.get("input_shape") or []
+  seq_len = int(input_shape[0]) if len(input_shape) >= 2 and isinstance(input_shape[0], int) else 30
+  devices = meta.get("devices")
+  if not isinstance(devices, list) or not devices:
+    devices = _load_labels()
+
+  power_w = _power_from_sample(sample)
+  noise_floor_w = float(meta.get("noise_floor_w") or 3.0)
+  buffer_status = "READY" if power_w < noise_floor_w else "LOADING"
+  confidence = 96.0 if power_w < noise_floor_w else max(40.0, 90.0 - (received_len / max(seq_len, 1)) * 50.0)
+
+  return {
+    "success": True,
+    "label": "idle",
+    "confidence": round(confidence, 1),
+    "index": 0,
+    "model_version": meta.get("model_name") or "unknown_model",
+    "label_source": label_source,
+    "timestamp": _now_iso(),
+    "problem_type": meta.get("problem_type") or "multilabel",
+    "active_devices": [],
+    "device_probs": [
+      {"device": device, "probability": 0.0}
+      for device in devices
+      if isinstance(device, str) and device.strip()
+    ],
+    "buffer": {
+      "received": received_len,
+      "window": seq_len,
+      "status": buffer_status,
+      "bar": _format_buffer_bar(received_len, seq_len),
+    },
+    "raw_top": {"label": "idle", "confidence": round(confidence, 1), "index": 0},
+    "raw_second": {"label": "idle", "confidence": round(confidence, 1), "index": 0},
+  }
+
+
+def _extract_features_from_sample(sample: dict):
+  global _LAST_RAW_SAMPLE
+  if not isinstance(sample, dict):
+    raise ValueError("sample harus object")
+
+  v = _as_float(sample.get("voltage", sample.get("V")))
+  i = _as_float(sample.get("current", sample.get("I")))
+  p = _as_float(sample.get("power", sample.get("P")))
+  pf = _as_float(sample.get("power_factor", sample.get("PF")))
+  hz = _as_float(sample.get("frequency", sample.get("Hz")))
+
+  # Sinkron dengan final_pipeline (8).ipynb v6:
+  # ['voltage', 'current', 'power', 'power_factor', 'frequency',
+  #  'apparent_power', 'reactive_power', 'power_ratio']
+  pf = max(0.0, min(pf, 1.0))
+  apparent_power = v * i
+  reactive_power = apparent_power * np.sqrt(max(0.0, 1.0 - (pf ** 2)))
+  power_ratio = p / (apparent_power + 1e-6)
+
+  _LAST_RAW_SAMPLE = sample
+  return np.array(
+    [v, i, p, pf, hz, apparent_power, reactive_power, power_ratio],
+    dtype=np.float32,
+  )
+
+
+def _load_dummy_samples():
+  if not _DUMMY_FILE.exists():
+    raise FileNotFoundError(f"Dummy file tidak ditemukan: {_DUMMY_FILE}")
+
+  raw = _DUMMY_FILE.read_text(encoding="utf-8").strip()
+  if not raw:
+    raise ValueError("Dummy file kosong")
+
+  if raw.startswith("["):
+    samples = json.loads(raw)
+  else:
+    samples = [json.loads(line) for line in raw.splitlines() if line.strip()]
+
+  if not isinstance(samples, list) or not samples:
+    raise ValueError("Format dummy harus array JSON atau JSONL (per baris)")
+
+  for item in samples:
+    if not isinstance(item, dict):
+      raise ValueError("Setiap item dummy harus object")
+
+  return samples
+
+
+def _run_samples(samples: list[dict], payload: dict | None):
+  stride = int((payload or {}).get("stride", 1))
+  stride = 1 if stride < 1 else stride
+  update_blynk = bool((payload or {}).get("update_blynk", False))
+
+  with _LOCK:
+    _ensure_runtime_state()
+    _SEQ_BUFFER.clear()
+    global _EMA_PROBS, _LAST_RAW_SAMPLE
+    _EMA_PROBS = None
+    _PRED_QUEUE.clear()
+    _PRED_DEVICE_QUEUE.clear()
+    _LAST_RAW_SAMPLE = None
+
+  timeline = []
+  last = None
+
+  for index, sample in enumerate(samples, start=1):
+    with _LOCK:
+      _ensure_runtime_state()
+      if _should_reset_buffer_for_device_change(sample):
+        _SEQ_BUFFER.clear()
+        _EMA_PROBS = None
+        _PRED_QUEUE.clear()
+        _PRED_DEVICE_QUEUE.clear()
+
+      features = _extract_features_from_sample(sample)
+      _SEQ_BUFFER.append(features.tolist())
+      sequence, received_len = _parse_sequence({"sequence": list(_SEQ_BUFFER)})
+
+    result = _predict_from_sequence(sequence, received_len, payload)
+    last = result
+
+    if update_blynk:
+      meta = _read_model_meta()
+      _blynk_update("V6", result["label"])
+      _blynk_update("V7", result["confidence"])
+      _blynk_update("V8", meta.get("model_name") or "N/A")
+      _blynk_update("V9", _now_iso())
+
+    if index == 1 or index == len(samples) or index % stride == 0:
+      timeline.append(
+        {
+          "step": index,
+          "buffer": result["buffer"],
+          "label": result["label"],
+          "confidence": result["confidence"],
+        },
+      )
+
+  if last is None:
+    raise ValueError("Tidak ada sample untuk diproses")
+
+  return last, timeline
+
+
+def _predict_from_sequence(sequence: np.ndarray, received_len: int, payload: dict | None):
+  global _EMA_PROBS, _REQUEST_COUNT
+  _REQUEST_COUNT += 1
+
+  _ensure_runtime_state()
+  labels = _load_labels()
+  label_source = _get_label_source()
+  model = _get_model()
+  meta = _read_model_meta()
+
+  input_shape = meta.get("input_shape") or []
+  seq_len = int(input_shape[0]) if len(input_shape) >= 2 and isinstance(input_shape[0], int) else 99
+  sequence = _scale_sequence(sequence, meta)
+  probs = model.predict(sequence.reshape((1, seq_len, 8)), verbose=0)
+  probs = np.array(probs).reshape((-1,))
+
+  if probs.size != len(labels):
+    raise RuntimeError(f"Output model {probs.size} tidak cocok dengan labels {len(labels)}")
+
+  smoothing = str((payload or {}).get("smoothing", "ema")).lower()
+  alpha = None
+  if (meta.get("problem_type") or "multiclass") != "multilabel" and smoothing == "ema":
+    alpha = float((payload or {}).get("ema_alpha", 0.6))
+    probs = _apply_smoothing(probs, alpha)
+
+  top_index = int(np.argmax(probs))
+  top_label = labels[top_index]
+  top_confidence = float(probs[top_index]) * 100.0
+
+  sorted_indices = list(np.argsort(-probs))
+  top3_indices = sorted_indices[:3]
+  second_index = int(top3_indices[1]) if len(top3_indices) > 1 else top_index
+  second_label = labels[second_index]
+  second_confidence = float(probs[second_index]) * 100.0
+  third_index = int(top3_indices[2]) if len(top3_indices) > 2 else top_index
+  third_label = labels[third_index]
+  third_confidence = float(probs[third_index]) * 100.0
+
+  problem_type = meta.get("problem_type") or "multiclass"
+  power_w = _power_from_sample(_LAST_RAW_SAMPLE)
+  noise_floor_w = float(meta.get("noise_floor_w") or 3.0)
+  device_probs = _device_probs_payload(labels, probs, meta.get("devices"))
+
+  if power_w < noise_floor_w:
+    buffer_status = "READY" if received_len >= seq_len else "LOADING"
+    buffer_bar = _format_buffer_bar(received_len, seq_len)
+    return {
+      "success": True,
+      "label": "idle",
+      "confidence": round(max(0.0, 1.0 - float(np.max(probs))) * 100.0, 1),
+      "index": top_index,
+      "model_version": meta.get("model_name") or "unknown_model",
+      "label_source": label_source,
+      "timestamp": _now_iso(),
+      "problem_type": problem_type,
+      "active_devices": [],
+      "device_probs": device_probs,
+      "buffer": {
+        "received": received_len,
+        "window": seq_len,
+        "status": buffer_status,
+        "bar": buffer_bar,
+      },
+      "raw_top": {
+        "label": top_label,
+        "confidence": round(top_confidence, 1),
+        "index": top_index,
+      },
+      "raw_second": {
+        "label": second_label,
+        "confidence": round(second_confidence, 1),
+        "index": second_index,
+      },
+    }
+
+  if problem_type == "multilabel":
+    devices = meta.get("devices") or labels
+
+    active_labels = _finalize_multilabel_devices(probs, labels, devices, meta, power_w)
+    raw_label = _resolve_multilabel_label(active_labels, meta)
+
+    _PRED_DEVICE_QUEUE.append(frozenset(active_labels))
+    chosen_active_devices = _majority_vote_active_devices(devices)
+    if not chosen_active_devices and active_labels:
+      chosen_active_devices = active_labels
+    chosen_label = _resolve_multilabel_label(chosen_active_devices, meta)
+    if chosen_active_devices:
+      chosen_indices = [labels.index(device) for device in chosen_active_devices if device in labels]
+      chosen_confidence = float(np.mean([float(probs[index]) for index in chosen_indices])) * 100.0
+    else:
+      chosen_confidence = max(0.0, 1.0 - float(np.max(probs))) * 100.0
+
+    if (
+      chosen_active_devices == ["charger_hp"]
+      and _solo_power_range_fits("charger_hp", power_w, meta.get("power_range") or {})
+      and chosen_confidence < 45.0
+    ):
+      chosen_confidence = max(chosen_confidence, 72.0)
+
+    chosen_index = top_index
+    smoothing = f"device_vote:{_PRED_DEVICE_QUEUE.maxlen}"
+    active_devices = chosen_active_devices
+  else:
+    prefer_non_uncertain = bool((payload or {}).get("prefer_non_uncertain", True))
+    uncertain_label = str((payload or {}).get("uncertain_label", "uncertain"))
+    min_second_confidence = float((payload or {}).get("min_second_confidence", 25.0))
+
+    chosen_index = top_index
+    chosen_label = top_label
+    chosen_confidence = top_confidence
+
+    if prefer_non_uncertain and top_label == uncertain_label and second_label != uncertain_label and second_confidence >= min_second_confidence:
+      chosen_index = second_index
+      chosen_label = second_label
+      chosen_confidence = second_confidence
+
+    power_range = meta.get("power_range") or {}
+    if chosen_label not in ("uncertain", "idle"):
+      label_range = power_range.get(chosen_label)
+      if label_range and not (label_range[0] <= power_w <= label_range[1] * 1.2):
+        for alt_index in top3_indices[1:]:
+          alt_label = labels[alt_index]
+          alt_range = power_range.get(alt_label)
+          alt_confidence = float(probs[alt_index]) * 100.0
+          if alt_range and alt_range[0] <= power_w <= alt_range[1] * 1.2:
+            chosen_index = alt_index
+            chosen_label = alt_label
+            chosen_confidence = alt_confidence
+            break
+
+    active_devices = _active_devices_from_label(chosen_label, labels)
+
+  buffer_status = "READY" if received_len >= seq_len else "LOADING"
+  min_buf = max(10, seq_len // 3)
+  if received_len < min_buf:
+    buffer_status = "WARMING"
+
+  if problem_type != "multilabel":
+    active_devices = _active_devices_from_label(chosen_label, labels)
+  buffer_bar = _format_buffer_bar(received_len, seq_len)
+  print(
+    f"[{_REQUEST_COUNT:05d}] Buffer {received_len}/{seq_len} {buffer_bar} {buffer_status} | "
+    f"Detected {chosen_label} ({chosen_confidence:.1f}%) | "
+    f"Top {top_label} ({top_confidence:.1f}%) | "
+    f"smoothing={smoothing}{'' if alpha is None else f' alpha={alpha:.2f}'}"
+  )
+
+  return {
+    "success": True,
+    "label": chosen_label,
+    "confidence": round(chosen_confidence, 1),
+    "index": chosen_index,
+    "model_version": meta.get("model_name") or "unknown_model",
+    "label_source": label_source,
+    "timestamp": _now_iso(),
+    "problem_type": problem_type,
+    "active_devices": active_devices,
+    "device_probs": device_probs,
+    "buffer": {
+      "received": received_len,
+      "window": seq_len,
+      "status": buffer_status,
+      "bar": buffer_bar,
+    },
+    "raw_top": {
+      "label": top_label,
+      "confidence": round(top_confidence, 1),
+      "index": top_index,
+    },
+    "raw_second": {
+      "label": second_label,
+      "confidence": round(second_confidence, 1),
+      "index": second_index,
+    },
+  }
+
+
+
+@app.get("/health")
+def health():
+  meta = _read_model_meta()
+  return jsonify(
+    {
+      "success": True,
+      "model_dir": str(MODEL_DIR),
+      "model_version": meta.get("model_name"),
+      "problem_type": meta.get("problem_type"),
+      "devices": meta.get("devices"),
+      "files": _get_model_files(),
+    }
+  )
+
+
+@app.get("/")
+def index():
+  return jsonify(
+    {
+      "success": True,
+      "message": "NILM ML service aktif",
+      "model_dir": str(MODEL_DIR),
+      "endpoints": [
+        "/health",
+        "/labels",
+        "/model/files",
+        "/model/files/config.json",
+        "/model/files/metadata.json",
+        "/latest",
+        "/dashboard/latest",
+        "/predict",
+        "/ingest",
+        "/thingsboard/ingest",
+        "/reset",
+        "/demo/dummy",
+      ],
+    }
+  )
+
+
+@app.get("/model/files")
+def model_files():
+  meta = _read_model_meta()
+  return jsonify(
+    {
+      "success": True,
+      "model_dir": str(MODEL_DIR),
+      "model_name": meta.get("model_name"),
+      "files": _get_model_files(),
+    }
+  )
+
+
+@app.get("/model/files/<path:name>")
+def model_file_content(name: str):
+  try:
+    path = _resolve_model_file(name)
+  except ValueError as exc:
+    return jsonify({"success": False, "error": str(exc)}), 400
+
+  if not path.exists():
+    return jsonify({"success": False, "error": f"File tidak ditemukan: {path.name}"}), 404
+
+  if path.name in _MODEL_BINARY_FILES:
+    return jsonify(
+      {
+        "success": True,
+        "name": path.name,
+        "path": str(path),
+        "type": "binary",
+        "size_bytes": path.stat().st_size,
+        "content": None,
+        "note": "File biner tidak ditampilkan, hanya metadata file.",
+      }
+    )
+
+  return jsonify(
+    {
+      "success": True,
+      "name": path.name,
+      "path": str(path),
+      "type": "text",
+      "size_bytes": path.stat().st_size,
+      "content": _read_text(path),
+    }
+  )
+
+@app.get("/labels")
+def labels():
+  meta = _read_model_meta()
+  runtime_labels = _load_labels()
+  label_source = _get_label_source()
+  labels_path = MODEL_DIR / "labels.json"
+  configured_labels = None
+  meta_path = _model_root() / "meta_nilm.json"
+  session_to_label = None
+  device_display = None
+
+  if meta_path.exists():
+    raw_meta = _read_json(meta_path)
+    session_to_label = raw_meta.get("session_to_label")
+    device_display = raw_meta.get("device_display")
+
+  if labels_path.exists():
+    configured_labels = _read_json(labels_path).get("labels", [])
+    if not isinstance(configured_labels, list):
+      configured_labels = []
+
+  visible_labels = [item.strip() for item in (configured_labels or runtime_labels) if isinstance(item, str) and item.strip()]
+  placeholders = [label for label in runtime_labels if label.startswith("unknown_")]
+  return jsonify(
+    {
+      "success": True,
+      "model_dir": str(MODEL_DIR),
+      "model_name": meta.get("model_name"),
+      "output_units": meta.get("output_units"),
+      "problem_type": meta.get("problem_type"),
+      "devices": meta.get("devices"),
+      "labels": visible_labels,
+      "session_to_label": session_to_label,
+      "device_display": device_display,
+      "label_source": label_source,
+      "has_placeholders": len(placeholders) > 0,
+      "placeholders": placeholders,
+      "configured_label_count": len(visible_labels),
+      "runtime_label_count": len(runtime_labels),
+    },
+  )
+
+
+@app.get("/latest")
+def latest():
+  if _LATEST_RESULT is None:
+    return jsonify({"success": False, "error": "Belum ada data telemetry yang masuk ke ML service."}), 404
+  return jsonify(_LATEST_RESULT)
+
+
+@app.get("/dashboard/latest")
+def dashboard_latest():
+  """Pipeline untuk GitHub Pages: ThingsBoard → inferensi → JSON dashboard."""
+  global _LATEST_RESULT
+
+  if str(os.environ.get("USE_DUMMY_BLYNK", "")).lower() in ("1", "true", "yes"):
+    samples = _load_dummy_samples()
+    if not samples:
+      return jsonify({"success": False, "error": "Dummy samples tidak tersedia."}), 503
+    sample = _normalize_sample(samples[-1])
+    source = "dummy"
+  else:
+    try:
+      from thingsboard_client import fetch_thingsboard_sample
+
+      sample = _normalize_sample(fetch_thingsboard_sample())
+      source = "thingsboard"
+    except Exception as exc:
+      return jsonify(
+        {
+          "success": False,
+          "data": None,
+          "source": "thingsboard",
+          "last_updated": _now_iso(),
+          "error": f"ThingsBoard connection error: {exc}",
+        }
+      ), 502
+
+  try:
+    with _LOCK:
+      pred = _get_v9_predictor().predict(sample)
+      response_payload = _predictor_to_response(pred, sample)
+  except Exception as exc:
+    return jsonify(
+      {
+        "success": False,
+        "data": None,
+        "source": source,
+        "last_updated": _now_iso(),
+        "error": f"ML inference error: {exc}",
+      }
+    ), 500
+
+  built = _build_latest_result(sample, response_payload)
+  _LATEST_RESULT = built
+  data = built["data"]
+  return jsonify(
+    {
+      "success": True,
+      "data": data,
+      "source": source,
+      "last_updated": data.get("timestamp") or _now_iso(),
+      "error": None,
+      "meta": built.get("meta"),
+    }
+  )
+
+
+@app.post("/predict")
+def predict():
+  payload = request.get_json(silent=True)
+  sequence, received_len = _parse_sequence(payload)
+  try:
+    response_payload = _predict_from_sequence(sequence, received_len, payload)
+  except Exception as exc:
+    return jsonify({"success": False, "error": str(exc)}), 500
+
+  update_blynk = bool((payload or {}).get("update_blynk", False))
+  blynk_result = None
+  if update_blynk:
+    meta = _read_model_meta()
+    try:
+      _blynk_update("V6", response_payload["label"])
+      _blynk_update("V7", response_payload["confidence"])
+      _blynk_update("V8", meta.get("model_name") or "N/A")
+      _blynk_update("V9", _now_iso())
+      blynk_result = {"updated": True, "pins": ["V6", "V7", "V8", "V9"]}
+    except Exception as exc:
+      blynk_result = {"updated": False, "error": str(exc)}
+
+  response_payload["blynk"] = blynk_result
+  return jsonify(_make_json_safe(response_payload))
+
+
+@app.post("/ingest")
+def ingest():
+  global _LATEST_RESULT
+  payload = request.get_json(silent=True) or {}
+  sample = _normalize_sample(payload)
+
+  try:
+    with _LOCK:
+      pred = _get_v9_predictor().predict(sample)
+      response_payload = _predictor_to_response(pred, sample)
+  except Exception as exc:
+    return jsonify({"success": False, "error": str(exc)}), 500
+
+  update_blynk = bool(payload.get("update_blynk", False))
+  blynk_result = None
+  if update_blynk:
+    meta = _read_model_meta()
+    try:
+      _blynk_update("V6", response_payload["label"])
+      _blynk_update("V7", response_payload["confidence"])
+      _blynk_update("V8", meta.get("model_name") or "N/A")
+      _blynk_update("V9", _now_iso())
+      blynk_result = {"updated": True, "pins": ["V6", "V7", "V8", "V9"]}
+    except Exception as exc:
+      blynk_result = {"updated": False, "error": str(exc)}
+
+  _LATEST_RESULT = _build_latest_result(sample, response_payload)
+  response_payload["blynk"] = blynk_result
+  response_payload["sample"] = _sample_to_dict(sample)
+  return jsonify(_make_json_safe(response_payload))
+
+
+@app.post("/thingsboard/ingest")
+def thingsboard_ingest():
+  return ingest()
+
+
+@app.post("/reset")
+def reset():
+  global _EMA_PROBS, _LAST_RAW_SAMPLE, _PREV_POWER, _LATEST_RESULT, _V9_PREDICTOR
+  with _LOCK:
+    _ensure_runtime_state()
+    _SEQ_BUFFER.clear()
+    _PRED_QUEUE.clear()
+    _PRED_DEVICE_QUEUE.clear()
+    _EMA_PROBS = None
+    _LAST_RAW_SAMPLE = None
+    _PREV_POWER = None
+    _LATEST_RESULT = None
+    if _V9_PREDICTOR is not None:
+      _V9_PREDICTOR.reset()
+  return jsonify({"success": True})
+
+
+@app.get("/demo/dummy")
+def demo_dummy():
+  payload = dict(request.args)
+  payload["update_blynk"] = str(payload.get("update_blynk", "false")).lower() in ("1", "true", "yes")
+  if "stride" in payload:
+    try:
+      payload["stride"] = int(payload["stride"])
+    except Exception:
+      payload["stride"] = 1
+
+  try:
+    samples = _load_dummy_samples()
+    last, timeline = _run_samples(samples, payload)
+  except Exception as exc:
+    return jsonify({"success": False, "error": str(exc)}), 500
+
+  return jsonify(
+    {
+      "success": True,
+      "file": str(_DUMMY_FILE),
+      "total_samples": len(samples),
+      "result": {
+        "label": last["label"],
+        "confidence": last["confidence"],
+        "buffer": last["buffer"],
+      },
+      "timeline": timeline,
+    },
+  )
+
+
+def _preload_model_on_startup():
+  """Muat model saat startup agar request pertama tidak terasa hang."""
+  print("=" * 60)
+  print("NILM ML Service")
+  print(f"  Model dir : {MODEL_DIR}")
+  print(f"  Model ada : {(MODEL_DIR / 'best_nilm_model.keras').exists()}")
+  try:
+    meta = _read_model_meta()
+    print(f"  Versi     : {meta.get('model_name')}")
+    print(f"  Devices   : {meta.get('devices')}")
+    print(f"  Window    : {meta.get('input_shape')}")
+    print("  Memuat TensorFlow (10–30 detik, tunggu)...")
+    predictor = _get_v9_predictor()
+    print(f"  Predictor : {predictor.meta.get('model_version')}")
+    print("  Model SIAP.")
+  except Exception as exc:
+    print(f"  GAGAL muat model: {exc}")
+    print("  Server tetap jalan; perbaiki model lalu restart.")
+  print("=" * 60)
+
+
+if os.environ.get("NILM_PRELOAD_MODEL", "").lower() in ("1", "true", "yes"):
+  _preload_model_on_startup()
+
+
+if __name__ == "__main__":
+  port = int(os.environ.get("PORT", "5001"))
+  _preload_model_on_startup()
+  print(f"Server: http://127.0.0.1:{port}  (CTRL+C untuk stop)")
+  app.run(host="0.0.0.0", port=port, threaded=True)

ml_service/nilm_v9_predictor.py

@@ -0,0 +1,487 @@
+"""
+Predictor NILM v9 — selaras nilm_inference.py + perbaikan kipas/kombinasi.
+"""
+
+from __future__ import annotations
+
+import json
+from collections import deque
+from pathlib import Path
+from typing import Any, Optional
+
+import numpy as np
+
+
+class MetaScaler:
+  def __init__(self, mean: list[float], scale: list[float]):
+    self.mean_ = np.array(mean, dtype=np.float32)
+    self.scale_ = np.array(
+      [float(item) if float(item) != 0.0 else 1.0 for item in scale],
+      dtype=np.float32,
+    )
+
+  def transform(self, data: np.ndarray) -> np.ndarray:
+    return (data - self.mean_) / self.scale_
+
+
+def build_feature_vector(raw: dict) -> np.ndarray:
+  def _f(key: str, fallback: float = 0.0) -> float:
+    try:
+      value = float(raw[key])
+      return value if np.isfinite(value) else fallback
+    except Exception:
+      return fallback
+
+  voltage = _f("voltage", 220.0)
+  current = _f("current", 0.0)
+  power = _f("power", 0.0)
+  power_factor = max(0.0, min(_f("power_factor", 0.9), 1.0))
+  frequency = _f("frequency", 50.0)
+
+  apparent_power = voltage * current
+  reactive_power = apparent_power * np.sqrt(max(0.0, 1.0 - power_factor**2))
+  power_ratio = power / (apparent_power + 1e-6)
+
+  return np.array(
+    [voltage, current, power, power_factor, frequency, apparent_power, reactive_power, power_ratio],
+    dtype=np.float32,
+  )
+
+
+class NilmV9Predictor:
+  def __init__(self, model_dir: Path):
+    import tensorflow as tf
+
+    model_dir = Path(model_dir).resolve()
+    meta_path = model_dir / "meta_nilm.json"
+    keras_path = model_dir / "best_nilm_model.keras"
+
+    if not meta_path.exists():
+      raise FileNotFoundError(f"meta_nilm.json tidak ditemukan di {model_dir}")
+    if not keras_path.exists():
+      raise FileNotFoundError(f"best_nilm_model.keras tidak ditemukan di {model_dir}")
+
+    with meta_path.open(encoding="utf-8") as handle:
+      self.meta: dict[str, Any] = json.load(handle)
+
+    try:
+      register = tf.keras.saving.register_keras_serializable(package="nilm_v9")
+    except AttributeError:
+      register = tf.keras.utils.register_keras_serializable(package="nilm_v9")
+
+    @register
+    class TemporalSum(tf.keras.layers.Layer):
+      def call(self, inputs):
+        return tf.reduce_sum(inputs, axis=1)
+
+      def get_config(self):
+        return super().get_config()
+
+    def weighted_bce(y_true, y_pred):
+      return tf.reduce_mean(tf.keras.losses.binary_crossentropy(y_true, y_pred))
+
+    def exact_match(y_true, y_pred):
+      pred_bin = tf.cast(y_pred >= 0.5, tf.float32)
+      match = tf.reduce_all(tf.equal(pred_bin, y_true), axis=1)
+      return tf.reduce_mean(tf.cast(match, tf.float32))
+
+    self.model = tf.keras.models.load_model(
+      str(keras_path),
+      custom_objects={
+        "TemporalSum": TemporalSum,
+        "weighted_bce": weighted_bce,
+        "exact_match": exact_match,
+      },
+      compile=False,
+      safe_mode=False,
+    )
+
+    self.scaler = MetaScaler(self.meta["scaler_mean"], self.meta["scaler_scale"])
+    self.window_size = int(self.meta["window_size"])
+    self.devices: list[str] = list(self.meta["devices"])
+    self.threshold = float(self.meta.get("threshold", 0.5))
+    self.device_thresholds: dict[str, float] = {
+      str(key): float(value)
+      for key, value in (self.meta.get("device_thresholds") or {}).items()
+      if isinstance(value, (int, float))
+    }
+    self.noise_floor_w = float(self.meta.get("noise_floor_w", 3.0))
+    self.smooth_n = max(1, int(self.meta.get("smooth_n", 5)))
+    self.transition_delta = float(self.meta.get("transition_delta", 30.0))
+    self.power_range: dict = dict(self.meta.get("power_range") or {})
+    self.session_to_label: dict[str, str] = {
+      key: str(value) for key, value in (self.meta.get("session_to_label") or {}).items()
+    }
+
+    self._buffer: deque = deque(maxlen=self.window_size)
+    self._label_vote_queue: deque = deque(maxlen=self.smooth_n)
+    self._prev_apparent: Optional[float] = None
+
+  def reset(self) -> None:
+    self._buffer.clear()
+    self._label_vote_queue.clear()
+    self._prev_apparent = None
+
+  def _median_power_w(self) -> float:
+    if not self._buffer:
+      return 0.0
+    powers = [float(row[2]) for row in self._buffer]
+    return float(np.median(powers))
+
+  def _device_threshold(self, device: str) -> float:
+    return self.device_thresholds.get(device, self.threshold)
+
+  def _prob_map(self, probs: np.ndarray) -> dict[str, float]:
+    return {device: float(probability) for device, probability in zip(self.devices, probs)}
+
+  def _active_from_label(self, label: Optional[str]) -> list[str]:
+    if not label or label == "idle":
+      return []
+    if label == "full_load":
+      return list(self.devices)
+    parts = {part.strip() for part in label.split("+") if part.strip()}
+    return [device for device in self.devices if device in parts]
+
+  def _labels_matching_power(self, power_w: float) -> list[tuple[float, str, int]]:
+    if power_w < self.noise_floor_w:
+      return [(0.0, "idle", 0)]
+
+    matches: list[tuple[float, str, int]] = []
+    for label, rng in self.power_range.items():
+      if label == "idle" or not isinstance(rng, list) or len(rng) < 2:
+        continue
+      lo, hi = float(rng[0]), float(rng[1]) * 1.12
+      if lo <= power_w <= hi:
+        center = (float(rng[0]) + float(rng[1])) / 2.0
+        device_count = len(self._active_from_label(label))
+        matches.append((abs(power_w - center), label, device_count))
+
+    # Jarak sama → prefer label lebih sederhana (mis. laptop vs laptop+kipas)
+    matches.sort(key=lambda item: (item[0], item[2]))
+    return matches
+
+  def _power_fingerprint_label(self, power_w: float) -> Optional[str]:
+    matches = self._labels_matching_power(power_w)
+    return matches[0][1] if matches else None
+
+  def _model_active_from_probs(self, probs: np.ndarray, power_w: float = 0.0) -> list[str]:
+    prob_map = self._prob_map(probs)
+    stable = self._median_power_w() or power_w
+    active: list[str] = []
+    for device in self.devices:
+      threshold = self._device_threshold(device)
+      # Di zona laptop, kipas butuh prob lebih tinggi agar tidak false-positive
+      if device == "kipas" and stable > 50:
+        threshold = max(threshold, 0.62)
+      if prob_map[device] >= threshold:
+        active.append(device)
+    return active
+
+  def _label_score(self, label: str, model_set: set[str], prob_map: dict[str, float]) -> float:
+    label_active = set(self._active_from_label(label))
+    if not label_active:
+      return 0.0
+
+    union = model_set | label_active
+    jaccard = len(model_set & label_active) / len(union) if union else 0.0
+    prob_score = float(np.mean([prob_map.get(device, 0.0) for device in label_active]))
+    return 0.55 * jaccard + 0.45 * prob_score
+
+  def _best_label_for_power(self, power_w: float, model_active: list[str], probs: np.ndarray) -> Optional[str]:
+    matches = self._labels_matching_power(power_w)
+    if not matches:
+      return None
+
+    model_set = set(model_active)
+    prob_map = self._prob_map(probs)
+
+    if model_set:
+      exact = [
+        label
+        for _, label, _ in matches
+        if set(self._active_from_label(label)) == model_set
+      ]
+      if exact:
+        return exact[0]
+
+    best_label = None
+    best_score = -1.0
+    for distance, label, _ in matches[:10]:
+      score = self._label_score(label, model_set, prob_map) - (distance / 120.0)
+      if score > best_score:
+        best_score = score
+        best_label = label
+
+    return best_label
+
+  def _disambiguate_laptop_combo(
+    self,
+    power_w: float,
+    model_active: list[str],
+    probs: np.ndarray,
+    fallback_label: Optional[str],
+  ) -> Optional[str]:
+    """Pisahkan laptop+kipas vs laptop+charger saat daya laptop fluktuatif."""
+    prob_map = self._prob_map(probs)
+    model_set = set(model_active)
+    if "laptop" not in model_set:
+      return fallback_label
+
+    matches = self._labels_matching_power(power_w)
+    candidate_labels = [label for _, label, _ in matches]
+    laptop_combos = [
+      label
+      for label in candidate_labels
+      if label.startswith("laptop") and "hair_dryer" not in label
+    ]
+    if not laptop_combos:
+      return fallback_label
+
+    kipas_p = prob_map.get("kipas", 0.0)
+    charger_p = prob_map.get("charger_hp", 0.0)
+    laptop_p = prob_map.get("laptop", 0.0)
+
+    # Model aktifkan keduanya → pilih sekunder dengan margin probabilitas
+    if "kipas" in model_set and "charger_hp" in model_set:
+      prefer_kipas = kipas_p >= charger_p + 0.08
+      prefer_charger = charger_p >= kipas_p + 0.08
+      for label in laptop_combos:
+        parts = set(self._active_from_label(label))
+        if prefer_kipas and parts == {"laptop", "kipas"}:
+          return label
+        if prefer_charger and parts == {"laptop", "charger_hp"}:
+          return label
+        if not prefer_kipas and not prefer_charger and parts == {"laptop", "kipas", "charger_hp"}:
+          return label
+
+    if "kipas" in model_set and "charger_hp" not in model_set:
+      for label in laptop_combos:
+        if set(self._active_from_label(label)) == {"laptop", "kipas"}:
+          return label
+
+    if "charger_hp" in model_set and "kipas" not in model_set:
+      for label in laptop_combos:
+        if set(self._active_from_label(label)) == {"laptop", "charger_hp"}:
+          return label
+
+    if laptop_p >= 0.5 and not model_set - {"laptop"}:
+      solo = [label for label in laptop_combos if label == "laptop"]
+      if solo:
+        return solo[0]
+
+    return fallback_label
+
+  def _refine_active_devices(
+    self,
+    model_active: list[str],
+    probs: np.ndarray,
+    power_w: float,
+  ) -> list[str]:
+    if power_w < self.noise_floor_w:
+      return []
+
+    stable_power = self._median_power_w() or power_w
+    fingerprint_label = self._power_fingerprint_label(stable_power)
+    fingerprint_active = self._active_from_label(fingerprint_label)
+
+    # Charger: model sering salah prediksi kipas+laptop di daya rendah
+    if stable_power <= 18:
+      return fingerprint_active or ["charger_hp"]
+
+    # Kipas & kombinasi kipas (18–50 W): ikuti fingerprint daya stabil
+    if 18 < stable_power < 50:
+      if fingerprint_active:
+        return fingerprint_active
+      return model_active
+
+    # Laptop & kombinasi: skor model + median daya (daya laptop fluktuatif)
+    if 45 <= stable_power < 195:
+      best_label = self._best_label_for_power(stable_power, model_active, probs)
+      best_label = self._disambiguate_laptop_combo(stable_power, model_active, probs, best_label)
+      best_active = self._active_from_label(best_label)
+      if best_active:
+        return best_active
+      without_hair = [device for device in model_active if device != "hair_dryer"]
+      return without_hair if without_hair else model_active
+
+    if stable_power >= 195:
+      best_label = self._best_label_for_power(stable_power, model_active, probs)
+      best_active = self._active_from_label(best_label)
+      if best_active:
+        return best_active
+      return model_active
+
+    if fingerprint_active:
+      return fingerprint_active
+
+    return model_active
+
+  def _vote_label(self, label: str) -> str:
+    self._label_vote_queue.append(label)
+    if not self._label_vote_queue:
+      return label
+    return max(set(self._label_vote_queue), key=self._label_vote_queue.count)
+
+  def _canonical_label(self, active: list[str]) -> str:
+    if not active:
+      return "idle"
+
+    active_set = set(active)
+    for label in self.session_to_label.values():
+      if label == "idle":
+        continue
+      if label == "full_load" and active_set == set(self.devices):
+        return label
+      parts = {part.strip() for part in label.split("+") if part.strip()}
+      ordered = [device for device in self.devices if device in parts]
+      if set(ordered) == active_set:
+        return label
+
+    return "+".join(device for device in self.devices if device in active_set)
+
+  def _compute_detection_confidence(
+    self,
+    active_devices: list[str],
+    probs: np.ndarray,
+    buffer_status: str,
+    buffer_fill: int,
+    label: str,
+    power_w: float,
+    model_active: list[str],
+  ) -> float:
+    prob_map = self._prob_map(probs)
+    min_buf = max(10, self.window_size // 3)
+
+    if buffer_status == "warming":
+      progress = min(1.0, buffer_fill / min_buf)
+      return round(18 + progress * 32, 1)
+
+    if not active_devices or label == "idle":
+      peak = max(prob_map.values()) if prob_map else 0.0
+      return round(max(88.0, (1.0 - peak) * 100.0), 1)
+
+    active_probs = [prob_map[device] for device in active_devices if device in prob_map]
+    if not active_probs:
+      return 78.0
+
+    max_percent = max(active_probs) * 100.0
+    min_percent = min(active_probs) * 100.0
+    model_set = set(model_active)
+    active_set = set(active_devices)
+    refined = active_set != model_set
+
+    if len(active_devices) == 1:
+      score = max_percent
+      if score < 50 and refined:
+        score = max(74.0, min(92.0, 68.0 + score * 0.35))
+      return round(min(99.0, score), 1)
+
+    # Kombinasi (termasuk kipas+X): harmonic blend — tidak hanya min rendah
+    if min_percent < 1.0:
+      min_percent = max_percent * 0.35
+    score = (2 * min_percent * max_percent) / (min_percent + max_percent + 1e-6)
+
+    kipas_percent = prob_map.get("kipas", 0.0) * 100.0
+    if "kipas" in active_set and kipas_percent >= 40:
+      score = max(score, kipas_percent * 0.85 + max_percent * 0.15)
+
+    if refined and score < 68:
+      score = max(70.0, 0.45 * min_percent + 0.55 * max_percent)
+
+    return round(min(99.0, score), 1)
+
+  def predict(self, raw: dict) -> dict:
+    feat = build_feature_vector(raw)
+    power_w = float(feat[2])
+    apparent_w = float(feat[5])
+
+    if self._prev_apparent is not None and abs(apparent_w - self._prev_apparent) > self.transition_delta:
+      self._buffer.clear()
+      self._label_vote_queue.clear()
+    self._prev_apparent = apparent_w
+
+    if power_w < self.noise_floor_w:
+      self.reset()
+      return self._pack("idle", [], [0.0] * len(self.devices), 0, power_w, apparent_w, False, "idle", 96.0)
+
+    self._buffer.append(feat)
+    buf_len = len(self._buffer)
+    min_buf = max(10, self.window_size // 3)
+
+    if buf_len < min_buf:
+      warmup_confidence = round(18 + min(1.0, buf_len / min_buf) * 32, 1)
+      return self._pack(
+        "filling_buffer",
+        [],
+        [0.0] * len(self.devices),
+        buf_len,
+        power_w,
+        apparent_w,
+        False,
+        "warming",
+        warmup_confidence,
+      )
+
+    buffer_array = np.array(self._buffer, dtype=np.float32)
+    if buf_len < self.window_size:
+      repeat = int(np.ceil(self.window_size / buf_len))
+      window = np.tile(buffer_array, (repeat, 1))[: self.window_size]
+    else:
+      window = buffer_array[-self.window_size :]
+
+    scaled = self.scaler.transform(window)
+    probs = self.model.predict(np.expand_dims(scaled, axis=0), verbose=0)[0]
+
+    model_active = self._model_active_from_probs(probs, power_w)
+    refined_active = self._refine_active_devices(model_active, probs, power_w)
+    refined_label = self._canonical_label(refined_active)
+    final_label = self._vote_label(refined_label)
+    final_active = self._active_from_label(final_label)
+    status = "ready" if buf_len >= self.window_size else "loading"
+
+    confidence = self._compute_detection_confidence(
+      final_active,
+      probs,
+      status,
+      buf_len,
+      final_label,
+      power_w,
+      model_active,
+    )
+
+    return self._pack(
+      final_label,
+      final_active,
+      [float(prob) for prob in probs],
+      buf_len,
+      power_w,
+      apparent_w,
+      buf_len >= self.window_size,
+      status,
+      confidence,
+    )
+
+  def _pack(
+    self,
+    label: str,
+    active_devices: list[str],
+    probs: list[float],
+    buffer_fill: int,
+    power_w: float,
+    apparent_w: float,
+    is_ready: bool,
+    buffer_status: str,
+    confidence: float = 0.0,
+  ) -> dict:
+    return {
+      "label": label,
+      "active_devices": active_devices,
+      "probs": list(zip(self.devices, probs)),
+      "buffer_fill": buffer_fill,
+      "power_w": round(power_w, 2),
+      "apparent_va": round(apparent_w, 2),
+      "is_ready": is_ready,
+      "buffer_status": buffer_status,
+      "confidence": confidence,
+      "model_version": self.meta.get("model_version", "v9_multilabel"),
+    }

ml_service/run.ps1

@@ -0,0 +1,14 @@
+# Jalankan ML service dari folder ml_service (memuat .env dari root proyek)
+$ErrorActionPreference = "Stop"
+$root = Split-Path -Parent $PSScriptRoot
+Set-Location $PSScriptRoot
+
+if (-not (Test-Path (Join-Path $root "src\nilm_models_v9\best_nilm_model.keras"))) {
+  Write-Host "ERROR: Model tidak ditemukan di src\nilm_models_v9\" -ForegroundColor Red
+  Write-Host "Pastikan best_nilm_model.keras dan meta_nilm.json ada." -ForegroundColor Yellow
+  exit 1
+}
+
+$env:NILM_MODEL_DIR = "src/nilm_models_v9"
+Write-Host "Memulai ML service (port 5001)..." -ForegroundColor Cyan
+python app.py

ml_service/thingsboard_client.py

@@ -0,0 +1,175 @@
+"""Fetch latest telemetry from ThingsBoard (server-side, for /dashboard/latest)."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import requests
+
+TELEMETRY_KEYS = {
+  "voltage": os.environ.get("THINGSBOARD_KEY_VOLTAGE", "tegangan").strip() or "tegangan",
+  "current": os.environ.get("THINGSBOARD_KEY_CURRENT", "arus").strip() or "arus",
+  "power": os.environ.get("THINGSBOARD_KEY_POWER", "daya").strip() or "daya",
+  "energy": os.environ.get("THINGSBOARD_KEY_ENERGY", "kwh").strip() or "kwh",
+  "frequency": os.environ.get("THINGSBOARD_KEY_FREQUENCY", "frekuensi").strip() or "frekuensi",
+  "power_factor": os.environ.get("THINGSBOARD_KEY_POWER_FACTOR", "power_factor").strip()
+  or "power_factor",
+}
+
+
+def _base_url() -> str:
+  url = (os.environ.get("THINGSBOARD_BASE_URL") or "").strip().rstrip("/")
+  if not url:
+    raise RuntimeError("THINGSBOARD_BASE_URL belum diatur di environment ML service.")
+  return url
+
+
+def _device_token() -> str:
+  return (os.environ.get("THINGSBOARD_ACCESS_TOKEN") or "").strip()
+
+
+def _api_token() -> str:
+  return (
+    (os.environ.get("THINGSBOARD_API_TOKEN") or os.environ.get("THINGSBOARD_JWT_TOKEN") or "").strip()
+  )
+
+
+def _device_id() -> str:
+  return (os.environ.get("THINGSBOARD_DEVICE_ID") or "").strip()
+
+
+def _login_token() -> str:
+  username = (os.environ.get("THINGSBOARD_USERNAME") or "").strip()
+  password = (os.environ.get("THINGSBOARD_PASSWORD") or "").strip()
+  if not username or not password:
+    raise RuntimeError("THINGSBOARD_USERNAME/PASSWORD belum diatur.")
+  response = requests.post(
+    f"{_base_url()}/api/auth/login",
+    json={"username": username, "password": password},
+    timeout=15,
+  )
+  response.raise_for_status()
+  payload = response.json()
+  token = payload.get("token")
+  if not token:
+    raise RuntimeError("Login ThingsBoard tidak mengembalikan token.")
+  return str(token)
+
+
+def _tenant_auth_header(token: str) -> str:
+  """
+  ThingsBoard 4.3+ REST API key: X-Authorization: ApiKey <tb_...>
+  JWT dari /api/auth/login: X-Authorization: Bearer <jwt>
+  """
+  normalized = token.strip()
+  if normalized.startswith("tb_"):
+    return f"ApiKey {normalized}"
+  if normalized.startswith("eyJ"):
+    return f"Bearer {normalized}"
+  # Default: treat as REST API key (ThingsBoard Cloud)
+  return f"ApiKey {normalized}"
+
+
+def _auth_headers() -> dict[str, str]:
+  api_token = _api_token()
+  if api_token:
+    return {"X-Authorization": _tenant_auth_header(api_token)}
+  return {"X-Authorization": f"Bearer {_login_token()}"}
+
+
+def _resolve_device_id(headers: dict[str, str]) -> str:
+  device_id = _device_id()
+  if device_id:
+    return device_id
+  token = _device_token()
+  if not token:
+    raise RuntimeError("THINGSBOARD_DEVICE_ID atau THINGSBOARD_ACCESS_TOKEN wajib diisi.")
+  response = requests.get(
+    f"{_base_url()}/api/device/info",
+    params={"deviceToken": token},
+    headers=headers,
+    timeout=15,
+  )
+  response.raise_for_status()
+  payload = response.json()
+  resolved = (payload.get("id") or {}).get("id")
+  if not resolved:
+    raise RuntimeError("Device ID ThingsBoard tidak ditemukan dari access token.")
+  return str(resolved)
+
+
+def _parse_value(points: list[dict[str, Any]] | None, default: float = 0.0) -> float:
+  if not points:
+    return default
+  raw = points[0].get("value")
+  if raw is None or raw == "":
+    return default
+  try:
+    return float(raw)
+  except (TypeError, ValueError):
+    return default
+
+
+def _telemetry_via_device_api() -> dict[str, Any]:
+  token = _device_token()
+  if not token:
+    raise RuntimeError("THINGSBOARD_ACCESS_TOKEN kosong untuk mode device API.")
+  keys = ",".join(TELEMETRY_KEYS.values())
+  response = requests.get(
+    f"{_base_url()}/api/v1/{token}/telemetry",
+    params={"keys": keys, "limit": 1},
+    timeout=15,
+  )
+  response.raise_for_status()
+  return response.json()
+
+
+def _telemetry_via_tenant_api() -> dict[str, Any]:
+  headers = _auth_headers()
+  device_id = _resolve_device_id(headers)
+  keys = ",".join(TELEMETRY_KEYS.values())
+  response = requests.get(
+    f"{_base_url()}/api/plugins/telemetry/DEVICE/{device_id}/values/timeseries",
+    params={"keys": keys, "limit": 1},
+    headers=headers,
+    timeout=15,
+  )
+  response.raise_for_status()
+  return response.json()
+
+
+def _sample_from_telemetry(telemetry: dict[str, Any]) -> dict[str, float]:
+  return {
+    "voltage": _parse_value(telemetry.get(TELEMETRY_KEYS["voltage"]), 220.0),
+    "current": _parse_value(telemetry.get(TELEMETRY_KEYS["current"]), 0.0),
+    "power": _parse_value(telemetry.get(TELEMETRY_KEYS["power"]), 0.0),
+    "energy": _parse_value(telemetry.get(TELEMETRY_KEYS["energy"]), 0.0),
+    "frequency": _parse_value(telemetry.get(TELEMETRY_KEYS["frequency"]), 50.0),
+    "power_factor": _parse_value(telemetry.get(TELEMETRY_KEYS["power_factor"]), 0.0),
+  }
+
+
+def fetch_thingsboard_sample() -> dict[str, float]:
+  auth_mode = (os.environ.get("THINGSBOARD_AUTH_MODE") or "auto").strip().lower()
+
+  if auth_mode == "device_token":
+    return _sample_from_telemetry(_telemetry_via_device_api())
+
+  if auth_mode in ("api_token", "jwt", "login"):
+    return _sample_from_telemetry(_telemetry_via_tenant_api())
+
+  # auto: tenant API jika ada API token / login; fallback device token jika 401
+  if _api_token() or (_device_id() and not _device_token()):
+    try:
+      return _sample_from_telemetry(_telemetry_via_tenant_api())
+    except requests.HTTPError as exc:
+      status = exc.response.status_code if exc.response is not None else None
+      if status in (401, 403) and _device_token():
+        return _sample_from_telemetry(_telemetry_via_device_api())
+      raise
+
+  if _device_token():
+    return _sample_from_telemetry(_telemetry_via_device_api())
+
+  return _sample_from_telemetry(_telemetry_via_tenant_api())