From 1a67102cab4deefc7f5307b0f393ab4430857184 Mon Sep 17 00:00:00 2001 From: croelofs <25582572+roelofsc@users.noreply.github.com> Date: Thu, 8 Jan 2026 13:18:11 +0100 Subject: [PATCH 01/10] Add the `energy_fault_detector.evaluation.PreDistDataset` class and the notebook `notebooks/PreDist/PreDist.ipynb` to show how to apply the EnergyFaultDetector on the PreDist dataset. Also adds the `criticality` as method to the `FaultDetectionResult`, for easy access and plotting. --- .../core/fault_detection_result.py | 13 +- energy_fault_detector/evaluation/__init__.py | 5 +- .../evaluation/predist_dataset.py | 201 +++++ energy_fault_detector/utils/data_downloads.py | 67 +- energy_fault_detector/utils/visualisation.py | 14 +- .../CARE to Compare.ipynb | 2 +- .../c2c_configs/windfarm_A.yaml | 0 .../c2c_configs/windfarm_B.yaml | 0 .../c2c_configs/windfarm_C.yaml | 0 notebooks/PreDist/PreDist.ipynb | 711 ++++++++++++++++++ notebooks/PreDist/configs/m1_cond_ae.yaml | 53 ++ notebooks/PreDist/configs/m1_default_ae.yaml | 48 ++ notebooks/PreDist/configs/m1_doy_ae.yaml | 55 ++ notebooks/PreDist/configs/m2_cond_ae.yaml | 62 ++ notebooks/PreDist/configs/m2_default_ae.yaml | 57 ++ notebooks/PreDist/configs/m2_doy_ae.yaml | 64 ++ notebooks/PreDist/predist_utils.py | 146 ++++ 17 files changed, 1458 insertions(+), 40 deletions(-) create mode 100644 energy_fault_detector/evaluation/predist_dataset.py rename notebooks/{ => CARE to Compare}/CARE to Compare.ipynb (99%) rename notebooks/{ => CARE to Compare}/c2c_configs/windfarm_A.yaml (100%) rename notebooks/{ => CARE to Compare}/c2c_configs/windfarm_B.yaml (100%) rename notebooks/{ => CARE to Compare}/c2c_configs/windfarm_C.yaml (100%) create mode 100644 notebooks/PreDist/PreDist.ipynb create mode 100644 notebooks/PreDist/configs/m1_cond_ae.yaml create mode 100644 notebooks/PreDist/configs/m1_default_ae.yaml create mode 100644 notebooks/PreDist/configs/m1_doy_ae.yaml create mode 100644 notebooks/PreDist/configs/m2_cond_ae.yaml create mode 100644 notebooks/PreDist/configs/m2_default_ae.yaml create mode 100644 notebooks/PreDist/configs/m2_doy_ae.yaml create mode 100644 notebooks/PreDist/predist_utils.py diff --git a/energy_fault_detector/core/fault_detection_result.py b/energy_fault_detector/core/fault_detection_result.py index 52d8d44..a1a45f1 100644 --- a/energy_fault_detector/core/fault_detection_result.py +++ b/energy_fault_detector/core/fault_detection_result.py @@ -6,6 +6,8 @@ import pandas as pd import numpy as np +from ..utils.analysis import calculate_criticality + @dataclass class FaultDetectionResult: @@ -27,10 +29,17 @@ class FaultDetectionResult: """DataFrame with ARCANA results (ARCANA bias). None if ARCANA was not run.""" arcana_losses: Optional[pd.DataFrame] = None - """DataFrame containing recorded values for all losses in ARCANA. None if ARCANA was not run.""" + """DataFrame containing recorded values for all losses in ARCANA. None if ARCANA was not run. + Empty if losses were not tracked.""" tracked_bias: Optional[List[pd.DataFrame]] = None - """List of DataFrames containing the ARCANA bias every 50th iteration. None if ARCANA was not run.""" + """List of DataFrames containing the ARCANA bias every 50th iteration. None if ARCANA was not run. + Empty if bias was not tracked.""" + + def criticality(self, normal_idx: pd.Series = None, init_criticality: int = 0, max_criticality: int = 1000 + ) -> pd.Series: + """Criticality based on the predicted anomalies.""" + return calculate_criticality(self.predicted_anomalies, normal_idx, init_criticality, max_criticality) def save(self, directory: str, **kwargs) -> None: """Saves the results to CSV files in the specified directory. diff --git a/energy_fault_detector/evaluation/__init__.py b/energy_fault_detector/evaluation/__init__.py index f136890..499c600 100644 --- a/energy_fault_detector/evaluation/__init__.py +++ b/energy_fault_detector/evaluation/__init__.py @@ -1,4 +1,5 @@ """Evaluation classes and methods, including the CARE-Score and Care2CompareDataset.""" -from energy_fault_detector.evaluation.care_score import CAREScore -from energy_fault_detector.evaluation.care2compare import Care2CompareDataset +from .care_score import CAREScore +from .care2compare import Care2CompareDataset +from .predist_dataset import PreDistDataset diff --git a/energy_fault_detector/evaluation/predist_dataset.py b/energy_fault_detector/evaluation/predist_dataset.py new file mode 100644 index 0000000..4a05f5d --- /dev/null +++ b/energy_fault_detector/evaluation/predist_dataset.py @@ -0,0 +1,201 @@ +import pandas as pd +from pathlib import Path +from typing import Dict, Any, Union +import logging + +from ..utils.data_downloads import download_zenodo_data + +logger = logging.getLogger('energy_fault_detector') + + +class PreDistDataset: + """Loader and preprocessor for the PreDist dataset. + + Args: + path (Union[str, Path]): Path to the dataset root. + download_dataset (bool): If True, downloads the PreDist dataset from Zenodo. + """ + + FAULT_HOURS_AFTER = 24 + FAULT_HOURS_BEFORE = 48 + + def __init__(self, path: Union[str, Path], download_dataset: bool = False): + if download_dataset: + logger.info("Downloading PreDist dataset from Zenodo (10.5281/zenodo.17522254)...") + path = download_zenodo_data(identifier="10.5281/zenodo.17522254", dest=path, overwrite=False) + + self.root_path = Path(path) + + # preload events + self.events: Dict[int, pd.DataFrame] = { + 1: self._load_events(manufacturer=1), + 2: self._load_events(manufacturer=2) + } + + def _load_events(self, manufacturer: int, filter_efd: bool = True) -> pd.DataFrame: + """Loads and combines all events from faults.csv and normal_events.csv. + + Args: + manufacturer (int): Dataset 1 or 2. + filter_efd (bool): Whether to filter events with efd possible or not. Default: True. + + Returns: + Events as dataframe, with start and end based on the possible anomaly start and report date for faults and + based on event start and end for normal events. + """ + + m_path = self.root_path / f"Manufacturer {manufacturer}" + + faults = pd.read_csv(m_path / 'faults.csv', sep=';', parse_dates=[ + 'Possible anomaly start', 'Report date', 'Possible anomaly end', + 'Training start', 'Training end' + ], index_col='Event ID') + + normals = pd.read_csv(m_path / 'normal_events.csv', sep=';', parse_dates=[ + 'Event start', 'Event end', 'Training start', 'Training end' + ], index_col='Event ID') + + if filter_efd: + # Only filter faults where early fault detection is possible (from a data perspective) + faults = faults[faults['efd_possible']] + + faults['Event type'] = 'anomaly' + faults['Event end'] = faults['Report date'] # for easy data selection later on + normals['Event type'] = 'normal' + + return pd.concat([faults, normals]) + + def load_substation_data(self, manufacturer: int, substation_id: int) -> pd.DataFrame: + """Loads raw CSV, maps string values, and cleans indices.""" + file_path = self.root_path / f"Manufacturer {manufacturer}" / 'operational_data' / f"substation_{substation_id}.csv" + df = pd.read_csv(file_path, sep=';', index_col='timestamp', parse_dates=['timestamp']) + df.index = df.index.tz_localize(None) + df = df.sort_index() + + # Mapping string values (EIN/AUS) to (1/0) + val_map = {'EIN': 1, 'AUS': 0} + status_cols = [c for c in df.columns + if any(x in c for x in ['s_hc1_heating_pump_status_setpoint', + 's_hc1.2_heating_pump_status', + 's_hc1.3_heating_pump_status', + 's_hc2_dhw_3-way_valve_status', + 's_hc1.1_heating_pump_status'])] + for col in status_cols: + if col in df.columns: + df[col] = df[col].map(val_map).astype('Int32') + + # Map control unit mode to integer + mode_map = {'Nacht': -1, 'Standby': 0, 'Tag': 1} + for col in [c for c in df.columns if 'control_unit_mode' in c]: + df[col] = df[col].map(mode_map).astype('Int32') + + # Handle noisy outside temperature value for specific substations + # In these cases, the outside temperature is not known - the sensor value is just noise + if manufacturer == 2 and substation_id in [18, 61]: + df = df.drop(columns=['outdoor_temperature'], errors='ignore') + + return df[~df.index.duplicated(keep='first')] + + def create_normal_flag(self, data: pd.DataFrame, manufacturer: int, substation_id: int) -> pd.Series: + """Create a normal flag based on disturbances, so we can select normal behaviour for training models. + + Args: + data (pd.DataFrame): Dataframe containing sensor data for a specific substation. + manufacturer (int): Dataset 1 or 2. + substation_id (int): ID of the substation to load data from. + + Returns: + pd.Series: Normal flag (boolean) based on disturbances with the same timestamp index as data. + """ + + dist_path = self.root_path / f"Manufacturer {manufacturer}" / 'disturbances.csv' + disturbances = pd.read_csv(dist_path, sep=';', parse_dates=['Event start']) + disturbances = disturbances[disturbances['substation ID'] == substation_id] + + normal_flag = pd.Series(True, index=data.index) + + # 1. Mark known anomalies from events_df + events_df = self.events[manufacturer] + anoms = events_df[(events_df['substation ID'] == substation_id) & (events_df['Event type'] == 'anomaly')] + for _, row in anoms.iterrows(): + # If we do not know when an anomaly started, we mark FAULT_HOURS_BEFORE before report + start = (row['Possible anomaly start'] + if pd.notna(row['Possible anomaly start']) + else (row['Report date'] - pd.Timedelta(hours=self.FAULT_HOURS_BEFORE))) + # If anomaly end was not provided, add some time after the fault for maintenance + # (This does not happen, anomaly end is always provided in this dataset) + end = (row['Possible anomaly end'] + if pd.notna(row['Possible anomaly end']) + else (row['Report date'] + pd.Timedelta(hours=self.FAULT_HOURS_AFTER))) + normal_flag.loc[start:end] = False + + # remove faults from disturbances already marked by the events dataframe + faults_in_disturbances = disturbances[disturbances['type'] == 'fault'] + faults_in_event_data = faults_in_disturbances[faults_in_disturbances['Event start'].isin(anoms['Report date'])] + disturbances = disturbances[~disturbances.index.isin(faults_in_event_data.index)] + + # 2. Mark disturbances (tasks, activities and remaining faults) + for _, dist in disturbances.iterrows(): + # round to nearest 10 minutes to match timestamp index of the data + d_start = dist['Event start'].floor('10min') + if dist['type'] == 'fault': + normal_flag.loc[d_start - pd.Timedelta(hours=self.FAULT_HOURS_BEFORE): + d_start + pd.Timedelta(hours=self.FAULT_HOURS_AFTER)] = False + else: # task/activity: mark the full day as possibly anomalous behaviour + normal_flag.loc[d_start: d_start.normalize() + pd.Timedelta(days=1)] = False + + return normal_flag + + def get_event_data(self, manufacturer: int, event_id: int, max_training_days: int = 2*365) -> Dict[str, Any]: + """Extracts training and test slices for a specific event row (fault or normal). + """ + + # get info from event + event_row = self.events[manufacturer].loc[event_id] + substation_id = event_row['substation ID'] + train_start = event_row['Training start'] + train_end = event_row['Training end'] + event_end = event_row['Event end'] + event_type = event_row['Event type'].lower() + anomaly_end = event_row.loc['Possible anomaly end'] + + # Max 2 years of training data + train_start = max(train_start, train_end - pd.Timedelta(days=max_training_days)) + + data = self.load_substation_data(manufacturer, event_row['substation ID']) + + # Training data + train_data = data.loc[train_start:train_end] + + # Test data + if event_type == 'normal': + test_data = data.loc[train_end:event_end] + else: # anomaly + # By default, 7 days before report, add 2 days after report for visualisations + test_data = data.loc[event_end - pd.Timedelta(days=7):anomaly_end + pd.Timedelta(days=2)] + # Exception: event 67 of manufacturer 1 (3 months) + if event_id == 67 and manufacturer == 1: + test_data = data.loc[ + event_row['Possible anomaly start']:anomaly_end + pd.Timedelta(days=2) + ] + + # Drop columns that are missing in the evaluation period + eval_data = test_data.loc[:event_end] + eval_data = eval_data.dropna(how='all', axis=1) + train_data = train_data[eval_data.columns] + test_data = test_data[eval_data.columns] + + # Create normal behaviour indicator + train_normal_flag = self.create_normal_flag(data=train_data, + manufacturer=manufacturer, + substation_id=substation_id) + test_normal_flag = self.create_normal_flag(data=test_data, + manufacturer=manufacturer, + substation_id=substation_id) + return { + 'train_data': train_data, + 'test_data': test_data, + 'train_normal_flag': train_normal_flag, + 'test_normal_flag': test_normal_flag, + 'event_data': event_row, + } diff --git a/energy_fault_detector/utils/data_downloads.py b/energy_fault_detector/utils/data_downloads.py index 6abeef1..03ce1f9 100644 --- a/energy_fault_detector/utils/data_downloads.py +++ b/energy_fault_detector/utils/data_downloads.py @@ -2,7 +2,6 @@ from typing import List, Union import os import re -import sys import shutil import logging from pathlib import Path @@ -172,25 +171,39 @@ def prepare_output_dir(out_dir: Path, overwrite: bool) -> None: def download_zenodo_data(identifier: str = "10.5281/zenodo.15846963", dest: Path = "./downloads", - overwrite: bool = False) -> Union[List[Path], Path]: + overwrite: bool = False, flatten_file_structure: bool = True, + expected_file_types: Union[List[str], str] = "*.csv") -> Path: """ Download a Zenodo record via API and unzip any .zip files. + Downloads all files associated with a given Zenodo record (by ID, DOI, or URL), + saves them to a local directory, and optionally flattens nested directories + that result from extracting ZIP archives. + Args: - identifier (str): Zenodo record ID, DOI (e.g., 10.5281/zenodo.15846963), or record URL - dest (Path): Output directory (default: downloads) + identifier (str): Zenodo record ID, DOI (e.g., 10.5281/zenodo.15846963), or record URL. + Defaults to the CARE2Compare dataset. + dest (Path): Local output directory to save downloaded files. (default: downloads) overwrite (bool): If True and dest already exists, contents of dest will be overwritten. + Default is False. + flatten_file_structure (bool): If True and unzipping results in a single top-level folder + with no conflicting root-level files matching `expected_file_types`, + moves its contents up one level. Default is True. + expected_file_types (Union[List[str], str]): Glob pattern(s) used to detect existing relevant files + at the root. If any match, flattening is skipped. + Can be a string like '*.csv' or list like ['*.csv', '*.json']. Default is '*.csv'. Returns: - Union[List[Path], Path]: List of paths the extracted content of all downloaded zip files. If there is only one - downloaded zip file only one path is returned + Path: The absolute path to the directory containing the downloaded and unzipped data. """ + if isinstance(expected_file_types, str): + expected_file_types = [expected_file_types] session = requests.Session() try: record_id = parse_record_id(identifier) except ValueError as e: logger.error(e) - sys.exit(1) + raise out_dir = Path(dest) @@ -200,7 +213,7 @@ def download_zenodo_data(identifier: str = "10.5281/zenodo.15846963", dest: Path prepare_output_dir(out_dir, overwrite) except Exception as e: logger.error(f"Failed to prepare output directory: {e}") - sys.exit(1) + raise logger.info(f"Fetching record {record_id} metadata...") record = fetch_record(session, record_id) @@ -209,7 +222,7 @@ def download_zenodo_data(identifier: str = "10.5281/zenodo.15846963", dest: Path files = list_files(session, record) except RuntimeError as e: logger.error(e) - sys.exit(1) + raise downloaded = [] for f in files: @@ -228,10 +241,10 @@ def download_zenodo_data(identifier: str = "10.5281/zenodo.15846963", dest: Path # Unzip any downloaded .zip files for p in downloaded: if p.suffix.lower() == ".zip": - extract_dir = p.with_suffix("") # folder named after the zip - logger.info(f"Unzipping: {p.name} -> {extract_dir}") + extract_target = out_dir # Extract directly into dest + logger.info(f"Unzipping: {p.name} -> {extract_target}") try: - safe_extract_zip(p, extract_dir) + safe_extract_zip(p, extract_target) except Exception as e: logger.error(f"Unzipping failed for {p.name}: {e}") else: @@ -241,20 +254,16 @@ def download_zenodo_data(identifier: str = "10.5281/zenodo.15846963", dest: Path except OSError as e: logger.warning(f"Could not remove {p}: {e}") - logger.info(f"Validating file structure.") - # Check resulting file structure and remove duplicate directory names if they exist due to unzipping. - root_paths = [] - for file_or_dir in os.listdir(out_dir): - root_path = out_dir / file_or_dir - if os.path.isdir(root_path): - root_paths.append(root_path) - if file_or_dir in os.listdir(root_path): - duplicate_dir_name = root_path / file_or_dir - logger.info(f"Removing redundant directory: {duplicate_dir_name}") - move_list = os.listdir(duplicate_dir_name) - for content in move_list: - shutil.move(src=duplicate_dir_name / content, - dst=root_path / content) - os.rmdir(duplicate_dir_name) - logger.info(f"File structure validated.") - return root_paths if len(root_paths) > 1 else root_paths[0] + if flatten_file_structure: + logger.info(f"Flattening file structure.") + # Standardize structure: If unzipping created a single subfolder, move its contents up + # This often happens with Zenodo zips. + subdirs = [d for d in out_dir.iterdir() if d.is_dir()] + if len(subdirs) == 1 and not any(out_dir.glob(pattern) for pattern in expected_file_types): + redundant_dir = subdirs[0] + logger.info(f"Flattening directory structure from {redundant_dir}") + for item in redundant_dir.iterdir(): + shutil.move(str(item), str(out_dir / item.name)) + redundant_dir.rmdir() + + return out_dir diff --git a/energy_fault_detector/utils/visualisation.py b/energy_fault_detector/utils/visualisation.py index 74e3003..4eda52c 100644 --- a/energy_fault_detector/utils/visualisation.py +++ b/energy_fault_detector/utils/visualisation.py @@ -11,7 +11,6 @@ from energy_fault_detector.core import Autoencoder from energy_fault_detector.fault_detector import FaultDetector -from energy_fault_detector.utils.analysis import calculate_criticality MAX_PLOTS = 20 @@ -220,8 +219,7 @@ def plot_score_with_threshold(model: FaultDetector, data: pd.DataFrame, normal_i ax.plot(threshold, linestyle='-', linewidth=.7, label='threshold', c=threshold_color) if show_criticality: - crit = calculate_criticality(predictions.predicted_anomalies, normal_idx=normal_index, - max_criticality=max_criticality) + crit = predictions.criticality(normal_idx=normal_index, max_criticality=max_criticality) ax2 = ax.twinx() ax2.plot(crit, label='criticality counter', color=criticality_color) ax2.legend(loc='upper right', markerscale=3) @@ -229,9 +227,13 @@ def plot_score_with_threshold(model: FaultDetector, data: pd.DataFrame, normal_i ax.set_ylabel('anomaly score') - legend = ax.legend(loc='upper left', markerscale=3) - for h in legend.legend_handles: - h.set_alpha(1) + # Get handles and labels from the current axes + handles, labels = ax.get_legend_handles_labels() + if labels: + # Only create the legend if there are labels found + legend = ax.legend(loc='upper left', markerscale=3) + for h in legend.legend_handles: + h.set_alpha(1) return fig, ax diff --git a/notebooks/CARE to Compare.ipynb b/notebooks/CARE to Compare/CARE to Compare.ipynb similarity index 99% rename from notebooks/CARE to Compare.ipynb rename to notebooks/CARE to Compare/CARE to Compare.ipynb index 247c101..9a869a1 100644 --- a/notebooks/CARE to Compare.ipynb +++ b/notebooks/CARE to Compare/CARE to Compare.ipynb @@ -295,7 +295,7 @@ { "cell_type": "markdown", "source": [ - "# CARE Score and Care2CompareDataset usage on other datasets\n", + "# CARE Score usage on other datasets\n", "\n", "To use the CARE-Score with other datasets you need the following data:\n", "- define events containing anomalous data (the period before an actual fault)\n", diff --git a/notebooks/c2c_configs/windfarm_A.yaml b/notebooks/CARE to Compare/c2c_configs/windfarm_A.yaml similarity index 100% rename from notebooks/c2c_configs/windfarm_A.yaml rename to notebooks/CARE to Compare/c2c_configs/windfarm_A.yaml diff --git a/notebooks/c2c_configs/windfarm_B.yaml b/notebooks/CARE to Compare/c2c_configs/windfarm_B.yaml similarity index 100% rename from notebooks/c2c_configs/windfarm_B.yaml rename to notebooks/CARE to Compare/c2c_configs/windfarm_B.yaml diff --git a/notebooks/c2c_configs/windfarm_C.yaml b/notebooks/CARE to Compare/c2c_configs/windfarm_C.yaml similarity index 100% rename from notebooks/c2c_configs/windfarm_C.yaml rename to notebooks/CARE to Compare/c2c_configs/windfarm_C.yaml diff --git a/notebooks/PreDist/PreDist.ipynb b/notebooks/PreDist/PreDist.ipynb new file mode 100644 index 0000000..f8ef82d --- /dev/null +++ b/notebooks/PreDist/PreDist.ipynb @@ -0,0 +1,711 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# EnergyFaultDetector @ District Heatin\n", + "\n", + "This notebook shows how to apply the EnergyFaultDetector on the PreDist dataset (available on [zenodo](https://doi.org/10.5281/zenodo.17522254)) and how to reproduce results from the accompanying paper (preprint available on [arXiv](https://doi.org/10.48550/arXiv.2511.14791))." + ], + "id": "b3569887686796a6" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-08T12:10:00.352157Z", + "start_time": "2026-01-08T12:09:52.718327900Z" + } + }, + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.metrics import fbeta_score, precision_score, recall_score, ConfusionMatrixDisplay\n", + "\n", + "from energy_fault_detector.evaluation import PreDistDataset\n", + "from energy_fault_detector import FaultDetector, Config\n", + "from energy_fault_detector.utils.visualisation import plot_score_with_threshold, plot_reconstruction\n", + "from energy_fault_detector.utils.analysis import create_events\n", + "\n", + "from predist_utils import train_or_get_model, find_optimal_threshold, get_arcana_importances" + ], + "id": "a149ecfec1850ff7", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From C:\\Users\\croelofs\\PycharmProjects\\EnergyFaultDetector\\.venv\\Lib\\site-packages\\keras\\src\\losses.py:2976: The name tf.losses.sparse_softmax_cross_entropy is deprecated. Please use tf.compat.v1.losses.sparse_softmax_cross_entropy instead.\n", + "\n" + ] + } + ], + "execution_count": 1 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Load dataset", + "id": "5cab669e1b0c15d" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-08T12:10:00.401341700Z", + "start_time": "2026-01-08T12:10:00.352934Z" + } + }, + "cell_type": "code", + "source": [ + "dataset = PreDistDataset('./predist_data', download_dataset=False)\n", + "# Check events for manufacturer 1\n", + "dataset.events[1]" + ], + "id": "b3f587b734b87ccc", + "outputs": [ + { + "data": { + "text/plain": [ + " substation ID Report date Problem EN \\\n", + "Event ID \n", + "1 10 2014-05-04 14:44:00 no DHW \n", + "3 12 2015-12-01 10:56:00 no heat \n", + "5 11 2018-11-23 08:30:00 no heat \n", + "6 21 2016-12-06 13:12:00 not enough heat \n", + "7 26 2020-06-13 10:38:00 no DHW \n", + "... ... ... ... \n", + "58 5 NaT NaN \n", + "59 22 NaT NaN \n", + "61 14 NaT NaN \n", + "66 19 NaT NaN \n", + "68 13 NaT NaN \n", + "\n", + " Event description EN \\\n", + "Event ID \n", + "1 No hot water. Actuator (DHW system) replaced. \n", + "3 Control parameters updated. \n", + "5 Pump settings updated. \n", + "6 The heaters are not getting warm enough. Suppl... \n", + "7 The needle valve was closed. Readjusted. \n", + "... ... \n", + "58 NaN \n", + "59 NaN \n", + "61 NaN \n", + "66 NaN \n", + "68 NaN \n", + "\n", + " Possible anomaly start Possible anomaly end Training start \\\n", + "Event ID \n", + "1 2014-05-03 16:00:00 2014-05-05 04:00:00 2012-03-28 09:00:00 \n", + "3 2015-11-29 12:00:00 2015-12-02 10:56:00 2015-03-01 00:00:00 \n", + "5 NaT 2018-11-26 09:56:59 2015-02-20 14:00:00 \n", + "6 NaT 2016-12-07 13:12:00 2015-11-30 09:00:00 \n", + "7 2020-06-12 12:00:00 2020-06-14 10:38:00 2018-10-18 13:00:00 \n", + "... ... ... ... \n", + "58 NaT NaT 2016-02-29 00:00:00 \n", + "59 NaT NaT 2018-06-21 10:00:00 \n", + "61 NaT NaT 2017-12-04 00:00:00 \n", + "66 NaT NaT 2015-09-15 09:31:00 \n", + "68 NaT NaT 2017-12-19 00:00:00 \n", + "\n", + " Training end efd_possible \\\n", + "Event ID \n", + "1 2014-04-20 14:44:00 True \n", + "3 2015-11-17 10:56:00 True \n", + "5 2018-11-09 08:30:00 True \n", + "6 2016-11-22 13:12:00 True \n", + "7 2020-05-30 10:38:00 True \n", + "... ... ... \n", + "58 2018-02-28 00:00:00 NaN \n", + "59 2019-01-31 00:00:00 NaN \n", + "61 2019-12-05 00:00:00 NaN \n", + "66 2017-06-14 00:00:00 NaN \n", + "68 2019-12-20 00:00:00 NaN \n", + "\n", + " Fault label \\\n", + "Event ID \n", + "1 Motorised control valve (primary side): Actuat... \n", + "3 Control unit: Incorrect parameterisation \n", + "5 Failure of the heating circuit pump \n", + "6 Control unit: Incorrect parameterisation \n", + "7 Incorrect setting of the differential pressure... \n", + "... ... \n", + "58 NaN \n", + "59 NaN \n", + "61 NaN \n", + "66 NaN \n", + "68 NaN \n", + "\n", + " Monitoring potential Event type Event end Event start \n", + "Event ID \n", + "1 3.4 anomaly 2014-05-04 14:44:00 NaT \n", + "3 4 anomaly 2015-12-01 10:56:00 NaT \n", + "5 3.8 anomaly 2018-11-23 08:30:00 NaT \n", + "6 4 anomaly 2016-12-06 13:12:00 NaT \n", + "7 3.1 anomaly 2020-06-13 10:38:00 NaT \n", + "... ... ... ... ... \n", + "58 NaN normal 2018-03-07 00:00:00 2018-02-28 \n", + "59 NaN normal 2019-02-07 00:00:00 2019-01-31 \n", + "61 NaN normal 2019-12-12 00:00:00 2019-12-05 \n", + "66 NaN normal 2017-06-21 00:00:00 2017-06-14 \n", + "68 NaN normal 2019-12-27 00:00:00 2019-12-20 \n", + "\n", + "[64 rows x 14 columns]" + ], + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
substation IDReport dateProblem ENEvent description ENPossible anomaly startPossible anomaly endTraining startTraining endefd_possibleFault labelMonitoring potentialEvent typeEvent endEvent start
Event ID
1102014-05-04 14:44:00no DHWNo hot water. Actuator (DHW system) replaced.2014-05-03 16:00:002014-05-05 04:00:002012-03-28 09:00:002014-04-20 14:44:00TrueMotorised control valve (primary side): Actuat...3.4anomaly2014-05-04 14:44:00NaT
3122015-12-01 10:56:00no heatControl parameters updated.2015-11-29 12:00:002015-12-02 10:56:002015-03-01 00:00:002015-11-17 10:56:00TrueControl unit: Incorrect parameterisation4anomaly2015-12-01 10:56:00NaT
5112018-11-23 08:30:00no heatPump settings updated.NaT2018-11-26 09:56:592015-02-20 14:00:002018-11-09 08:30:00TrueFailure of the heating circuit pump3.8anomaly2018-11-23 08:30:00NaT
6212016-12-06 13:12:00not enough heatThe heaters are not getting warm enough. Suppl...NaT2016-12-07 13:12:002015-11-30 09:00:002016-11-22 13:12:00TrueControl unit: Incorrect parameterisation4anomaly2016-12-06 13:12:00NaT
7262020-06-13 10:38:00no DHWThe needle valve was closed. Readjusted.2020-06-12 12:00:002020-06-14 10:38:002018-10-18 13:00:002020-05-30 10:38:00TrueIncorrect setting of the differential pressure...3.1anomaly2020-06-13 10:38:00NaT
.............................................
585NaTNaNNaNNaTNaT2016-02-29 00:00:002018-02-28 00:00:00NaNNaNNaNnormal2018-03-07 00:00:002018-02-28
5922NaTNaNNaNNaTNaT2018-06-21 10:00:002019-01-31 00:00:00NaNNaNNaNnormal2019-02-07 00:00:002019-01-31
6114NaTNaNNaNNaTNaT2017-12-04 00:00:002019-12-05 00:00:00NaNNaNNaNnormal2019-12-12 00:00:002019-12-05
6619NaTNaNNaNNaTNaT2015-09-15 09:31:002017-06-14 00:00:00NaNNaNNaNnormal2017-06-21 00:00:002017-06-14
6813NaTNaNNaNNaTNaT2017-12-19 00:00:002019-12-20 00:00:00NaNNaNNaNnormal2019-12-27 00:00:002019-12-20
\n", + "

64 rows × 14 columns

\n", + "
" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 2 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Create or load models (uses optimized configs)", + "id": "ad56a689d11f8d2b" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-08T12:10:00.530885300Z", + "start_time": "2026-01-08T12:10:00.438434900Z" + } + }, + "cell_type": "code", + "source": [ + "model_configs = {\n", + " 1: {\n", + " 'config_files': {\n", + " 'default_ae': './configs/m1_default_ae.yaml',\n", + " 'cond_ae': './configs/m1_cond_ae.yaml',\n", + " 'doy_ae': './configs/m1_doy_ae.yaml'\n", + " },\n", + " 'bottleneck': 0.65\n", + " },\n", + " 2: {\n", + " 'config_files': {\n", + " 'default_ae': './configs/m2_default_ae.yaml',\n", + " 'cond_ae': './configs/m2_cond_ae.yaml',\n", + " 'doy_ae': './configs/m2_doy_ae.yaml'\n", + " },\n", + " 'bottleneck': 0.25\n", + " }\n", + "}\n", + "\n", + "# Model file exists, load the model\n", + "load_from_file = True" + ], + "id": "c9177963f751115b", + "outputs": [], + "execution_count": 3 + }, + { + "metadata": { + "ExecuteTime": { + "start_time": "2026-01-08T12:10:00.633173600Z" + } + }, + "cell_type": "code", + "source": [ + "# Create or load model, predict and collect results for all events\n", + "from joblib import Parallel, delayed\n", + "\n", + "\n", + "# To test:\n", + "manufacturers = [1, 2] # [1, 2]\n", + "models = ['default_ae', 'cond_ae'] # ['default_ae', 'cond_ae', 'doy_ae']\n", + "\n", + "results = {}\n", + "for manufacturer in manufacturers:\n", + " results[manufacturer] = {}\n", + " for config_name, config_file in model_configs[manufacturer]['config_files'].items():\n", + " if config_name not in models:\n", + " continue\n", + "\n", + " conf = Config(config_file)\n", + " dp_params = conf.config_dict['train']['data_preprocessor']['params']\n", + " ts_features = None\n", + " if dp_params.get('ts_features'):\n", + " ts_features = dp_params.pop('ts_features') # remove time features from config\n", + "\n", + " # Prepare parameters for parallel execution\n", + " bottleneck_ratio = model_configs[manufacturer]['bottleneck']\n", + " events_to_process = dataset.events[manufacturer].iterrows()\n", + "\n", + " # Run parallel over events\n", + " # n_jobs=-1 uses all CPU cores. Adjust if memory is an issue.\n", + " parallel_results = Parallel(n_jobs=-1, verbose=10)(\n", + " delayed(train_or_get_model)(\n", + " event_id, dataset, manufacturer, config_name,\n", + " conf, bottleneck_ratio, load_from_file, ts_features\n", + " ) for event_id, event_row in events_to_process\n", + " )\n", + "\n", + " # Create the results dictionary\n", + " results[manufacturer][config_name] = dict(parallel_results)" + ], + "id": "d6f9edc9349242ca", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 20 concurrent workers.\n", + "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 27.7s\n", + "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 37.4s\n", + "[Parallel(n_jobs=-1)]: Done 21 tasks | elapsed: 42.3s\n", + "[Parallel(n_jobs=-1)]: Done 32 out of 64 | elapsed: 4.7min remaining: 4.7min\n", + "[Parallel(n_jobs=-1)]: Done 39 out of 64 | elapsed: 5.2min remaining: 3.3min\n", + "[Parallel(n_jobs=-1)]: Done 46 out of 64 | elapsed: 7.7min remaining: 3.0min\n", + "[Parallel(n_jobs=-1)]: Done 53 out of 64 | elapsed: 8.0min remaining: 1.7min\n" + ] + } + ], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "### Find optimal criticality threshold based on the reliability score\n", + "Calculate max criticality before report date and optimize criticality threshold using 5-fold CV" + ], + "id": "3c0ee0eeabed5068" + }, + { + "metadata": {}, + "cell_type": "code", + "source": [ + "max_criticality_results = {}\n", + "criticality_thresholds = {}\n", + "predicted_anomalies = {}\n", + "true_anomalies = {}\n", + "\n", + "for manufacturer in results.keys():\n", + " max_criticality_results[manufacturer] = {}\n", + " criticality_thresholds[manufacturer] = {}\n", + " predicted_anomalies[manufacturer] = {}\n", + "\n", + " true_anomalies[manufacturer] = (dataset.events[manufacturer]['Event type'] == 'anomaly').astype(int)\n", + "\n", + " for config_name, results_dict in results[manufacturer].items():\n", + "\n", + " max_criticality_list = []\n", + " for event_id, prediction in results_dict.items():\n", + " event_row = dataset.events[manufacturer].loc[event_id]\n", + " max_criticality = prediction.criticality().loc[:event_row['Report date']].max()\n", + " max_criticality_list += [(event_id, max_criticality)]\n", + "\n", + " c = pd.DataFrame(max_criticality_list, columns=['event_id', 'max_criticality'])\n", + " c = c.set_index('event_id')['max_criticality']\n", + " max_criticality_results[manufacturer][config_name] = c\n", + "\n", + " criticality_threshold = find_optimal_threshold(\n", + " true_anomalies=true_anomalies[manufacturer],\n", + " max_criticalities=max_criticality_results[manufacturer][config_name],\n", + " )\n", + " criticality_thresholds[manufacturer][config_name] = criticality_threshold\n", + " predicted_anomalies[manufacturer][config_name] = c > criticality_threshold" + ], + "id": "4f741a688f149cd7", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Final results (reliability and eventwise precision+recall)", + "id": "ae299a2f61b2f5a5" + }, + { + "metadata": {}, + "cell_type": "code", + "source": [ + "for manufacturer in results.keys():\n", + " print(f'Manufacturer m{manufacturer}')\n", + " for config_name in results[manufacturer].keys():\n", + " print(f'Model {config_name}:')\n", + "\n", + " reliability = fbeta_score(\n", + " true_anomalies[manufacturer], predicted_anomalies[manufacturer][config_name],\n", + " beta=0.5\n", + " )\n", + " precision = precision_score(\n", + " true_anomalies[manufacturer], predicted_anomalies[manufacturer][config_name]\n", + " )\n", + " recall = recall_score(\n", + " true_anomalies[manufacturer], predicted_anomalies[manufacturer][config_name]\n", + " )\n", + " print(f'Reliability: {reliability:.2f}, Precision: {precision:.2f}, Recall: {recall:.2f}')\n", + "\n", + " disp = ConfusionMatrixDisplay.from_predictions(\n", + " y_true=true_anomalies[manufacturer], y_pred=predicted_anomalies[manufacturer][config_name],\n", + " cmap='Blues',\n", + " labels=[False, True],\n", + " display_labels=['Normal', 'Anomaly'],\n", + " )\n" + ], + "id": "3b5c248383e4592e", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Visualise results", + "id": "570ebfedc795dd61" + }, + { + "metadata": {}, + "cell_type": "code", + "source": [ + "manufacturer = 1\n", + "config_name = 'cond_ae'\n", + "event_id = 49\n", + "report_date = dataset.events[manufacturer].loc[event_id]['Report date']\n", + "\n", + "# Event details\n", + "dataset.events[manufacturer].loc[event_id]" + ], + "id": "a761ecfa7874e175", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "#### Criticality", + "id": "e1d0ace838ed0d5f" + }, + { + "metadata": {}, + "cell_type": "code", + "source": [ + "predictions = results[manufacturer][config_name][event_id]\n", + "\n", + "fig, ax = plt.subplots(1, 1, figsize=(8,3))\n", + "crit = predictions.criticality()\n", + "crit.plot(ax=ax, label=config_name)\n", + "\n", + "ax.axvline(report_date, label='incident report', c='r', linestyle='-')\n", + "\n", + "ax.legend(loc='upper left')\n", + "ax.set_ylabel('criticality')\n", + "ax.set_xlabel('')" + ], + "id": "5236c23c789fdd72", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "#### ARCANA results", + "id": "814da89e48b3860c" + }, + { + "metadata": {}, + "cell_type": "code", + "source": [ + "test_data = dataset.get_event_data(manufacturer, event_id)['test_data']\n", + "\n", + "# find longest detected anomaly event (continuous run of predicted anomalous timestamps)\n", + "anomaly_events, _ = create_events(\n", + " test_data,\n", + " predictions.predicted_anomalies,\n", + " min_event_length=12\n", + ")\n", + "longest_anomaly_event = anomaly_events[anomaly_events['duration'] == anomaly_events['duration'].max()].iloc[0]\n", + "\n", + "# Calculate ARCANA feature importances\n", + "top_features = get_arcana_importances(manufacturer, event_id, config_name, test_data.loc[longest_anomaly_event['start']:report_date])\n", + "\n", + "top_features" + ], + "id": "b8a234e31eeecc66", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "code", + "source": [ + "# Plot the reconstruction of the top 3\n", + "fig, ax = plot_reconstruction(test_data, predictions.reconstruction, top_features.index[:3].to_list())\n", + "\n", + "for ax_ in ax:\n", + " ax_.axvline(report_date, label='incident report', color='r', linestyle='-')\n", + "\n", + "ax[0].legend(loc='upper left')" + ], + "id": "d0cbfbada56ec052", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "code", + "source": "", + "id": "ef36d5c93501b213", + "outputs": [], + "execution_count": null + } + ], + "metadata": { + "kernelspec": { + "name": "python3", + "language": "python", + "display_name": "Python 3 (ipykernel)" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/PreDist/configs/m1_cond_ae.yaml b/notebooks/PreDist/configs/m1_cond_ae.yaml new file mode 100644 index 0000000..534d289 --- /dev/null +++ b/notebooks/PreDist/configs/m1_cond_ae.yaml @@ -0,0 +1,53 @@ +train: + data_clipping: + lower_percentile: 0.001 + upper_percentile: 0.999 + + data_preprocessor: + params: + imputer_strategy: mean + include_duplicate_value_to_nan: false, + max_col_zero_frac: 0.5 + max_nan_frac_per_col: 0.8 + min_unique_value_count: 3 + scale: standardize + features_to_exclude: + - p_net_meter_energy # we use power and flow + - p_net_meter_volume + ts_features: ['hour_of_day', 'day_of_week'] + + autoencoder: + name: conditional + verbose: 0 + params: + batch_size: 256 + code_size: 5 # set by bottleneck ratio (0.65) + early_stopping: true + epochs: 100 + layers: [64, 32] + learning_rate: 0.00045 + noise: 0.05 + loss_name: mean_squared_error + conditional_features: ['hour_of_day_sine', + 'hour_of_day_cosine', + 'day_of_week_sine', + 'day_of_week_cosine'] + + anomaly_score: + name: mahalanobis + + data_splitter: + type: sklearn + validation_split: 0.2 + shuffle: true + + threshold_selector: + fit_on_val: false + name: quantile + params: + quantile: 0.99 + +root_cause_analysis: + alpha: 0.8 + init_x_bias: recon + num_iter: 1000 diff --git a/notebooks/PreDist/configs/m1_default_ae.yaml b/notebooks/PreDist/configs/m1_default_ae.yaml new file mode 100644 index 0000000..01b4293 --- /dev/null +++ b/notebooks/PreDist/configs/m1_default_ae.yaml @@ -0,0 +1,48 @@ +train: + data_clipping: + lower_percentile: 0.001 + upper_percentile: 0.999 + + data_preprocessor: + params: + imputer_strategy: mean + include_duplicate_value_to_nan: false, + max_col_zero_frac: 0.5 + max_nan_frac_per_col: 0.8 + min_unique_value_count: 3 + scale: standardize + features_to_exclude: + - p_net_meter_energy # we use power and flow + - p_net_meter_volume + + autoencoder: + name: default + verbose: 0 + params: + batch_size: 256 + code_size: 5 # set by bottleneck ratio (0.65) + early_stopping: true + epochs: 100 + layers: [64, 32] + learning_rate: 0.00045 + noise: 0.05 + loss_name: mean_squared_error + + anomaly_score: + name: mahalanobis + + data_splitter: + type: sklearn + validation_split: 0.2 + shuffle: true + + threshold_selector: + fit_on_val: false + name: quantile + params: + quantile: 0.99 + +root_cause_analysis: + alpha: 0.8 + init_x_bias: recon + num_iter: 1000 diff --git a/notebooks/PreDist/configs/m1_doy_ae.yaml b/notebooks/PreDist/configs/m1_doy_ae.yaml new file mode 100644 index 0000000..cb67060 --- /dev/null +++ b/notebooks/PreDist/configs/m1_doy_ae.yaml @@ -0,0 +1,55 @@ +train: + data_clipping: + lower_percentile: 0.001 + upper_percentile: 0.999 + + data_preprocessor: + params: + imputer_strategy: mean + include_duplicate_value_to_nan: false, + max_col_zero_frac: 0.5 + max_nan_frac_per_col: 0.8 + min_unique_value_count: 3 + scale: standardize + features_to_exclude: + - p_net_meter_energy # we use power and flow + - p_net_meter_volume + ts_features: ['hour_of_day', 'day_of_week', 'day_of_year'] + + autoencoder: + name: conditional + verbose: 0 + params: + batch_size: 256 + code_size: 5 # set by bottleneck ratio (0.65) + early_stopping: true + epochs: 100 + layers: [64, 32] + learning_rate: 0.00045 + noise: 0.05 + loss_name: mean_squared_error + conditional_features: ['hour_of_day_sine', + 'hour_of_day_cosine', + 'day_of_week_sine', + 'day_of_week_cosine', + 'day_of_year_sine', + 'day_of_year_cosine'] + + anomaly_score: + name: mahalanobis + + data_splitter: + type: sklearn + validation_split: 0.2 + shuffle: true + + threshold_selector: + fit_on_val: false + name: quantile + params: + quantile: 0.99 + +root_cause_analysis: + alpha: 0.8 + init_x_bias: recon + num_iter: 1000 diff --git a/notebooks/PreDist/configs/m2_cond_ae.yaml b/notebooks/PreDist/configs/m2_cond_ae.yaml new file mode 100644 index 0000000..813c503 --- /dev/null +++ b/notebooks/PreDist/configs/m2_cond_ae.yaml @@ -0,0 +1,62 @@ +train: + data_clipping: + lower_percentile: 0.001 + upper_percentile: 0.999 + + data_preprocessor: + params: + imputer_strategy: mean + include_duplicate_value_to_nan: false, + max_col_zero_frac: 0.5 + max_nan_frac_per_col: 0.8 + min_unique_value_count: 3 + scale: standardize + features_to_exclude: + - p_net_meter_energy # we use power and flow + - p_net_meter_volume + - s_dhw_control_unit_mode + - s_hc1.1_control_unit_mode + - s_hc1.2_control_unit_mode + - s_hc1.3_control_unit_mode + - s_hc1_control_unit_mode + - s_hc1.1_room_temperature_setpoint + - s_hc1.2_room_temperature_setpoint + - s_hc1.3_room_temperature_setpoint + - s_hc1_room_temperature_setpoint + ts_features: ['hour_of_day', 'day_of_week'] + + autoencoder: + name: conditional + verbose: 0 + params: + batch_size: 256 + code_size: 5 # set by bottleneck ratio (0.25) + early_stopping: true + epochs: 100 + layers: [64, 32] + learning_rate: 0.00053 + noise: 0.15 + loss_name: mean_squared_error + conditional_features: [ 'hour_of_day_sine', + 'hour_of_day_cosine', + 'day_of_week_sine', + 'day_of_week_cosine' ] + + anomaly_score: + name: rmse + + data_splitter: + type: sklearn + validation_split: 0.2 + shuffle: true + + threshold_selector: + fit_on_val: false + name: quantile + params: + quantile: 0.99 + +root_cause_analysis: + alpha: 0.8 + init_x_bias: recon + num_iter: 1000 diff --git a/notebooks/PreDist/configs/m2_default_ae.yaml b/notebooks/PreDist/configs/m2_default_ae.yaml new file mode 100644 index 0000000..26d1dde --- /dev/null +++ b/notebooks/PreDist/configs/m2_default_ae.yaml @@ -0,0 +1,57 @@ +train: + data_clipping: + lower_percentile: 0.001 + upper_percentile: 0.999 + + data_preprocessor: + params: + imputer_strategy: mean + include_duplicate_value_to_nan: false, + max_col_zero_frac: 0.5 + max_nan_frac_per_col: 0.8 + min_unique_value_count: 3 + scale: standardize + features_to_exclude: + - p_net_meter_energy # we use power and flow + - p_net_meter_volume + - s_dhw_control_unit_mode + - s_hc1.1_control_unit_mode + - s_hc1.2_control_unit_mode + - s_hc1.3_control_unit_mode + - s_hc1_control_unit_mode + - s_hc1.1_room_temperature_setpoint + - s_hc1.2_room_temperature_setpoint + - s_hc1.3_room_temperature_setpoint + - s_hc1_room_temperature_setpoint + + autoencoder: + name: default + verbose: 0 + params: + batch_size: 256 + code_size: 5 # set by bottleneck ratio (0.25) + early_stopping: true + epochs: 100 + layers: [64, 32] + learning_rate: 0.00053 + noise: 0.15 + loss_name: mean_squared_error + + anomaly_score: + name: rmse + + data_splitter: + type: sklearn + validation_split: 0.2 + shuffle: true + + threshold_selector: + fit_on_val: false + name: quantile + params: + quantile: 0.99 + +root_cause_analysis: + alpha: 0.8 + init_x_bias: recon + num_iter: 1000 diff --git a/notebooks/PreDist/configs/m2_doy_ae.yaml b/notebooks/PreDist/configs/m2_doy_ae.yaml new file mode 100644 index 0000000..fe9370f --- /dev/null +++ b/notebooks/PreDist/configs/m2_doy_ae.yaml @@ -0,0 +1,64 @@ +train: + data_clipping: + lower_percentile: 0.001 + upper_percentile: 0.999 + + data_preprocessor: + params: + imputer_strategy: mean + include_duplicate_value_to_nan: false, + max_col_zero_frac: 0.5 + max_nan_frac_per_col: 0.8 + min_unique_value_count: 3 + scale: standardize + features_to_exclude: + - p_net_meter_energy # we use power and flow + - p_net_meter_volume + - s_dhw_control_unit_mode + - s_hc1.1_control_unit_mode + - s_hc1.2_control_unit_mode + - s_hc1.3_control_unit_mode + - s_hc1_control_unit_mode + - s_hc1.1_room_temperature_setpoint + - s_hc1.2_room_temperature_setpoint + - s_hc1.3_room_temperature_setpoint + - s_hc1_room_temperature_setpoint + ts_features: ['hour_of_day', 'day_of_week', 'day_of_year'] + + autoencoder: + name: conditional + verbose: 0 + params: + batch_size: 256 + code_size: 5 # set by bottleneck ratio (0.25) + early_stopping: true + epochs: 100 + layers: [64, 32] + learning_rate: 0.00053 + noise: 0.15 + loss_name: mean_squared_error + conditional_features: [ 'hour_of_day_sine', + 'hour_of_day_cosine', + 'day_of_week_sine', + 'day_of_week_cosine', + 'day_of_year_sine', + 'day_of_year_cosine' ] + + anomaly_score: + name: rmse + + data_splitter: + type: sklearn + validation_split: 0.2 + shuffle: true + + threshold_selector: + fit_on_val: false + name: quantile + params: + quantile: 0.99 + +root_cause_analysis: + alpha: 0.8 + init_x_bias: recon + num_iter: 1000 diff --git a/notebooks/PreDist/predist_utils.py b/notebooks/PreDist/predist_utils.py new file mode 100644 index 0000000..c42cebf --- /dev/null +++ b/notebooks/PreDist/predist_utils.py @@ -0,0 +1,146 @@ +from typing import List, Tuple +from pathlib import Path +from copy import deepcopy +import logging + +import pandas as pd +import numpy as np +from sklearn.model_selection import StratifiedKFold +from sklearn.metrics import fbeta_score + +from energy_fault_detector import FaultDetector, Config +from energy_fault_detector.core import FaultDetectionResult +from energy_fault_detector.evaluation import PreDistDataset +from energy_fault_detector.root_cause_analysis.arcana_utils import calculate_mean_arcana_importances + + +def train_or_get_model(event_id: int, dataset: PreDistDataset, manufacturer: int, config_name: str, conf: Config, + bottleneck_ratio: float, load_from_file: bool, ts_features_orig: List[str] | None + ) -> Tuple[int, FaultDetectionResult]: + """Processes a single event: loads data, trains/loads model, and predicts.""" + + # Configure logging + logger = logging.getLogger('energy_fault_detector') + if not logger.handlers: + logging.basicConfig(level=logging.INFO) + + logger.info(f'Processing event {event_id} for manufacturer {manufacturer}...') + + # Local copy of ts_features and configuration to avoid mutation issues in parallel + ts_features = ts_features_orig.copy() if ts_features_orig else None + local_conf = deepcopy(conf) + + # Get specific event data + data = dataset.get_event_data(manufacturer, event_id) + + # Create a new model or load from file + model_path = Path(f'./models/m{manufacturer}/event_{event_id}/{config_name}') + + if model_path.exists() and load_from_file: + model = FaultDetector() + model.load_models(model_path) + if (model_path / 'ts_features.txt').exists(): + with open(model_path / 'ts_features.txt', 'r') as f: + ts_features = f.read().splitlines() + else: + # Prepare data and config + train_data = data['train_data'] + bottleneck = calculate_bottleneck(train_data, local_conf, bottleneck_ratio) + local_conf['train']['autoencoder']['params']['code_size'] = bottleneck + if ts_features: + train_data = add_cyclic_time_features(train_data, ts_features) + + model = FaultDetector(local_conf, model_directory=model_path) + model_data = model.fit(train_data, data['train_normal_flag'], save_models=True, overwrite_models=True) + if ts_features: + # save the time features as well + with open(Path(model_data.model_path) / 'ts_features.txt', 'w') as f: + f.write('\n'.join(ts_features)) + + # Predict + test_data = data['test_data'] + if ts_features: + test_data = add_cyclic_time_features(test_data, ts_features) + predictions = model.predict(test_data) + + return event_id, predictions + + +def add_cyclic_time_features(df: pd.DataFrame, features: List[str]) -> pd.DataFrame: + """Calculates cyclical time features from the timestamp index.""" + df = df.copy() + if 'hour_of_day' in features: + phase = df.index.hour / 24 + df['hour_of_day_sine'] = np.sin(2 * np.pi * phase) + df['hour_of_day_cosine'] = np.cos(2 * np.pi * phase) + if 'day_of_week' in features: + phase = df.index.day_of_week / 7 + df['day_of_week_sine'] = np.sin(2 * np.pi * phase) + df['day_of_week_cosine'] = np.cos(2 * np.pi * phase) + if 'day_of_year' in features: + phase = df.index.dayofyear / (365 + df.index.is_leap_year) + df['day_of_year_sine'] = np.sin(2 * np.pi * phase) + df['day_of_year_cosine'] = np.cos(2 * np.pi * phase) + return df + + +def calculate_bottleneck(df: pd.DataFrame, config: Config, ratio: float = 0.75) -> int: + """Calculates code_size relative to input dimensions, accounting for exclusions/conditions.""" + ae_params = config['train']['autoencoder']['params'] + cond_features = ae_params.get('conditional_features', []) + + # Exclude conditions and existing data_preprocessor exclusions + input_dim = len(df.columns) - len([c for c in cond_features if c in df.columns]) + + # Check for manual feature exclusions in config + dp_params = config['train'].get('data_preprocessor', {}).get('params', {}) + excluded = dp_params.get('features_to_exclude', []) + input_dim -= len([e for e in excluded if e in df.columns]) + + return max(1, round(input_dim * ratio)) + + +def find_optimal_threshold(true_anomalies: pd.Series, + max_criticalities: pd.Series, + thresholds: np.ndarray = np.arange(1, 100), + k: int = 5) -> int: + """Finds the threshold maximizing reliability (Event-wise F0.5) using CV. + + Args: + true_anomalies (pd.Series): Series indicating whether each event is an anomaly. 1 = anomaly, 0 = normal. + max_criticalities (pd.Series): Series containing the maximum criticality of each event. + thresholds (np.ndarray, optional): Array of thresholds to evaluate. Defaults to np.arange(1, 100). + k (int, optional): Number of folds for CV. Defaults to 5. + + Returns: + Optimal criticality threshold. + """ + y_true = true_anomalies.values + skf = StratifiedKFold(n_splits=k, shuffle=True, random_state=42) + + results = [] + for t in thresholds: + fold_f05 = [] + y_pred = (max_criticalities >= t).astype(int).values + + for train_idx, val_idx in skf.split(y_true, y_true): + score = fbeta_score(y_true[val_idx], y_pred[val_idx], beta=0.5, zero_division=0) + fold_f05.append(score) + + results.append({'threshold': t, 'mean_f05': np.mean(fold_f05)}) + + best_t = max(results, key=lambda x: x['mean_f05'])['threshold'] + return best_t + + +def get_arcana_importances(manufacturer: int, event_id: int, config_name: str, data: pd.DataFrame) -> pd.Series: + + model_path = Path(f'models/m{manufacturer}/event_{event_id}/{config_name}') + model = FaultDetector() + model.load_models(model_path) + if (model_path / 'ts_features.txt').exists(): + with open(model_path / 'ts_features.txt', 'r') as f: + ts_features = f.read().splitlines() + data = add_cyclic_time_features(data, ts_features) + bias, _, _ = model.run_root_cause_analysis(data, track_losses=False, track_bias=False) + return calculate_mean_arcana_importances(bias).sort_values(ascending=False) From ebc30c484c87ad046ac031cdd9af8289b7ccc753 Mon Sep 17 00:00:00 2001 From: croelofs <25582572+roelofsc@users.noreply.github.com> Date: Fri, 9 Jan 2026 09:07:13 +0100 Subject: [PATCH 02/10] Fix bug in `quick_fault_detection` --- .../quick_fault_detection/configuration.py | 31 +- .../quick_fault_detection/optimization.py | 3 + notebooks/PreDist/PreDist.ipynb | 302 +++++++++++++++--- notebooks/PreDist/predist_utils.py | 36 +++ 4 files changed, 329 insertions(+), 43 deletions(-) diff --git a/energy_fault_detector/quick_fault_detection/configuration.py b/energy_fault_detector/quick_fault_detection/configuration.py index 412199d..cf65608 100644 --- a/energy_fault_detector/quick_fault_detection/configuration.py +++ b/energy_fault_detector/quick_fault_detection/configuration.py @@ -68,10 +68,37 @@ def update_preprocessor_config(config: Config, features_to_exclude: Union[List[s Returns: Config: Updated config object. """ + if features_to_exclude is not None: - config['train']['data_preprocessor']['params']['features_to_exclude'] = features_to_exclude + if config['train']['data_preprocessor'].get('params'): + # old data preprocessing configuration style + config['train']['data_preprocessor']['params']['features_to_exclude'] = features_to_exclude + else: + # new configuration style + steps = config['train']['data_preprocessor'].setdefault('steps', []) + column_selector_found = False + for step in steps: + if step['name'] == 'column_selector': + step['params']['features_to_exclude'] = features_to_exclude + column_selector_found = True + break + if not column_selector_found: + steps.append({'name': 'column_selector', 'params': {'features_to_exclude': features_to_exclude}}) if angles is not None: - config['train']['data_preprocessor']['params']['angles'] = angles + if config['train']['data_preprocessor'].get('params'): + # old data preprocessing configuration style + config['train']['data_preprocessor']['params']['angles'] = angles + else: + # new configuration style + steps = config['train']['data_preprocessor'].setdefault('steps', []) + angle_transformer_found = False + for step in steps: + if step['name'] == 'angle_transformer': + step['params']['angles'] = angles + angle_transformer_found = True + break + if not angle_transformer_found: + steps.append({'name': 'angle_transformer', 'params': {'angles': angles}}) return config diff --git a/energy_fault_detector/quick_fault_detection/optimization.py b/energy_fault_detector/quick_fault_detection/optimization.py index a8de03c..fcadc2f 100644 --- a/energy_fault_detector/quick_fault_detection/optimization.py +++ b/energy_fault_detector/quick_fault_detection/optimization.py @@ -127,6 +127,9 @@ def reconstruction_mse(trial: op.Trial) -> float: deviations = training_dict.val_recon_error score = float(np.mean((np.square(deviations)))) + # help garbage collection + del model + return score study = op.create_study(sampler=op.samplers.TPESampler(), diff --git a/notebooks/PreDist/PreDist.ipynb b/notebooks/PreDist/PreDist.ipynb index f8ef82d..c1a660f 100644 --- a/notebooks/PreDist/PreDist.ipynb +++ b/notebooks/PreDist/PreDist.ipynb @@ -13,8 +13,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-08T12:10:00.352157Z", - "start_time": "2026-01-08T12:09:52.718327900Z" + "end_time": "2026-01-08T12:27:58.369133600Z", + "start_time": "2026-01-08T12:27:51.629034100Z" } }, "cell_type": "code", @@ -52,8 +52,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-08T12:10:00.401341700Z", - "start_time": "2026-01-08T12:10:00.352934Z" + "end_time": "2026-01-08T12:27:58.441405400Z", + "start_time": "2026-01-08T12:27:58.370132100Z" } }, "cell_type": "code", @@ -415,8 +415,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-08T12:10:00.530885300Z", - "start_time": "2026-01-08T12:10:00.438434900Z" + "end_time": "2026-01-08T12:27:58.579565800Z", + "start_time": "2026-01-08T12:27:58.479155900Z" } }, "cell_type": "code", @@ -450,7 +450,8 @@ { "metadata": { "ExecuteTime": { - "start_time": "2026-01-08T12:10:00.633173600Z" + "end_time": "2026-01-08T12:44:18.510142700Z", + "start_time": "2026-01-08T12:27:58.648316300Z" } }, "cell_type": "code", @@ -459,7 +460,7 @@ "from joblib import Parallel, delayed\n", "\n", "\n", - "# To test:\n", + "# Select which dataset(s) and model configs to test:\n", "manufacturers = [1, 2] # [1, 2]\n", "models = ['default_ae', 'cond_ae'] # ['default_ae', 'cond_ae', 'doy_ae']\n", "\n", @@ -499,17 +500,49 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 20 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 27.7s\n", - "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 37.4s\n", - "[Parallel(n_jobs=-1)]: Done 21 tasks | elapsed: 42.3s\n", - "[Parallel(n_jobs=-1)]: Done 32 out of 64 | elapsed: 4.7min remaining: 4.7min\n", - "[Parallel(n_jobs=-1)]: Done 39 out of 64 | elapsed: 5.2min remaining: 3.3min\n", - "[Parallel(n_jobs=-1)]: Done 46 out of 64 | elapsed: 7.7min remaining: 3.0min\n", - "[Parallel(n_jobs=-1)]: Done 53 out of 64 | elapsed: 8.0min remaining: 1.7min\n" + "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 38.7s\n", + "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 41.7s\n", + "[Parallel(n_jobs=-1)]: Done 21 tasks | elapsed: 44.4s\n", + "[Parallel(n_jobs=-1)]: Done 32 out of 64 | elapsed: 47.9s remaining: 47.9s\n", + "[Parallel(n_jobs=-1)]: Done 39 out of 64 | elapsed: 49.8s remaining: 31.9s\n", + "[Parallel(n_jobs=-1)]: Done 46 out of 64 | elapsed: 51.9s remaining: 20.2s\n", + "[Parallel(n_jobs=-1)]: Done 53 out of 64 | elapsed: 55.1s remaining: 11.3s\n", + "[Parallel(n_jobs=-1)]: Done 60 out of 64 | elapsed: 55.6s remaining: 3.6s\n", + "[Parallel(n_jobs=-1)]: Done 64 out of 64 | elapsed: 56.1s finished\n", + "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 20 concurrent workers.\n", + "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 3.7s\n", + "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 4.9s\n", + "[Parallel(n_jobs=-1)]: Done 21 tasks | elapsed: 8.6s\n", + "[Parallel(n_jobs=-1)]: Done 32 out of 64 | elapsed: 10.8s remaining: 10.8s\n", + "[Parallel(n_jobs=-1)]: Done 39 out of 64 | elapsed: 12.0s remaining: 7.6s\n", + "[Parallel(n_jobs=-1)]: Done 46 out of 64 | elapsed: 14.9s remaining: 5.8s\n", + "[Parallel(n_jobs=-1)]: Done 53 out of 64 | elapsed: 15.8s remaining: 3.2s\n", + "[Parallel(n_jobs=-1)]: Done 60 out of 64 | elapsed: 16.8s remaining: 1.0s\n", + "[Parallel(n_jobs=-1)]: Done 64 out of 64 | elapsed: 17.2s finished\n", + "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 20 concurrent workers.\n", + "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 3.0s\n", + "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 3.5s\n", + "[Parallel(n_jobs=-1)]: Done 23 out of 56 | elapsed: 6.8s remaining: 9.8s\n", + "[Parallel(n_jobs=-1)]: Done 29 out of 56 | elapsed: 7.7s remaining: 7.2s\n", + "[Parallel(n_jobs=-1)]: Done 35 out of 56 | elapsed: 8.7s remaining: 5.2s\n", + "[Parallel(n_jobs=-1)]: Done 41 out of 56 | elapsed: 11.2s remaining: 4.0s\n", + "[Parallel(n_jobs=-1)]: Done 47 out of 56 | elapsed: 11.6s remaining: 2.1s\n", + "[Parallel(n_jobs=-1)]: Done 53 out of 56 | elapsed: 1.7min remaining: 5.8s\n", + "[Parallel(n_jobs=-1)]: Done 56 out of 56 | elapsed: 1.8min finished\n", + "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 20 concurrent workers.\n", + "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 43.9s\n", + "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 1.1min\n", + "[Parallel(n_jobs=-1)]: Done 23 out of 56 | elapsed: 2.8min remaining: 4.0min\n", + "[Parallel(n_jobs=-1)]: Done 29 out of 56 | elapsed: 4.6min remaining: 4.3min\n", + "[Parallel(n_jobs=-1)]: Done 35 out of 56 | elapsed: 6.9min remaining: 4.1min\n", + "[Parallel(n_jobs=-1)]: Done 41 out of 56 | elapsed: 10.3min remaining: 3.8min\n", + "[Parallel(n_jobs=-1)]: Done 47 out of 56 | elapsed: 12.0min remaining: 2.3min\n", + "[Parallel(n_jobs=-1)]: Done 53 out of 56 | elapsed: 12.7min remaining: 43.1s\n", + "[Parallel(n_jobs=-1)]: Done 56 out of 56 | elapsed: 13.3min finished\n" ] } ], - "execution_count": null + "execution_count": 4 }, { "metadata": {}, @@ -521,7 +554,12 @@ "id": "3c0ee0eeabed5068" }, { - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-08T12:44:22.788242600Z", + "start_time": "2026-01-08T12:44:18.928865700Z" + } + }, "cell_type": "code", "source": [ "max_criticality_results = {}\n", @@ -557,7 +595,7 @@ ], "id": "4f741a688f149cd7", "outputs": [], - "execution_count": null + "execution_count": 5 }, { "metadata": {}, @@ -566,7 +604,12 @@ "id": "ae299a2f61b2f5a5" }, { - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-08T12:44:23.238074100Z", + "start_time": "2026-01-08T12:44:22.871012900Z" + } + }, "cell_type": "code", "source": [ "for manufacturer in results.keys():\n", @@ -594,8 +637,77 @@ " )\n" ], "id": "3b5c248383e4592e", - "outputs": [], - "execution_count": null + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Manufacturer m1\n", + "Model default_ae:\n", + "Reliability: 0.86, Precision: 1.00, Recall: 0.55\n", + "Model cond_ae:\n", + "Reliability: 0.86, Precision: 0.95, Recall: 0.62\n", + "Manufacturer m2\n", + "Model default_ae:\n", + "Reliability: 0.66, Precision: 0.68, Recall: 0.58\n", + "Model cond_ae:\n", + "Reliability: 0.71, Precision: 0.78, Recall: 0.54\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + } + ], + "execution_count": 6 }, { "metadata": {}, @@ -604,7 +716,12 @@ "id": "570ebfedc795dd61" }, { - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-08T12:44:23.257405Z", + "start_time": "2026-01-08T12:44:23.238074100Z" + } + }, "cell_type": "code", "source": [ "manufacturer = 1\n", @@ -616,8 +733,33 @@ "dataset.events[manufacturer].loc[event_id]" ], "id": "a761ecfa7874e175", - "outputs": [], - "execution_count": null + "outputs": [ + { + "data": { + "text/plain": [ + "substation ID 18\n", + "Report date 2019-05-04 07:19:00\n", + "Problem EN no DHW\n", + "Event description EN The DHW controller was set to night mode. Rese...\n", + "Possible anomaly start 2019-05-03 11:00:00\n", + "Possible anomaly end 2019-05-05 07:19:00\n", + "Training start 2016-12-16 10:00:00\n", + "Training end 2019-04-20 07:19:00\n", + "efd_possible True\n", + "Fault label Control unit: Incorrect parameterisation\n", + "Monitoring potential 4\n", + "Event type anomaly\n", + "Event end 2019-05-04 07:19:00\n", + "Event start NaT\n", + "Name: 49, dtype: object" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 7 }, { "metadata": {}, @@ -626,7 +768,12 @@ "id": "e1d0ace838ed0d5f" }, { - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-08T12:44:23.423567300Z", + "start_time": "2026-01-08T12:44:23.288919900Z" + } + }, "cell_type": "code", "source": [ "predictions = results[manufacturer][config_name][event_id]\n", @@ -642,8 +789,32 @@ "ax.set_xlabel('')" ], "id": "5236c23c789fdd72", - "outputs": [], - "execution_count": null + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, '')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + } + ], + "execution_count": 8 }, { "metadata": {}, @@ -652,7 +823,12 @@ "id": "814da89e48b3860c" }, { - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-08T12:44:35.723922500Z", + "start_time": "2026-01-08T12:44:23.466997300Z" + } + }, "cell_type": "code", "source": [ "test_data = dataset.get_event_data(manufacturer, event_id)['test_data']\n", @@ -671,11 +847,39 @@ "top_features" ], "id": "b8a234e31eeecc66", - "outputs": [], - "execution_count": null + "outputs": [ + { + "data": { + "text/plain": [ + "s_dhw_supply_temperature_setpoint 0.405723\n", + "p_net_meter_flow 0.099440\n", + "p_net_return_temperature 0.092462\n", + "p_hc1_return_temperature 0.075755\n", + "p_net_meter_heat_power 0.074011\n", + "s_dhw_lower_storage_temperature 0.073638\n", + "s_dhw_upper_storage_temperature 0.058171\n", + "p_net_supply_temperature 0.039459\n", + "outdoor_temperature 0.034128\n", + "s_dhw_supply_temperature 0.028003\n", + "s_hc1_supply_temperature 0.010396\n", + "s_hc1_supply_temperature_setpoint 0.008813\n", + "dtype: float32" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 9 }, { - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-08T12:44:36.211049200Z", + "start_time": "2026-01-08T12:44:35.945780300Z" + } + }, "cell_type": "code", "source": [ "# Plot the reconstruction of the top 3\n", @@ -687,16 +891,32 @@ "ax[0].legend(loc='upper left')" ], "id": "d0cbfbada56ec052", - "outputs": [], - "execution_count": null - }, - { - "metadata": {}, - "cell_type": "code", - "source": "", - "id": "ef36d5c93501b213", - "outputs": [], - "execution_count": null + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + } + ], + "execution_count": 10 } ], "metadata": { diff --git a/notebooks/PreDist/predist_utils.py b/notebooks/PreDist/predist_utils.py index c42cebf..d2d19ab 100644 --- a/notebooks/PreDist/predist_utils.py +++ b/notebooks/PreDist/predist_utils.py @@ -2,9 +2,11 @@ from pathlib import Path from copy import deepcopy import logging +import gc import pandas as pd import numpy as np +import tensorflow as tf from sklearn.model_selection import StratifiedKFold from sklearn.metrics import fbeta_score @@ -63,6 +65,11 @@ def train_or_get_model(event_id: int, dataset: PreDistDataset, manufacturer: int test_data = add_cyclic_time_features(test_data, ts_features) predictions = model.predict(test_data) + # memory cleanup + del model + tf.keras.backend.clear_session() + gc.collect() + return event_id, predictions @@ -144,3 +151,32 @@ def get_arcana_importances(manufacturer: int, event_id: int, config_name: str, d data = add_cyclic_time_features(data, ts_features) bias, _, _ = model.run_root_cause_analysis(data, track_losses=False, track_bias=False) return calculate_mean_arcana_importances(bias).sort_values(ascending=False) + + +def calculate_earliness(criticality_threshold: int, report_ts: int | pd.Timestamp, criticality: pd.Series, + min_detection_time: pd.Timedelta = pd.Timedelta(hours=24) + ) -> Tuple[int | pd.Timestamp | None, float]: + """Calculate the detection time and earliness score. + + Args: + criticality_threshold (int): Threshold for determining whether the event is detected. + report_ts (int | pd.Timestamp): Timestamp of the report. + criticality (pd.Series): Series containing the criticality of each event. + min_detection_time (pd.Timedelta, optional): Minimum detection time. Defaults to pd.Timedelta(hours=24). + + Returns: + A tuple containing the detection time and earliness score. If not detected, the detection time is None and + the earliness score is 0. + """ + + crit_threshold_reached = criticality[criticality >= criticality_threshold] + if crit_threshold_reached.empty: + detection_time = None + earliness = 0 + return detection_time, earliness + + detection_timestamp = crit_threshold_reached.sort_index(ascending=True).index[0] + detection_time = report_ts - detection_timestamp + # max(earliness, 0) to handle detection after fault is known + earliness = max(min(1, detection_time / min_detection_time), 0) + return detection_time, earliness From 9d2b602305842270ab1a274655d67036671c03b2 Mon Sep 17 00:00:00 2001 From: croelofs <25582572+roelofsc@users.noreply.github.com> Date: Fri, 9 Jan 2026 09:59:20 +0100 Subject: [PATCH 03/10] Accept pathlib.Path for file paths as well. Some refactoring: Moving from os.path to pathlib.Path for file handling (wip). --- energy_fault_detector/core/__init__.py | 9 +- energy_fault_detector/{ => core}/_logs.py | 17 ++-- .../core/fault_detection_model.py | 19 ++-- .../core/fault_detection_result.py | 87 ++++++++++++++++--- energy_fault_detector/fault_detector.py | 11 +-- energy_fault_detector/main.py | 21 ++--- .../quick_fault_detector.py | 7 +- tests/core/test_fault_detection_result.py | 73 ++++++++++++++++ 8 files changed, 192 insertions(+), 52 deletions(-) rename energy_fault_detector/{ => core}/_logs.py (56%) create mode 100644 tests/core/test_fault_detection_result.py diff --git a/energy_fault_detector/core/__init__.py b/energy_fault_detector/core/__init__.py index 47eca0d..5229541 100644 --- a/energy_fault_detector/core/__init__.py +++ b/energy_fault_detector/core/__init__.py @@ -1,7 +1,8 @@ """This module contains class templates for most of the anomaly detection classes, such as autoencoders, anomaly scores, threshold selectors and data classes.""" -from energy_fault_detector.core.anomaly_score import AnomalyScore -from energy_fault_detector.core.autoencoder import Autoencoder -from energy_fault_detector.core.data_transformer import DataTransformer -from energy_fault_detector.core.threshold_selector import ThresholdSelector +from .anomaly_score import AnomalyScore +from .autoencoder import Autoencoder +from .data_transformer import DataTransformer +from .threshold_selector import ThresholdSelector +from .fault_detection_result import FaultDetectionResult, ModelMetadata \ No newline at end of file diff --git a/energy_fault_detector/_logs.py b/energy_fault_detector/core/_logs.py similarity index 56% rename from energy_fault_detector/_logs.py rename to energy_fault_detector/core/_logs.py index 2cd2a36..2a68147 100644 --- a/energy_fault_detector/_logs.py +++ b/energy_fault_detector/core/_logs.py @@ -1,34 +1,35 @@ """Logging settings""" import os +from pathlib import Path import logging.config as logging_config import yaml -def setup_logging(default_path: str = 'logging.yaml', env_key: str = 'LOG_CFG') -> None: +def setup_logging(default_path: str | Path = 'logging.yaml', env_key: str = 'LOG_CFG') -> None: """Setup logging configuration Args: - default_path (str): default logging configuration file. Default is 'logging.yaml' + default_path (str or Path): default logging configuration file. Default is 'logging.yaml' env_key (str): Environment variable holding logging config file path (overrides default_path). Default is 'LOG_CFG' """ - path = default_path + path = Path(default_path) value = os.getenv(env_key, None) if value: - path = value + path = Path(value) try: with open(path, 'rt', encoding='utf-8') as f: config = yaml.safe_load(f.read()) # check paths exist or create them: for _, handler in config['handlers'].items(): - if handler.get('filename'): - dirname = os.path.dirname(handler['filename']) - if dirname != '' and not os.path.exists(dirname): - os.makedirs(dirname) + filename = handler.get('filename') + if filename: + # Resolve path and create parent directories if they don't exist + Path(filename).parent.mkdir(parents=True, exist_ok=True) logging_config.dictConfig(config) except Exception as e: diff --git a/energy_fault_detector/core/fault_detection_model.py b/energy_fault_detector/core/fault_detection_model.py index 0aed66b..cd575bb 100644 --- a/energy_fault_detector/core/fault_detection_model.py +++ b/energy_fault_detector/core/fault_detection_model.py @@ -2,9 +2,10 @@ import os from abc import ABC, abstractmethod -from typing import Any, Optional, Union, List, Tuple +from typing import Optional, Union, List, Tuple import logging from datetime import datetime +from pathlib import Path import pandas as pd import numpy as np @@ -16,10 +17,10 @@ from energy_fault_detector.core.model_factory import ModelFactory from energy_fault_detector.core.fault_detection_result import ModelMetadata, FaultDetectionResult from energy_fault_detector.data_preprocessing import DataPreprocessor -from energy_fault_detector._logs import setup_logging +from energy_fault_detector.core._logs import setup_logging from energy_fault_detector.data_splitting.data_splitter import BlockDataSplitter -setup_logging(os.path.join(os.path.dirname(__file__), '..', 'logging.yaml')) +setup_logging(Path(__file__).parent.parent / 'logging.yaml') logger = logging.getLogger('energy_fault_detector') DATA_PREP_DIR = 'data_preprocessor' @@ -28,6 +29,8 @@ SCORE_DIR = 'anomaly_score' DataType = Union[pd.DataFrame, np.ndarray, List] +PathLike = Union[str, Path] +ModelPart = Union[DataPreprocessor, Autoencoder, AnomalyScore, ThresholdSelector] class NoTrainingData(Exception): @@ -50,9 +53,9 @@ class FaultDetectionModel(ABC): save_timestamps: a list of string timestamps, indicating when the model was saved. """ - def __init__(self, config: Optional[Config] = None, model_directory: str = 'models'): + def __init__(self, config: Optional[Config] = None, model_directory: PathLike = 'models'): self.config: Optional[Config] = config - self.model_directory: str = model_directory + self.model_directory: PathLike = model_directory self.anomaly_score: Optional[AnomalyScore] = None self.autoencoder: Optional[Autoencoder] = None @@ -191,11 +194,11 @@ def save_models(self, model_name: Union[str, int] = None, overwrite: bool = Fals return os.path.abspath(model_dir), current_datetime - def load_models(self, model_path: str) -> None: + def load_models(self, model_path: PathLike) -> None: """Load saved models given the model path. Args: - model_path: Path to the model files. + model_path (str, Path): Path to the model files. """ data_prep_dir = os.path.join(model_path, DATA_PREP_DIR) @@ -221,7 +224,7 @@ def load_models(self, model_path: str) -> None: self._model_factory = ModelFactory(self.config) @staticmethod - def _load_pickled_model(model_type: str, model_directory: str): + def _load_pickled_model(model_type: str, model_directory: str) -> ModelPart: """Load a pickled model of given type, using file name (which is the class name).""" model_class_name = os.listdir(model_directory)[0].split('.')[0] if model_type != 'data_preprocessor': diff --git a/energy_fault_detector/core/fault_detection_result.py b/energy_fault_detector/core/fault_detection_result.py index a1a45f1..05b4633 100644 --- a/energy_fault_detector/core/fault_detection_result.py +++ b/energy_fault_detector/core/fault_detection_result.py @@ -1,7 +1,7 @@ -import os from typing import Optional, List from dataclasses import dataclass +from pathlib import Path import pandas as pd import numpy as np @@ -36,36 +36,95 @@ class FaultDetectionResult: """List of DataFrames containing the ARCANA bias every 50th iteration. None if ARCANA was not run. Empty if bias was not tracked.""" - def criticality(self, normal_idx: pd.Series = None, init_criticality: int = 0, max_criticality: int = 1000 + def criticality(self, normal_idx: pd.Series | None, init_criticality: int = 0, max_criticality: int = 1000 ) -> pd.Series: - """Criticality based on the predicted anomalies.""" + """Criticality based on the predicted anomalies. + + Args: + normal_idx (pd.Series, optional): A pandas Series with boolean values indicating normal operation, indexed + by timestamp. Ignored if None. + init_criticality (int, optional): The initial criticality value. Defaults to 0. + max_criticality (int, optional): The maximum criticality value. Defaults to 1000. + + """ return calculate_criticality(self.predicted_anomalies, normal_idx, init_criticality, max_criticality) - def save(self, directory: str, **kwargs) -> None: + def save(self, directory: str | Path, **kwargs) -> None: """Saves the results to CSV files in the specified directory. Args: directory (str): The directory where the CSV files will be saved. - kwargs: other keywords args for `pd.DataFrame.to_csv` + kwargs: other keywords args for `pd.DataFrame.to_csv` (i.e. sep=',') """ # Ensure the directory exists - os.makedirs(directory, exist_ok=True) + directory = Path(directory) + directory.mkdir(exist_ok=True, parents=True) # Save each DataFrame as a CSV file - self.predicted_anomalies.to_csv(os.path.join(directory, 'predicted_anomalies.csv'), **kwargs) - self.reconstruction.to_csv(os.path.join(directory, 'reconstruction.csv'), **kwargs) - self.recon_error.to_csv(os.path.join(directory, 'reconstruction_errors.csv'), **kwargs) - self.anomaly_score.to_csv(os.path.join(directory, 'anomaly_scores.csv'), **kwargs) + self.predicted_anomalies.to_csv(directory / 'predicted_anomalies.csv', **kwargs) + self.reconstruction.to_csv(directory / 'reconstruction.csv', **kwargs) + self.recon_error.to_csv(directory / 'reconstruction_errors.csv', **kwargs) + self.anomaly_score.to_csv(directory / 'anomaly_scores.csv', **kwargs) if self.bias_data is not None: - self.bias_data.to_csv(os.path.join(directory, 'bias_data.csv'), **kwargs) + self.bias_data.to_csv(directory / 'bias_data.csv', **kwargs) if self.arcana_losses is not None: - self.arcana_losses.to_csv(os.path.join(directory, 'arcana_losses.csv'), **kwargs) + self.arcana_losses.to_csv(directory / 'arcana_losses.csv', **kwargs) if self.tracked_bias is not None and len(self.tracked_bias) > 0: for idx, bias_df in enumerate(self.tracked_bias): - bias_df.to_csv(os.path.join(directory, f'tracked_bias_{idx}.csv'), **kwargs) + bias_df.to_csv(directory / f'tracked_bias_{idx}.csv', **kwargs) + + @classmethod + def load(cls, directory: str | Path, **kwargs) -> "FaultDetectionResult": + """Loads the results from CSV files in the specified directory. + + Args: + directory (str | Path): The directory where the CSV files are stored. + kwargs: other keywords args for `pd.read_csv` (e.g., sep=',') + + Returns: + FaultDetectionResult: The loaded result object. + """ + directory = Path(directory) + + # Default pandas loading arguments to ensure indices are restored correctly + params = {'index_col': 0, 'parse_dates': True} + params.update(kwargs) + + # Load mandatory fields + predicted_anomalies = pd.read_csv(directory / 'predicted_anomalies.csv', **params).iloc[:, 0] + # Ensure predicted_anomalies is explicitly a Series and boolean + predicted_anomalies = predicted_anomalies.astype(bool) + + reconstruction = pd.read_csv(directory / 'reconstruction.csv', **params) + recon_error = pd.read_csv(directory / 'reconstruction_errors.csv', **params) + anomaly_score = pd.read_csv(directory / 'anomaly_scores.csv', **params).iloc[:, 0] + + # Load optional fields if they exist + bias_data = None + if (directory / 'bias_data.csv').exists(): + bias_data = pd.read_csv(directory / 'bias_data.csv', **params) + + arcana_losses = None + if (directory / 'arcana_losses.csv').exists(): + arcana_losses = pd.read_csv(directory / 'arcana_losses.csv', **params) + + tracked_bias = None + tracked_files = sorted(directory.glob('tracked_bias_*.csv')) + if tracked_files: + tracked_bias = [pd.read_csv(f, **params) for f in tracked_files] + + return cls( + predicted_anomalies=predicted_anomalies, + reconstruction=reconstruction, + recon_error=recon_error, + anomaly_score=anomaly_score, + bias_data=bias_data, + arcana_losses=arcana_losses, + tracked_bias=tracked_bias + ) @dataclass @@ -73,6 +132,6 @@ class ModelMetadata: """Class to encapsulate metadata about the FaultDetector model.""" model_date: str - model_path: str + model_path: str | Path train_recon_error: np.ndarray val_recon_error: Optional[np.ndarray] = None diff --git a/energy_fault_detector/fault_detector.py b/energy_fault_detector/fault_detector.py index 30891d5..33710ba 100644 --- a/energy_fault_detector/fault_detector.py +++ b/energy_fault_detector/fault_detector.py @@ -3,23 +3,24 @@ import logging from typing import Optional, Tuple, List from datetime import datetime -import os import warnings +from pathlib import Path import pandas as pd import numpy as np from tensorflow.keras.backend import clear_session from energy_fault_detector.core.fault_detection_model import FaultDetectionModel +from energy_fault_detector.core.fault_detection_result import FaultDetectionResult, ModelMetadata from energy_fault_detector.threshold_selectors import AdaptiveThresholdSelector from energy_fault_detector.data_preprocessing.data_preprocessor import DataPreprocessor from energy_fault_detector.data_preprocessing.data_clipper import DataClipper from energy_fault_detector.root_cause_analysis import Arcana from energy_fault_detector.config import Config -from energy_fault_detector._logs import setup_logging -from energy_fault_detector.core.fault_detection_result import FaultDetectionResult, ModelMetadata +from energy_fault_detector.core._logs import setup_logging + -setup_logging(os.path.join(os.path.dirname(__file__), 'logging.yaml')) +setup_logging(Path(__file__).parent / 'logging.yaml') logger = logging.getLogger('energy_fault_detector') @@ -41,7 +42,7 @@ class FaultDetector(FaultDetectionModel): save_timestamps: a list of string timestamps indicating when the model was saved. """ - def __init__(self, config: Optional[Config] = None, model_directory: str = 'fault_detector_model', + def __init__(self, config: Optional[Config] = None, model_directory: str | Path = 'fault_detector_model', model_subdir: Optional[str] = None): if model_subdir is not None: warnings.warn( diff --git a/energy_fault_detector/main.py b/energy_fault_detector/main.py index 3f379dd..a87120a 100644 --- a/energy_fault_detector/main.py +++ b/energy_fault_detector/main.py @@ -1,19 +1,19 @@ """Quick energy fault detector CLI tool, to try out the EnergyFaultDetector model on a specific dataset.""" -import os import argparse import logging import yaml +from pathlib import Path from dataclasses import dataclass, field from typing import List, Optional logger = logging.getLogger('energy_fault_detector') -here = os.path.abspath(os.path.dirname(__file__)) +here = Path(__file__).resolve().parent @dataclass class Options: - csv_test_data_path: Optional[str] = None + csv_test_data_path: Optional[str | Path] = None train_test_column_name: Optional[str] = None train_test_mapping: Optional[dict] = None time_column_name: Optional[str] = None @@ -27,7 +27,7 @@ class Options: enable_debug_plots: bool = False -def load_options_from_yaml(file_path: str) -> Options: +def load_options_from_yaml(file_path: str | Path) -> Options: """Load options from a YAML file and return an Options dataclass.""" with open(file_path, 'r') as file: options_dict = yaml.safe_load(file) @@ -76,19 +76,19 @@ def main(): parser.add_argument( 'csv_data_path', - type=str, + type=Path, help='Path to a CSV file containing training data.' ) parser.add_argument( '--options', - type=str, + type=Path, help='Path to a YAML file containing additional options.', default=None, required=False, ) parser.add_argument( '--results_dir', - type=str, + type=Path, help='Path to a directory where results will be saved.', default='results' ) @@ -107,13 +107,13 @@ def main(): logger.info(f"Options YAML: {args.options}") logger.info(f"Results Directory: {args.results_dir}") - os.makedirs(args.results_dir, exist_ok=True) + args.results_dir.mkdir(exist_ok=True) options = Options() # Initialize with default values if args.options: options = load_options_from_yaml(args.options) elif args.c2c_example: - options = load_options_from_yaml(os.path.join(here, 'c2c_options.yaml')) + options = load_options_from_yaml(here / 'c2c_options.yaml') print(options) @@ -138,10 +138,11 @@ def main(): ) logger.info(f'Fault detection completed. Results are saved in {args.results_dir}.') prediction_results.save(args.results_dir) - event_meta_data.to_csv(os.path.join(args.results_dir, 'events.csv'), index=False) + event_meta_data.to_csv(args.results_dir / 'events.csv', index=False) except Exception as e: logger.error(f'An error occurred: {e}') + raise if __name__ == '__main__': diff --git a/energy_fault_detector/quick_fault_detection/quick_fault_detector.py b/energy_fault_detector/quick_fault_detection/quick_fault_detector.py index f244de5..dfc82d8 100644 --- a/energy_fault_detector/quick_fault_detection/quick_fault_detector.py +++ b/energy_fault_detector/quick_fault_detection/quick_fault_detector.py @@ -1,12 +1,13 @@ """Quick energy fault detection, to try out the EnergyFaultDetector model on a specific dataset.""" import os +from pathlib import Path import logging from typing import List, Optional, Tuple import pandas as pd -from energy_fault_detector._logs import setup_logging +from energy_fault_detector.core._logs import setup_logging from energy_fault_detector.fault_detector import FaultDetector from energy_fault_detector.utils.analysis import create_events from energy_fault_detector.root_cause_analysis.arcana_utils import calculate_mean_arcana_importances @@ -20,14 +21,14 @@ logger = logging.getLogger('energy_fault_detector') -def quick_fault_detector(csv_data_path: str, csv_test_data_path: Optional[str] = None, +def quick_fault_detector(csv_data_path: str | Path, csv_test_data_path: Optional[str | Path] = None, train_test_column_name: Optional[str] = None, train_test_mapping: Optional[dict] = None, time_column_name: Optional[str] = None, status_data_column_name: Optional[str] = None, status_mapping: Optional[dict] = None, status_label_confidence_percentage: Optional[float] = 0.95, features_to_exclude: Optional[List[str]] = None, angle_features: Optional[List[str]] = None, automatic_optimization: bool = True, enable_debug_plots: bool = False, - min_anomaly_length: int = 18, save_dir: Optional[str] = None + min_anomaly_length: int = 18, save_dir: Optional[str | Path] = None ) -> Tuple[FaultDetectionResult, pd.DataFrame]: """Analyzes provided data using an autoencoder based approach for identifying anomalies based on a learned normal behavior. Anomalies are then aggregated to events and further analyzed. diff --git a/tests/core/test_fault_detection_result.py b/tests/core/test_fault_detection_result.py new file mode 100644 index 0000000..813d688 --- /dev/null +++ b/tests/core/test_fault_detection_result.py @@ -0,0 +1,73 @@ + +import unittest +import tempfile +import pandas as pd +from pathlib import Path + +from energy_fault_detector.core import FaultDetectionResult + + +class TestFaultDetectionResultSaveLoad(unittest.TestCase): + + def setUp(self): + # Create sample data + index = pd.date_range("2023-01-01", periods=5, freq="H") + + self.predicted_anomalies = pd.Series([False, True, False, True, False], index=index, name="anomaly") + self.reconstruction = pd.DataFrame({ + "sensor_1": [1.0, 2.0, 3.0, 4.0, 5.0], + "sensor_2": [2.0, 3.0, 4.0, 5.0, 6.0] + }, index=index) + self.recon_error = pd.DataFrame({ + "sensor_1": [0.1, 0.2, 0.1, 0.3, 0.1], + "sensor_2": [0.2, 0.1, 0.3, 0.1, 0.2] + }, index=index) + self.anomaly_score = pd.Series([0.1, 0.9, 0.2, 0.8, 0.15], index=index, name="score") + + # Optional fields + self.bias_data = pd.DataFrame({"bias": [0.01, 0.02]}, index=index[:2]) + self.arcana_losses = pd.DataFrame({"loss_a": [0.1, 0.2], "loss_b": [0.05, 0.1]}, index=index[:2]) + self.tracked_bias = [ + pd.DataFrame({"bias_step_0": [0.01]}, index=[index[0]]), + pd.DataFrame({"bias_step_1": [0.02]}, index=[index[1]]) + ] + + # Instantiate object + self.fdr = FaultDetectionResult( + predicted_anomalies=self.predicted_anomalies, + reconstruction=self.reconstruction, + recon_error=self.recon_error, + anomaly_score=self.anomaly_score, + bias_data=self.bias_data, + arcana_losses=self.arcana_losses, + tracked_bias=self.tracked_bias + ) + + def test_save_and_load_roundtrip(self): + with tempfile.TemporaryDirectory() as tmp_dir: + tmp_path = Path(tmp_dir) + + # Save result + self.fdr.save(tmp_path) + + # Load result back + loaded_fdr = FaultDetectionResult.load(tmp_path) + + # Compare core attributes + pd.testing.assert_series_equal(loaded_fdr.predicted_anomalies, self.fdr.predicted_anomalies, check_freq=False) + pd.testing.assert_frame_equal(loaded_fdr.reconstruction, self.fdr.reconstruction, check_freq=False) + pd.testing.assert_frame_equal(loaded_fdr.recon_error, self.fdr.recon_error, check_freq=False) + pd.testing.assert_series_equal(loaded_fdr.anomaly_score, self.fdr.anomaly_score, check_freq=False) + + # Compare optional attributes + pd.testing.assert_frame_equal(loaded_fdr.bias_data, self.fdr.bias_data, check_freq=False) + pd.testing.assert_frame_equal(loaded_fdr.arcana_losses, self.fdr.arcana_losses, check_freq=False) + + # Compare tracked_bias list of DataFrames + self.assertEqual(len(loaded_fdr.tracked_bias), len(self.fdr.tracked_bias)) + for loaded_df, original_df in zip(loaded_fdr.tracked_bias, self.fdr.tracked_bias): + pd.testing.assert_frame_equal(loaded_df, original_df, check_freq=False) + + +if __name__ == "__main__": + unittest.main() From 2497a81b9f094360cea344017356596be25e70e8 Mon Sep 17 00:00:00 2001 From: croelofs <25582572+roelofsc@users.noreply.github.com> Date: Fri, 9 Jan 2026 10:00:20 +0100 Subject: [PATCH 04/10] Use float32 as default data type to reduce memory usage (if necessary, change to float64 through config) --- energy_fault_detector/config/config.py | 6 ++++++ energy_fault_detector/fault_detector.py | 5 +++++ 2 files changed, 11 insertions(+) diff --git a/energy_fault_detector/config/config.py b/energy_fault_detector/config/config.py index de26319..65e6101 100644 --- a/energy_fault_detector/config/config.py +++ b/energy_fault_detector/config/config.py @@ -98,6 +98,7 @@ 'train': {'type': 'dict', 'schema': TRAIN_SCHEMA, 'required': False, 'allow_unknown': True}, 'predict': {'type': 'dict', 'schema': PREDICT_SCHEMA, 'required': False}, 'root_cause_analysis': {'type': 'dict', 'schema': ROOT_CAUSE_ANALYSIS_SCHEMA, 'required': False}, + 'dtype': {'type': 'string', 'required': False, 'allowed': ['float32', 'float64']} } @@ -203,3 +204,8 @@ def fit_threshold_on_val(self) -> bool: def verbose(self) -> int: """Verbosity Level of the Autoencoder.""" return self.config_dict.get('train', {}).get('autoencoder', {}).get('verbose', 1) + + @property + def dtype(self): + """Data type, float32 by default.""" + return self.config_dict.get('dtype', 'float32') diff --git a/energy_fault_detector/fault_detector.py b/energy_fault_detector/fault_detector.py index 33710ba..941e743 100644 --- a/energy_fault_detector/fault_detector.py +++ b/energy_fault_detector/fault_detector.py @@ -95,6 +95,10 @@ def preprocess_train_data(self, sensor_data: pd.DataFrame, normal_index: pd.Seri self.data_preprocessor.fit(x_normal) x_prepped = self.data_preprocessor.transform(x_normal) + + # Use float32 by default for performance, unless specified otherwise in config + x_prepped = x_prepped.astype(self.config.dtype) + return x_prepped, x, y def fit(self, sensor_data: pd.DataFrame, normal_index: pd.Series = None, save_models: bool = True, @@ -283,6 +287,7 @@ def predict(self, sensor_data: pd.DataFrame, model_path: Optional[str] = None, logger.debug('No model_path provided; using existing model instances.') x_prepped = self.data_preprocessor.transform(x).sort_index() + x_prepped = x_prepped.astype(self.config.dtype) column_order = x_prepped.columns if self.autoencoder.is_conditional: From 2b9a73c80a35b42074132d5bbc873d0bbd55ddb5 Mon Sep 17 00:00:00 2001 From: croelofs <25582572+roelofsc@users.noreply.github.com> Date: Fri, 9 Jan 2026 11:11:09 +0100 Subject: [PATCH 05/10] Update PreDist configurations and make final log message of the quick fault detector clearer --- energy_fault_detector/main.py | 2 +- notebooks/PreDist/configs/m1_cond_ae.yaml | 6 +++++- notebooks/PreDist/configs/m1_default_ae.yaml | 6 +++++- notebooks/PreDist/configs/m1_doy_ae.yaml | 6 +++++- notebooks/PreDist/configs/m2_cond_ae.yaml | 8 ++++++-- notebooks/PreDist/configs/m2_default_ae.yaml | 8 ++++++-- notebooks/PreDist/configs/m2_doy_ae.yaml | 8 ++++++-- 7 files changed, 34 insertions(+), 10 deletions(-) diff --git a/energy_fault_detector/main.py b/energy_fault_detector/main.py index a87120a..563d9fa 100644 --- a/energy_fault_detector/main.py +++ b/energy_fault_detector/main.py @@ -136,7 +136,7 @@ def main(): min_anomaly_length=options.min_anomaly_length, save_dir=args.results_dir, ) - logger.info(f'Fault detection completed. Results are saved in {args.results_dir}.') + logger.info(f'Fault detection completed. Results are saved in the directory "{args.results_dir}".') prediction_results.save(args.results_dir) event_meta_data.to_csv(args.results_dir / 'events.csv', index=False) diff --git a/notebooks/PreDist/configs/m1_cond_ae.yaml b/notebooks/PreDist/configs/m1_cond_ae.yaml index 534d289..20d2f0c 100644 --- a/notebooks/PreDist/configs/m1_cond_ae.yaml +++ b/notebooks/PreDist/configs/m1_cond_ae.yaml @@ -20,12 +20,16 @@ train: name: conditional verbose: 0 params: + act: prelu + last_act: linear batch_size: 256 code_size: 5 # set by bottleneck ratio (0.65) early_stopping: true + min_delta: 0.0001 + patience: 5 epochs: 100 layers: [64, 32] - learning_rate: 0.00045 + learning_rate: 0.0004486710512068144 noise: 0.05 loss_name: mean_squared_error conditional_features: ['hour_of_day_sine', diff --git a/notebooks/PreDist/configs/m1_default_ae.yaml b/notebooks/PreDist/configs/m1_default_ae.yaml index 01b4293..bd8f9f8 100644 --- a/notebooks/PreDist/configs/m1_default_ae.yaml +++ b/notebooks/PreDist/configs/m1_default_ae.yaml @@ -19,12 +19,16 @@ train: name: default verbose: 0 params: + act: prelu + last_act: linear batch_size: 256 code_size: 5 # set by bottleneck ratio (0.65) early_stopping: true + min_delta: 0.0001 + patience: 5 epochs: 100 layers: [64, 32] - learning_rate: 0.00045 + learning_rate: 0.0004486710512068144 noise: 0.05 loss_name: mean_squared_error diff --git a/notebooks/PreDist/configs/m1_doy_ae.yaml b/notebooks/PreDist/configs/m1_doy_ae.yaml index cb67060..bb5b832 100644 --- a/notebooks/PreDist/configs/m1_doy_ae.yaml +++ b/notebooks/PreDist/configs/m1_doy_ae.yaml @@ -20,12 +20,16 @@ train: name: conditional verbose: 0 params: + act: prelu + last_act: linear batch_size: 256 code_size: 5 # set by bottleneck ratio (0.65) early_stopping: true + min_delta: 0.0001 + patience: 5 epochs: 100 layers: [64, 32] - learning_rate: 0.00045 + learning_rate: 0.0004486710512068144 noise: 0.05 loss_name: mean_squared_error conditional_features: ['hour_of_day_sine', diff --git a/notebooks/PreDist/configs/m2_cond_ae.yaml b/notebooks/PreDist/configs/m2_cond_ae.yaml index 813c503..4f9137c 100644 --- a/notebooks/PreDist/configs/m2_cond_ae.yaml +++ b/notebooks/PreDist/configs/m2_cond_ae.yaml @@ -9,7 +9,7 @@ train: include_duplicate_value_to_nan: false, max_col_zero_frac: 0.5 max_nan_frac_per_col: 0.8 - min_unique_value_count: 3 + min_unique_value_count: 2 scale: standardize features_to_exclude: - p_net_meter_energy # we use power and flow @@ -29,12 +29,16 @@ train: name: conditional verbose: 0 params: + act: prelu + last_act: linear batch_size: 256 code_size: 5 # set by bottleneck ratio (0.25) early_stopping: true + min_delta: 0.0001 + patience: 5 epochs: 100 layers: [64, 32] - learning_rate: 0.00053 + learning_rate: 0.0005289609464733553 noise: 0.15 loss_name: mean_squared_error conditional_features: [ 'hour_of_day_sine', diff --git a/notebooks/PreDist/configs/m2_default_ae.yaml b/notebooks/PreDist/configs/m2_default_ae.yaml index 26d1dde..c5a188e 100644 --- a/notebooks/PreDist/configs/m2_default_ae.yaml +++ b/notebooks/PreDist/configs/m2_default_ae.yaml @@ -9,7 +9,7 @@ train: include_duplicate_value_to_nan: false, max_col_zero_frac: 0.5 max_nan_frac_per_col: 0.8 - min_unique_value_count: 3 + min_unique_value_count: 2 scale: standardize features_to_exclude: - p_net_meter_energy # we use power and flow @@ -28,12 +28,16 @@ train: name: default verbose: 0 params: + act: prelu + last_act: linear batch_size: 256 code_size: 5 # set by bottleneck ratio (0.25) early_stopping: true + min_delta: 0.0001 + patience: 5 epochs: 100 layers: [64, 32] - learning_rate: 0.00053 + learning_rate: 0.0005289609464733553 noise: 0.15 loss_name: mean_squared_error diff --git a/notebooks/PreDist/configs/m2_doy_ae.yaml b/notebooks/PreDist/configs/m2_doy_ae.yaml index fe9370f..c3a6434 100644 --- a/notebooks/PreDist/configs/m2_doy_ae.yaml +++ b/notebooks/PreDist/configs/m2_doy_ae.yaml @@ -9,7 +9,7 @@ train: include_duplicate_value_to_nan: false, max_col_zero_frac: 0.5 max_nan_frac_per_col: 0.8 - min_unique_value_count: 3 + min_unique_value_count: 2 scale: standardize features_to_exclude: - p_net_meter_energy # we use power and flow @@ -29,12 +29,16 @@ train: name: conditional verbose: 0 params: + act: prelu + last_act: linear batch_size: 256 code_size: 5 # set by bottleneck ratio (0.25) early_stopping: true + min_delta: 0.0001 + patience: 5 epochs: 100 layers: [64, 32] - learning_rate: 0.00053 + learning_rate: 0.0005289609464733553 noise: 0.15 loss_name: mean_squared_error conditional_features: [ 'hour_of_day_sine', From e74d93f249d8372a627268abdecadbb3cec7a14b Mon Sep 17 00:00:00 2001 From: croelofs <25582572+roelofsc@users.noreply.github.com> Date: Fri, 9 Jan 2026 11:18:26 +0100 Subject: [PATCH 06/10] Update the README.md --- README.md | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 4d04c94..92de174 100644 --- a/README.md +++ b/README.md @@ -64,7 +64,7 @@ results = fault_detector.predict(sensor_data=test_sensor_data) The pandas `DataFrame` `sensor_data` contains the operational data in wide format with the timestamp as index, the pandas `Series` `normal_index` indicates which timestamps are considered 'normal' operation and can be used to create -a normal behaviour model. The [`base_config.yaml`](energy_fault_detector/base_config.yaml) file contains all model +a normal behaviour model. The [`base_config.yaml`](energy_fault_detector/base_config.yaml) file contains the model settings, an example is found [here](energy_fault_detector/base_config.yaml). @@ -100,12 +100,17 @@ This project is licensed under the [MIT License](./LICENSE). ## References If you use this work, please cite us: +**Fault detection in district heating substations**: +- Enabling Predictive Maintenance in District Heating Substations: A Labelled Dataset and Fault Detection Evaluation Framework based on Service Data. +PrePrint on ArXiv. https://doi.org/10.48550/arXiv.2511.14791 +- Dataset: PreDist Dataset - Operational data of district heating substations labelled with faults and maintenance information. Zenodo, Nov 2025, https://doi.org/10.5281/zenodo.17522254. + **ARCANA Algorithm**: Autoencoder-based anomaly root cause analysis for wind turbines. Energy and AI. 2021;4:100065. https://doi.org/10.1016/j.egyai.2021.100065 **CARE to Compare dataset and CARE-Score**: - Paper: CARE to Compare: A Real-World Benchmark Dataset for Early Fault Detection in Wind Turbine Data. Data. 2024; 9(12):138. https://doi.org/10.3390/data9120138 -- Dataset: Wind Turbine SCADA Data For Early Fault Detection. Zenodo, Mar. 2025, https://doi.org/10.5281/ZENODO.14958989. +- Dataset: Wind Turbine SCADA Data For Early Fault Detection. Zenodo, Oct. 2024, https://doi.org/10.5281/ZENODO.14958989. **Transfer learning methods**: Transfer learning applications for autoencoder-based anomaly detection in wind turbines. Energy and AI. 2024;17:100373. https://doi.org/10.1016/j.egyai.2024.100373 From 41565afe3ca380b83a85ef6256e7d0541caa99f7 Mon Sep 17 00:00:00 2001 From: croelofs <25582572+roelofsc@users.noreply.github.com> Date: Mon, 12 Jan 2026 09:23:59 +0100 Subject: [PATCH 07/10] Fix bug in fault_detection_result.py and add missing column in predist_dataset.py to replace string values for. --- .../core/fault_detection_result.py | 2 +- .../evaluation/care2compare.py | 3 - .../evaluation/predist_dataset.py | 7 + notebooks/PreDist/PreDist.ipynb | 167 +++++++++--------- 4 files changed, 93 insertions(+), 86 deletions(-) diff --git a/energy_fault_detector/core/fault_detection_result.py b/energy_fault_detector/core/fault_detection_result.py index 05b4633..6d90928 100644 --- a/energy_fault_detector/core/fault_detection_result.py +++ b/energy_fault_detector/core/fault_detection_result.py @@ -36,7 +36,7 @@ class FaultDetectionResult: """List of DataFrames containing the ARCANA bias every 50th iteration. None if ARCANA was not run. Empty if bias was not tracked.""" - def criticality(self, normal_idx: pd.Series | None, init_criticality: int = 0, max_criticality: int = 1000 + def criticality(self, normal_idx: pd.Series | None = None, init_criticality: int = 0, max_criticality: int = 1000 ) -> pd.Series: """Criticality based on the predicted anomalies. diff --git a/energy_fault_detector/evaluation/care2compare.py b/energy_fault_detector/evaluation/care2compare.py index 897a9ac..6fcfda9 100644 --- a/energy_fault_detector/evaluation/care2compare.py +++ b/energy_fault_detector/evaluation/care2compare.py @@ -18,9 +18,6 @@ class Care2CompareDataset: The data can be downloaded either manually from https://doi.org/10.5281/zenodo.14958989 (in this case specify `path`) or it can be downloaded automatically by setting download_dataset to True. - All data is loaded into memory, which might be problematic for large datasets (consider using DataLoader classes of - TensorFlow and PyTorch in that case). - By default, only the averages are read. See statistics argument of the data loading methods. Method overview: diff --git a/energy_fault_detector/evaluation/predist_dataset.py b/energy_fault_detector/evaluation/predist_dataset.py index 4a05f5d..143c5e2 100644 --- a/energy_fault_detector/evaluation/predist_dataset.py +++ b/energy_fault_detector/evaluation/predist_dataset.py @@ -11,9 +11,15 @@ class PreDistDataset: """Loader and preprocessor for the PreDist dataset. + The data can be downloaded either manually from https://doi.org/10.5281/zenodo.17522254 (in this case specify + `path`) or it can be downloaded automatically by setting download_dataset to True. + Args: path (Union[str, Path]): Path to the dataset root. download_dataset (bool): If True, downloads the PreDist dataset from Zenodo. + + Attributes: + events (Dict[int, pd.DataFrame): preloaded events dataframe for each manufacturer. """ FAULT_HOURS_AFTER = 24 @@ -79,6 +85,7 @@ def load_substation_data(self, manufacturer: int, substation_id: int) -> pd.Data 's_hc1.2_heating_pump_status', 's_hc1.3_heating_pump_status', 's_hc2_dhw_3-way_valve_status', + 's_dhw_3-way_valve_status', 's_hc1.1_heating_pump_status'])] for col in status_cols: if col in df.columns: diff --git a/notebooks/PreDist/PreDist.ipynb b/notebooks/PreDist/PreDist.ipynb index c1a660f..48fa6d7 100644 --- a/notebooks/PreDist/PreDist.ipynb +++ b/notebooks/PreDist/PreDist.ipynb @@ -13,8 +13,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-08T12:27:58.369133600Z", - "start_time": "2026-01-08T12:27:51.629034100Z" + "end_time": "2026-01-12T08:17:49.721583300Z", + "start_time": "2026-01-12T08:17:43.412263500Z" } }, "cell_type": "code", @@ -24,8 +24,8 @@ "from sklearn.metrics import fbeta_score, precision_score, recall_score, ConfusionMatrixDisplay\n", "\n", "from energy_fault_detector.evaluation import PreDistDataset\n", - "from energy_fault_detector import FaultDetector, Config\n", - "from energy_fault_detector.utils.visualisation import plot_score_with_threshold, plot_reconstruction\n", + "from energy_fault_detector import Config\n", + "from energy_fault_detector.utils.visualisation import plot_reconstruction\n", "from energy_fault_detector.utils.analysis import create_events\n", "\n", "from predist_utils import train_or_get_model, find_optimal_threshold, get_arcana_importances" @@ -52,8 +52,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-08T12:27:58.441405400Z", - "start_time": "2026-01-08T12:27:58.370132100Z" + "end_time": "2026-01-12T08:17:49.785659800Z", + "start_time": "2026-01-12T08:17:49.730587300Z" } }, "cell_type": "code", @@ -415,8 +415,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-08T12:27:58.579565800Z", - "start_time": "2026-01-08T12:27:58.479155900Z" + "end_time": "2026-01-12T08:17:49.953720900Z", + "start_time": "2026-01-12T08:17:49.839560800Z" } }, "cell_type": "code", @@ -450,8 +450,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-08T12:44:18.510142700Z", - "start_time": "2026-01-08T12:27:58.648316300Z" + "end_time": "2026-01-12T08:21:15.715824Z", + "start_time": "2026-01-12T08:17:50.035077400Z" } }, "cell_type": "code", @@ -500,45 +500,45 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 20 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 38.7s\n", - "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 41.7s\n", - "[Parallel(n_jobs=-1)]: Done 21 tasks | elapsed: 44.4s\n", - "[Parallel(n_jobs=-1)]: Done 32 out of 64 | elapsed: 47.9s remaining: 47.9s\n", - "[Parallel(n_jobs=-1)]: Done 39 out of 64 | elapsed: 49.8s remaining: 31.9s\n", - "[Parallel(n_jobs=-1)]: Done 46 out of 64 | elapsed: 51.9s remaining: 20.2s\n", - "[Parallel(n_jobs=-1)]: Done 53 out of 64 | elapsed: 55.1s remaining: 11.3s\n", - "[Parallel(n_jobs=-1)]: Done 60 out of 64 | elapsed: 55.6s remaining: 3.6s\n", - "[Parallel(n_jobs=-1)]: Done 64 out of 64 | elapsed: 56.1s finished\n", + "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 27.1s\n", + "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 42.2s\n", + "[Parallel(n_jobs=-1)]: Done 21 tasks | elapsed: 57.9s\n", + "[Parallel(n_jobs=-1)]: Done 32 out of 64 | elapsed: 1.0min remaining: 1.0min\n", + "[Parallel(n_jobs=-1)]: Done 39 out of 64 | elapsed: 1.2min remaining: 44.5s\n", + "[Parallel(n_jobs=-1)]: Done 46 out of 64 | elapsed: 1.2min remaining: 28.1s\n", + "[Parallel(n_jobs=-1)]: Done 53 out of 64 | elapsed: 1.2min remaining: 15.4s\n", + "[Parallel(n_jobs=-1)]: Done 60 out of 64 | elapsed: 1.3min remaining: 5.2s\n", + "[Parallel(n_jobs=-1)]: Done 64 out of 64 | elapsed: 1.3min finished\n", "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 20 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 3.7s\n", - "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 4.9s\n", - "[Parallel(n_jobs=-1)]: Done 21 tasks | elapsed: 8.6s\n", - "[Parallel(n_jobs=-1)]: Done 32 out of 64 | elapsed: 10.8s remaining: 10.8s\n", - "[Parallel(n_jobs=-1)]: Done 39 out of 64 | elapsed: 12.0s remaining: 7.6s\n", - "[Parallel(n_jobs=-1)]: Done 46 out of 64 | elapsed: 14.9s remaining: 5.8s\n", - "[Parallel(n_jobs=-1)]: Done 53 out of 64 | elapsed: 15.8s remaining: 3.2s\n", - "[Parallel(n_jobs=-1)]: Done 60 out of 64 | elapsed: 16.8s remaining: 1.0s\n", - "[Parallel(n_jobs=-1)]: Done 64 out of 64 | elapsed: 17.2s finished\n", + "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 12.2s\n", + "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 16.3s\n", + "[Parallel(n_jobs=-1)]: Done 21 tasks | elapsed: 26.8s\n", + "[Parallel(n_jobs=-1)]: Done 32 out of 64 | elapsed: 31.8s remaining: 31.8s\n", + "[Parallel(n_jobs=-1)]: Done 39 out of 64 | elapsed: 35.4s remaining: 22.7s\n", + "[Parallel(n_jobs=-1)]: Done 46 out of 64 | elapsed: 44.4s remaining: 17.3s\n", + "[Parallel(n_jobs=-1)]: Done 53 out of 64 | elapsed: 46.2s remaining: 9.5s\n", + "[Parallel(n_jobs=-1)]: Done 60 out of 64 | elapsed: 49.3s remaining: 3.2s\n", + "[Parallel(n_jobs=-1)]: Done 64 out of 64 | elapsed: 50.2s finished\n", "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 20 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 3.0s\n", - "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 3.5s\n", - "[Parallel(n_jobs=-1)]: Done 23 out of 56 | elapsed: 6.8s remaining: 9.8s\n", - "[Parallel(n_jobs=-1)]: Done 29 out of 56 | elapsed: 7.7s remaining: 7.2s\n", - "[Parallel(n_jobs=-1)]: Done 35 out of 56 | elapsed: 8.7s remaining: 5.2s\n", - "[Parallel(n_jobs=-1)]: Done 41 out of 56 | elapsed: 11.2s remaining: 4.0s\n", - "[Parallel(n_jobs=-1)]: Done 47 out of 56 | elapsed: 11.6s remaining: 2.1s\n", - "[Parallel(n_jobs=-1)]: Done 53 out of 56 | elapsed: 1.7min remaining: 5.8s\n", - "[Parallel(n_jobs=-1)]: Done 56 out of 56 | elapsed: 1.8min finished\n", + "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 9.2s\n", + "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 9.8s\n", + "[Parallel(n_jobs=-1)]: Done 23 out of 56 | elapsed: 19.8s remaining: 28.4s\n", + "[Parallel(n_jobs=-1)]: Done 29 out of 56 | elapsed: 23.5s remaining: 21.9s\n", + "[Parallel(n_jobs=-1)]: Done 35 out of 56 | elapsed: 25.7s remaining: 15.4s\n", + "[Parallel(n_jobs=-1)]: Done 41 out of 56 | elapsed: 32.5s remaining: 11.8s\n", + "[Parallel(n_jobs=-1)]: Done 47 out of 56 | elapsed: 33.6s remaining: 6.4s\n", + "[Parallel(n_jobs=-1)]: Done 53 out of 56 | elapsed: 34.8s remaining: 1.9s\n", + "[Parallel(n_jobs=-1)]: Done 56 out of 56 | elapsed: 36.2s finished\n", "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 20 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 43.9s\n", - "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 1.1min\n", - "[Parallel(n_jobs=-1)]: Done 23 out of 56 | elapsed: 2.8min remaining: 4.0min\n", - "[Parallel(n_jobs=-1)]: Done 29 out of 56 | elapsed: 4.6min remaining: 4.3min\n", - "[Parallel(n_jobs=-1)]: Done 35 out of 56 | elapsed: 6.9min remaining: 4.1min\n", - "[Parallel(n_jobs=-1)]: Done 41 out of 56 | elapsed: 10.3min remaining: 3.8min\n", - "[Parallel(n_jobs=-1)]: Done 47 out of 56 | elapsed: 12.0min remaining: 2.3min\n", - "[Parallel(n_jobs=-1)]: Done 53 out of 56 | elapsed: 12.7min remaining: 43.1s\n", - "[Parallel(n_jobs=-1)]: Done 56 out of 56 | elapsed: 13.3min finished\n" + "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 10.0s\n", + "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 10.4s\n", + "[Parallel(n_jobs=-1)]: Done 23 out of 56 | elapsed: 21.5s remaining: 30.8s\n", + "[Parallel(n_jobs=-1)]: Done 29 out of 56 | elapsed: 25.5s remaining: 23.8s\n", + "[Parallel(n_jobs=-1)]: Done 35 out of 56 | elapsed: 27.9s remaining: 16.7s\n", + "[Parallel(n_jobs=-1)]: Done 41 out of 56 | elapsed: 34.6s remaining: 12.6s\n", + "[Parallel(n_jobs=-1)]: Done 47 out of 56 | elapsed: 34.7s remaining: 6.6s\n", + "[Parallel(n_jobs=-1)]: Done 53 out of 56 | elapsed: 37.1s remaining: 2.0s\n", + "[Parallel(n_jobs=-1)]: Done 56 out of 56 | elapsed: 39.1s finished\n" ] } ], @@ -556,8 +556,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-08T12:44:22.788242600Z", - "start_time": "2026-01-08T12:44:18.928865700Z" + "end_time": "2026-01-12T08:21:30.617322700Z", + "start_time": "2026-01-12T08:21:17.307176200Z" } }, "cell_type": "code", @@ -606,8 +606,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-08T12:44:23.238074100Z", - "start_time": "2026-01-08T12:44:22.871012900Z" + "end_time": "2026-01-12T08:21:31.920364500Z", + "start_time": "2026-01-12T08:21:30.617322700Z" } }, "cell_type": "code", @@ -629,12 +629,15 @@ " )\n", " print(f'Reliability: {reliability:.2f}, Precision: {precision:.2f}, Recall: {recall:.2f}')\n", "\n", + " fig, ax = plt.subplots()\n", " disp = ConfusionMatrixDisplay.from_predictions(\n", " y_true=true_anomalies[manufacturer], y_pred=predicted_anomalies[manufacturer][config_name],\n", " cmap='Blues',\n", " labels=[False, True],\n", " display_labels=['Normal', 'Anomaly'],\n", - " )\n" + " ax=ax\n", + " )\n", + " ax.set_title(f'Confusion matrix m{manufacturer}, model {config_name}.')\n" ], "id": "3b5c248383e4592e", "outputs": [ @@ -644,14 +647,14 @@ "text": [ "Manufacturer m1\n", "Model default_ae:\n", - "Reliability: 0.86, Precision: 1.00, Recall: 0.55\n", + "Reliability: 0.89, Precision: 1.00, Recall: 0.62\n", "Model cond_ae:\n", - "Reliability: 0.86, Precision: 0.95, Recall: 0.62\n", + "Reliability: 0.89, Precision: 1.00, Recall: 0.62\n", "Manufacturer m2\n", "Model default_ae:\n", - "Reliability: 0.66, Precision: 0.68, Recall: 0.58\n", + "Reliability: 0.73, Precision: 0.86, Recall: 0.46\n", "Model cond_ae:\n", - "Reliability: 0.71, Precision: 0.78, Recall: 0.54\n" + "Reliability: 0.73, Precision: 1.00, Recall: 0.35\n" ] }, { @@ -659,7 +662,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data", @@ -672,7 +675,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiYAAAHHCAYAAACLPpP8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABHHUlEQVR4nO3dB3gU5dbA8TMBQmih9947qKCISJWudCyAUsUOSFO5KiKISBFQpHgVQVAEC/EKKn50UEABRUUEqYLSlBaKFGG+57ze3ZsNCclmd5OZzf/nMyY7O+XdybB79rzNsm3bFgAAAAeISOsCAAAAeBCYAAAAxyAwAQAAjkFgAgAAHIPABAAAOAaBCQAAcAwCEwAA4BgEJgAAwDEITAAAgGMQmCDN7dy5U5o3by45c+YUy7Lk448/Durx9+3bZ447e/bsoB43HJQqVUp69uyZ1sUIa3rf6f2n96G/RowYYfZ1Gy2zlh1ICQITGLt375YHH3xQypQpI1FRURIdHS316tWTV155Rf7666+QnrtHjx7y448/yujRo2Xu3LlSu3btkJ4vHG3bts18EKTkw89J/u///k/69Okj1apVkwwZMpjACUD6kjGtC4C09+mnn8qdd94pmTNnlu7du5sPhYsXL8qXX34pQ4cOlZ9++kn+/e9/h+TcGvSsX79enn76aXnsscdCco6SJUua82TKlEnCOTB5/vnnpVGjRn59mO/YsUMiIpzz/WTevHmyYMECueGGG6RIkSJpXRwAaYDAJJ3bu3ev3HPPPebDe8WKFVK4cGHvc48++qjs2rXLBC6h8scff5ifuXLlCmlaWbNA+IfO23n+/HnJkiWLCUad5MUXX5Q33njDBJF33HGHbN26Na2LBCCVOeerEtLEuHHj5MyZMzJz5kyfoMSjXLlyMmDAAO/jv//+W0aNGiVly5Y1H2r67fxf//qXXLhwwWc/Xa8fLJp1uemmm0xgoNVEc+bM8W6jVQ8aECnNzGgA4fm2r+0eEvrmn1Cd+9KlS+XWW281wU327NmlYsWKpkxJtTHRQKx+/fqSLVs2s2+7du3k559/TvB8GqBpmXQ7bQvTq1cvOXfuXJLXVzMYmoH64YcfpGHDhpI1a1ZzTT/88EPz/OrVq6VOnTomSNByL1u2zGf/X3/9VR555BHznG6TN29ek92KW2Wjr0vXqcaNG5vy6rJq1Sqfv8UXX3xhqsn0OK+//vpVbUw0YNH98+fPL0ePHvUeX7Nn1atXN3/zs2fPJvpa9Xx63vfff99kb4oWLSo5cuSQzp07y6lTp8w98vjjj0uBAgXM30mvYfz7RrMkwc5sBfo3UN999520atXKVHFq2W+77TbZsGHDVdtpdrFJkybmWMWKFZMXXnhBrly5kmC5Pv/8c+/9p9fp9ttvN/un1Ndffy2tW7eW3Llzm2PWqFHDVMWG8p7Xv9/AgQPNPaOvoW3btvLbb7+lqPwTJkyQW265xdzjev1q1arl/RvF984775jndbs8efKYL1cHDhxI0XnhQDbStaJFi9plypRJ9vY9evSw9bbp3LmzPXXqVLt79+7mcfv27X22K1mypF2xYkW7YMGC9r/+9S/7tddes2+44Qbbsix769atZpvvv//enjRpktm/S5cu9ty5c+2YmBjvefQY8T333HNmew89VmRkpF27dm37lVdesWfMmGEPGTLEbtCggXebvXv3mn1mzZrlXbd06VI7Y8aMdoUKFexx48bZzz//vJ0vXz47d+7cZvv457v++uvtjh072tOmTbPvv/9+s+6JJ55I8no1bNjQLlKkiF28eHF76NCh9pQpU+wqVarYGTJksOfPn28XKlTIHjFihD158mTzt8iZM6cdGxvr3f+DDz6wa9asaQ8fPtz+97//ba6lllGvzdmzZ802u3fvtvv372/KpM/rddTl8OHD3r9FuXLlzH5PPfWUuUYrV670PqfX2mPPnj129uzZ7Q4dOnjX6T76d1u9evU1X6seU8tw3XXX2XXr1rVfffVVUy7d95577rG7du1qt2rVytw39913n9lWr3tibr/99gTvAX8F+jfQeyxbtmx24cKF7VGjRtkvvfSSXbp0aTtz5sz2hg0bvNsdOnTIzp8/v7nOerzx48fb5cuXt2vUqGFea9z7as6cOea6tGzZ0pRn7NixdqlSpexcuXIleP8l5f/+7//MvwO9XrrP9OnTzbVv2rRpSO/5e++916zXv63+G9ftPa9Xj+OPYsWK2Y888og5zsSJE+2bbrrJHGfx4sU+273wwgvm2t19992mbJ7XodfvxIkTfp0TzkRgko6dOnXK/MNv165dsrbfsmWL2V7fpOLSQEDXr1ixwrtO3yB13Zo1a7zrjh49at7MBw8efFXQoG/icSU3MPEENn/88Uei5U4oMNEPzwIFCtjHjh3zrtNAKSIiwgRb8c/Xu3dvn2PqB3fevHnt5Hwo6v7z5s3zrtu+fbtZp+eK+8H2xRdfXFXOc+fOXXXM9evXm+30wy1uAKPrPAFHXJ6/xZIlSxJ8Lm5gol5//XWz/TvvvGPKpx/gjz/+eJKv1ROYVKtWzb548aJ3vQad+kGiQUlcGrxcK/AIZmASyN9Ag2790NcA0OPgwYN2jhw5fAJgvUa679dff+1zz2ugEzcwOX36tAlA+vbt61NODSR127jrkxOY/P333yZQ0msV/4P5ypUrIbvnPe8HGkzEpUFKSgKT+Pe63kN6LzVp0sS7bt++feZ+HD16tM+2P/74owm64q+HO1GVk47Fxsaan5qCTY7PPvvM/Bw0aJDP+sGDB5uf8duiVKlSxaSNPTTdq6nyPXv2SLB42qb85z//STRlHt+hQ4dky5YtJk2taWAPTX03a9bM+zrjeuihh3we6+s6duyY9xpei6b+NdXsoddAy125cmVTheDh+T3u9dFUtcelS5fMObUaQvf/9ttvJblKly4tLVq0SNa2DzzwgNm2X79+ct9995kqHG37kVzagDpudYy+Lv0S1Lt3b5/tdL2m37V6MNRS+je4fPmy6SnUvn17UxXpodWeXbt2NVWVnntA75ubb77ZVF3Gvee7det2VdXjyZMnpUuXLvLnn396F+2FpOdfuXKlX69Nq5m0rZhWk8Vvq+Wp9gzFPe/Zp3///j7baTlSIu69fuLECVP9p+eMe58vXLjQ/Du/6667fK5doUKFpHz58n5fOzgTgUk6pvXl6vTp08naXts7aA8O/WCMS98U9A1Rn4+rRIkSVx1D67/1TSdY7r77btOt+f7775eCBQuaDx9t43CtIMVTTv1wik8/qPSNLn5bivivRV+HSs5r0bYG8dvFaJ198eLFr1oX/5jam2j48OFmW23Tky9fPvNhpx9s+sbtT2DiD21zpO0JdIwZbcMS90MjKfGvled1JfR69e/kz+tIqZT+DbRxtl6HxO4VLb+nbYPeV/rhGF/8ffWaKm2Lon/LuIsGQXHb9yS3q7/SdjSpec973g80cL3W602uxYsXm8BO26Np8KTXY/r06T73h147DXL1Ose/dtpWxt9rB2eiV046D0y0saG/PR+SO+CTfgNMiL6xpPQc+g02Lv3AXLNmjfmmpBmbJUuWmO6m+qavb/KJlcFfgbyWxPZNzjE1azFr1izzLbRu3breQeg0AEtuhkj5E1h4GrJ6GqbqGDN67uQK5PWGipPK5Pm76Zg9GtTHlzGjM96WU/ParF271jScbdCggUybNs1kpDTrpve+diGPe+30/teGwwmVTzNjcD9n/AtAmtHeGjpGiY4lktSHj/ag0TcG/dai37I8jhw5Yr7Be3rYBIN+O9Njxhc/K6P0W5v2ktBl4sSJptpBx0XRYKVp06YJvg7PGB7xbd++3WQltNeCE2ivBB2A7uWXX/au066+8a9NMEcH1bS/BkQ6Gm9kZKQMGTLEVO0E8+/rFvpNXHvxJHav6L3nybro9fFkQ+KKv68nw6C9kxK6P/3lOZ5+wUjseKG45z3vB5qxiZslSegcSfnoo49MpkR7jsXtwq6BSfzXqoGRZgArVKjg93ngDlTlpHNPPPGEeUPSqhANMOLTNx1Pl0PtiqgmT57ss40GA0q7OwaLvgFpCle7eMb9wIyJifHZ7vjx41fte91115mf8buieui3Md3m7bff9vmA1zd2zbJ4XqcT6LfC+N9Qp0yZclXmyPOhklAw56++ffuaDxytztGgVb/B62isqZHZcBq9/hqgaRumuF209d+KfpPXbuqeKlG9b7QL8TfffOPdTquC3n33XZ9japCn+2gAre2GEhvbJ7l0MDr9oNZ/l/H//p6/WSjuee0+rV599VWf9fHfH5J7nTW4jntf6/WOPz1Fx44dzbbaHT3+/aiPtQ2Mh1ZPadCVnG79cBYyJumcBgD6BqttNTQLEnfk13Xr1skHH3zgHeeiZs2a5tu7fljpm5uOCaFvwvpmp40DdQyMYNGqiieffFI6dOhgGtfpm4vWN+u3pLiN4UaOHGmqcjQo0m9wWsesqWBtU6AfGokZP368eWPVLJF+6GpbDv3A16oSJ83xoRktTflrubQxsWa2dJwNHeshLv3Q0TfssWPHmoBOv3VqdZZ+K/eHfkPVKjFtV6LXUOl1uffee8311zFVQkkD0U8++cT8ruNo6GvRsUA891+bNm2823rGuQn1MPx6fs9YOfr6NVDTcWA08NVxgOIG+fq3atmypRn7R4NF/bei92XcAFuDEr2W2rBYgwq91zUzs3//fnPttc3Ua6+9luzyadZGj6fXRu8DHW9EAxH9UNZxUTQLEYp7Xs+lDXj135v+nXQMkuXLl5u/m7/0369+wdFrp42K9d/x1KlTTXu2uNdO36/07zFs2DDzd9f3HW28r41/9UuLNtzWDJ/Sa6gBjGZOdSwbuEhadwuCM/zyyy+mm6KOBaBdI7UrZL169cwYC+fPn/dud+nSJTNugHZPzJQpkxkbYtiwYT7bKO26qN09E+q6qUtS3YU9YzNod0Etj46Jot1X43efXL58uenurONU6Hb6U7un6uuJf464XUDVsmXLzGvMkiWLHR0dbbdp08betm2bzzae88XvjqzHij82RUL0tVatWvWq9YldHz3mo48+6n2s3T979eplxmnQ8UVatGhhurom1M33jTfeMGPSaHfKuF2HEzuX5znPcQ4cOGC6q+p1iE+7iupYHjrOSVLdhbXrckLXauPGjUleW8+2CS3xX69ek5tvvtlOSqB/A/Xtt9+aa69/g6xZs9qNGze2161bd9W+P/zwgzlfVFSUGRNFxz2ZOXNmgveKXi89pl5z3b5s2bJ2z5497U2bNl11jZLjyy+/tJs1a2b+7erfSscT0X+/obzn//rrLzNeinYj1nPq8fQ+Skl3Yb1OOu6LDilQqVIlc77EXv9HH31k33rrreacuuj2+jfbsWPHVa8joS70cDZL/5fWwREA+Ds3UNWqVU1PjmBWIQJIe7QxAeA6mp7XKgmCEiD8kDEBAISENmZNqjGvdvGlmy/iovErACAkdPC5pAb3e+655xzV4Bxpj8AEABASOoCc9mi6lrhD/cPZtPeXLp6ecNrOS0em9nQd195POlt3XA8++KDMmDHDr/NQlQMAAJK0aNEiMyyBTgmgoYMOFaHd0HW+Jg1SNDDRIR10GAcPHaDQM9ZPcpExAQAASYo7jpAaPXq0yaDowIIamHgCkYSmWvAHgYmD6GibBw8eNAMGBXOIcQBA6tBMgk6MqvOQ6eB3oXL+/HkzEGYwyhv/80YHaIw7NUBiDZt1AE6d/DHudCY60vE777xjghMNZJ599lkTrPiDwMRBNCiJP9spAMCdDX89oyeHIijJkiOvyN+BD7evPaLOnDmT7AbJnkk9tQy6r464q6NSKx21V0c61qBMR+zV0bt17qSFCxf6VSbamDiIDuucK1cuiazSQ6wMkWldHCAk9q+akNZFAELmdGyslCtd3EzbocP9h0JsbKw5duYqPUQC+ay4fFEubHvbBFFx24FcK2OiWRqdPkE/r3SS0TfffNM0ePUEJ3GtWLHCTK6q0xR4JptMDjImDuJJp2lQQmCCcOVvQzjAjVKlOj5jVECfFbYV4f03mdx/lzrjuM5hpGrVqiUbN240E73q/FHx1alTx/wkMAEAID2wTAQU2P5BaBuZ2EzuW7ZsMT91Ukl/EJgAAOBGVsQ/SyD7+0FnddYxS0qUKGEa+OrM9KtWrTIzWO/evds8bt26tZn9XNuYDBw4UBo0aCA1atTw6zwEJgAAIElHjx6V7t27y6FDh0wbFw04NChp1qyZaaeybNkymTx5sumpox05OnXqJM8884z4i8AEAAA3sqwAq3L823fmzJmJPqeBSPxRX1OKwAQAADeyUrcqJ7U4s1QAACBdImMCAIAbWalblZNaCEwAAHCliACrY5xZaeLMUgEAgHSJjAkAAG5kUZUDAACcwqJXDgAAQEiRMQEAwI0sqnIAAIBTWOFZlUNgAgCAG1nhmTFxZrgEAADSJTImAAC4kUVVDgAAcFRVTkRg+zuQM8MlAACQLpExAQDAjSKsf5ZA9ncgAhMAANzICs82Js4sFQAASJfImAAA4EZWeI5jQmACAIAbWVTlAAAAhBQZEwAA3MiiKgcAADiFFZ5VOQQmAAC4kRWeGRNnhksAACBdImMCAIAbWVTlAAAAp7CoygEAAAgpMiYAALhSRIDVMc7MTRCYAADgRhZVOQAAACFFxgQAANdmTCIC29+BCEwAAHAjKzy7CzuzVAAAIF0iYwIAgBtZ4dn4lcAEAAA3ssKzKofABAAAN7LCM2PizHAJAACkS2RMAABwI4uqHAAA4BQWVTkAAAAhRcYEAAAXsizLLAEcQJyIjAkAAC4OTKwAFn9Mnz5datSoIdHR0WapW7eufP75597nz58/L48++qjkzZtXsmfPLp06dZIjR474/boITAAAQJKKFSsmL730kmzevFk2bdokTZo0kXbt2slPP/1knh84cKAsWrRIPvjgA1m9erUcPHhQOnbsKP6iKgcAADey/rsEsr8f2rRp4/N49OjRJouyYcMGE7TMnDlT5s2bZwIWNWvWLKlcubJ5/uabb072eciYAACQjqtyYmNjfZYLFy4kee7Lly/L/Pnz5ezZs6ZKR7Moly5dkqZNm3q3qVSpkpQoUULWr1/v1+siMAEAIB0rXry45MyZ07uMGTMm0W1//PFH034kc+bM8tBDD0lMTIxUqVJFDh8+LJGRkZIrVy6f7QsWLGie8wdVOQAApONeOQcOHDCNWT006EhMxYoVZcuWLXLq1Cn58MMPpUePHqY9STARmAAAkI4Dk+j/9rJJDs2KlCtXzvxeq1Yt2bhxo7zyyity9913y8WLF+XkyZM+WRPtlVOoUCG/ikVVDgAALmSlcnfhhFy5csW0SdEgJVOmTLJ8+XLvczt27JD9+/ebNij+IGMCAACSNGzYMGnVqpVp0Hr69GnTA2fVqlXyxRdfmLYpffr0kUGDBkmePHlMBqZfv34mKPGnR44iMAEAwI2s1O0ufPToUenevbscOnTIBCI62JoGJc2aNTPPT5o0SSIiIszAappFadGihUybNs3vYhGYAADgQlYqD0mv45RcS1RUlEydOtUsgaCNCQAAcAwyJgAAuJBl/ZM1SfkBxJEITAAAcCFLAu1Z48zIhKocAADgGGRMAABwISuVG7+mFgITAADcyErd7sKphaocAADgGGRMAABwIyuwqhybqhwAAOCUNiYWgQkAAAgWK0wDE9qYAAAAxyBjAgCAG1nh2SuHwAQAABeyqMoBAAAILTImAAC4kBWmGRMCEwAAXMgK08CEqhwAAOAYZEwAAHAhK0wzJgQmAAC4kRWe3YWpygEAAI5BxgQAABeyqMoBAABOYRGYAAAAp7DCNDChjQkAAHAMMiYAALiRFZ69cghMAABwIYuqHAAAgNAiYxJCq1atksaNG8uJEyckV65caV2cdKt3p1uld6f6UrxwHvN4+57DMn7m57Js3TbzeNGMAXJrrfI++8z66EsZ9NL8NCkvECxvvL9apryzXI4ei5Vq5YvK2KF3Sq2qpdK6WAgSi4xJ2urZs6e5iC+99JLP+o8//tixFxfOcPDoSXn+tf9I4+7jpEmP8bJ20y/y7oQHpFKZQt5tZsd8JRVbDvMuz035OE3LDARq4f9tlmcmx8iT97eSVXOfNIFJp35T5Y/jp9O6aAgSS/+zAlgc2sjENYGJioqKkrFjx5oMRLBcvHgxaMeCMy1Zu1WWrtsmew78Ibv3H5UXpi+Ss+cuSO1qpb3b/HX+ohw9dtq7nD57Pk3LDARq2rwV0r39LdKtbV2pVKawTBx2j2SNipR3Plmf1kUDwicwadq0qRQqVEjGjBmT6DYfffSRVK1aVTJnziylSpWSl19+2ed5XTdq1Cjp3r27REdHywMPPCCzZ882VS2LFy+WihUrStasWaVz585y7tw5efvtt80+uXPnlv79+8vly5e9x5o7d67Url1bcuTIYcrVtWtXOXr0aEivAQITEWFJx2a1JGuWSNn4417v+jtb1pZdS1+SdfP/JcMfbStZMmdK03ICgbh46W/Zsv2ANLqponddRESENLypos99D3ezAsmWBFgNFEquamOSIUMGefHFF00AoEFCsWLFfJ7fvHmz3HXXXTJixAi5++67Zd26dfLII49I3rx5TVWQx4QJE2T48OHy3HPPmcdr1641Qcirr74q8+fPl9OnT0vHjh2lQ4cOJmD57LPPZM+ePdKpUyepV6+eOba6dOmSCXI0mNGAZNCgQeY8uj2cpUrZIvLFW4MlKjKjnP3rgtw39A3Zsfewee7DLzbJgUPH5fAfp6Rq+SLy3GPtpFzJAtL9iTfTuthAihw7eUYuX74i+fPk8FmfP0+07Nx3JM3KhSCz6C7sCBosXHfddSaomDlzps9zEydOlNtuu02effZZ87hChQqybds2GT9+vE9g0qRJExk8eLD3sQYmGmRMnz5dypYta9ZpxkQzIkeOHJHs2bNLlSpVTEPWlStXegOT3r17e49RpkwZE9jceOONcubMGbNPUi5cuGAWj9jY2ICuDRK389cj0qDbGInOnkXa3Xa9TBtxn9zx4CsmOHk75ivvdtt2H5TDf8bKJ9P7S6mi+WTf73+mabkBIL1xVVWOh7Yz0SqWn3/+2We9PtaMRlz6eOfOnT5VMFr9Ep9W33iCElWwYEFThRM3wNB1catqNEPTpk0bKVGihKnOadiwoVm/f//+ZL0OrZLKmTOndylevHiy9oP/Lv19Wfb+9qd8v/2AjJz6iWzd+bs8dE+jBLfdvHWf+VmmeP5ULiUQHHlzZZcMGSKuauj6x/FYKZA3Os3KheCywrQqx5WBSYMGDaRFixYybNiwFO2fLVu2q9ZlyuTbpkD/YAmtu3Llivn97NmzpgzaTuXdd9+VjRs3SkxMjF8NarX8p06d8i4HDhxI0euB/yIsSyIjE04YVq/wTxXhkT9PpXKpgOCIzJRRrqtUXFZv3OFdp+9dazb+IjdW/1+jb7ibFaaBieuqcjy027BW6Wj7Do/KlSvLV1/9Ly2v9LFW6Wj7lGDavn27HDt2zJTDk+nYtGmTX8fQBrq6ILS0MeuydT/JgcMnJEfWKOncsrYZt6RTv2mmukYfL/3qJzl+6qzpUjl6YEf56tud8tOug2lddCDFHunaRB55fq5cX7mE3FC1lEx/b6VpX9Wtzc1pXTQEiWX9swSyvxO5NjCpXr26dOvWzbTr8NB2I9rGQxukajuQ9evXy2uvvSbTpk0L+vm1+iYyMlKmTJkiDz30kGzdutWcF86TL3d2mT6iuxTMFy2xZ87LT7t+N0HJqm+2S9GCuUzPhYfvaWx66vx+5IQsWrFFJrz1RVoXGwhIx+a15M+TZ+TF1z81XeCrVygqH776KFU5cDzXBiZq5MiRsmDBAu/jG264Qd5//33T40aDhMKFC5tt4jZ8DZb8+fObbsb/+te/THCk59bePm3btg36uRCY/i/MS/S534+cNI1ggXD0wF0NzYJwzphYAe3vRJZt23ZaFwL/65WjjWAzV+8rVobItC4OEBInNr6W1kUAQvo+XjBvTtNuUNsghvKzokz/DyVD5qvbTCbX5QtnZc+rnUNa1nTT+BUAAIQnV1flAACQXllM4gcAAJzC0ysnkMUfOvaWdjDRcbsKFCgg7du3lx07/tclXTVq1OiqLsnaQcQfBCYAACBJq1evlkcffVQ2bNggS5cuNSOmN2/e3IzrFVffvn3l0KFD3mXcuHHiD6pyAABw6aSkEREpr46x/dx3yZIlPo+1Z6pmTnQUdB34NO5I6jqxbUqRMQEAwIWsVK7KiU9786g8efL4rNfR0PPlyyfVqlUzI5zrJLn+IGMCAEA6FhtvAtnkjEquUxw8/vjjZj46DUA8unbtKiVLlpQiRYrIDz/8IE8++aRph7Jw4cJkl4fABACAdNwrp3i8CWSfe+45GTFixDX31bYmOuL5l19+6bP+gQce8BmhXQc6ve2222T37t0+E+VeC4EJAADpeK6cAwcO+AywllS25LHHHpPFixfLmjVrpFixfyY9TUydOnXMz127dhGYAAAQzqwgZUw0KEnOyK86UHy/fv0kJiZGVq1aJaVLJz1T9ZYtW8xPzZwkF4EJAABIklbfzJs3T/7zn/+YsUwOHz5s1uvw+FmyZDHVNfp869atJW/evKaNycCBA02PnRo1akhyEZgAAOBCViqP/Dp9+nTvIGpxzZo1y0yWGxkZKcuWLZPJkyebsU207UqnTp3kmWee8es8BCYAAKTjNibJldScvxqI6CBsgWIcEwAA4BhkTAAAcCFLAqzKEWdO4kdgAgCAC1mpXJWTWqjKAQAAjkHGBAAAF7JSuVdOaiEwAQDAhSyqcgAAAEKLjAkAAC5kUZUDAACcwgrTqhwCEwAAXMgK04wJbUwAAIBjkDEBAMCNrACrY5yZMCEwAQDAjSyqcgAAAEKLjAkAAC5k0SsHAAA4hUVVDgAAQGiRMQEAwIUsqnIAAIBTWFTlAAAAhBYZEwAAXMgK04wJgQkAAC5k0cYEAAA4hRWmGRPamAAAAMcgYwIAgAtZVOUAAACnsKjKAQAACC0yJgAAuJAVYHWMM/MlBCYAALhShGWZJZD9nYiqHAAA4BhkTAAAcCGLXjkAAMAprDDtlUNgAgCAC0VY/yyB7O9EtDEBAACOQcYEAAA3sgKsjnFoxoTABAAAF7LCtPErVTkAAMAxyJgAAOBC1n//C2R/JyIwAQDAhSLolQMAABBaZEwAAHAhKz0PsPbJJ58k+4Bt27YNpDwAACAd98pJVmDSvn37ZEdfly9fDrRMAADAYcaMGSMLFy6U7du3S5YsWeSWW26RsWPHSsWKFb3bnD9/XgYPHizz58+XCxcuSIsWLWTatGlSsGDB4LYxuXLlSrIWghIAAFJHhGUFvPhj9erV8uijj8qGDRtk6dKlcunSJWnevLmcPXvWu83AgQNl0aJF8sEHH5jtDx48KB07dky9NiYaGUVFRQVyCAAA4IKqnCVLlvg8nj17thQoUEA2b94sDRo0kFOnTsnMmTNl3rx50qRJE7PNrFmzpHLlyiaYufnmm0PTK0ezIqNGjZKiRYtK9uzZZc+ePWb9s88+awoEAABSr/GrFcASCA1EVJ48ecxPDVA0i9K0aVPvNpUqVZISJUrI+vXrk31cvwOT0aNHmyhp3LhxEhkZ6V1frVo1efPNN/09HAAASEOxsbE+i7YNSYo233j88celXr165vNfHT582MQFuXLl8tlW25focyELTObMmSP//ve/pVu3bpIhQwbv+po1a5oGMQAAIPWqcqwAFlW8eHHJmTOnd9FGrknRtiZbt241jVyDze82Jr///ruUK1cuwehJUzgAACD0IlLQgDX+/urAgQMSHR3tXZ85c+Zr7vfYY4/J4sWLZc2aNVKsWDHv+kKFCsnFixfl5MmTPlmTI0eOmOeSXS4/X4dUqVJF1q5de9X6Dz/8UK6//np/DwcAANJQdHS0z5JYYGLbtglKYmJiZMWKFVK6dGmf52vVqiWZMmWS5cuXe9ft2LFD9u/fL3Xr1g1dxmT48OHSo0cPkznRLIn2adYTaxWPRlAAACD0rP8ugezvD62+0R43//nPfyRHjhzediNa/aPjmujPPn36yKBBg0yDWA1y+vXrZ4KS5PbISVHGpF27dqaP8rJlyyRbtmwmUPn555/NumbNmvl7OAAA4IJeOdOnTzc9cRo1aiSFCxf2LgsWLPBuM2nSJLnjjjukU6dOpguxVuFoAiPk45jUr1/fDK4CAADSB9u2k9xGxzabOnWqWVIqxQOsbdq0yWRKPO1OtG4JAACkjgjrnyWQ/Z3I78Dkt99+ky5dushXX33lbXWrLXB1zHztNhS3hS4AAAgNK0xnF/a7jcn9999vugVrtuT48eNm0d+1Iaw+BwAAkGoZE52UZ926dT6zCervU6ZMMW1PAABA6rCcmfRI3cBER4hLaCA1nUOnSJEiwSoXAAC4Bqpy/mv8+PGmX7I2fvXQ3wcMGCATJkwIdvkAAMA1Gr8Gsrg2Y5I7d26fyOrs2bNSp04dyZjxn93//vtv83vv3r2lffv2oSstAAAIa8kKTCZPnhz6kgAAAEnvVTnJCkx0CHoAAJB+h6RPLSkeYE2dP3/ezCQYV9wZCgEAAEIamGj7kieffFLef/99OXbsWIK9cwAAQGhFWJZZAtk/LHrlPPHEE2a6Y53MR6dGfvPNN+X55583XYV1hmEAABB6lhX4EhYZE51FWAMQnV2wV69eZlC1cuXKScmSJeXdd9+Vbt26haakAAAg7PmdMdEh6MuUKeNtT6KP1a233ipr1qwJfgkBAECivXICWcIiMNGgZO/eveb3SpUqmbYmnkyKZ1I/AAAQWlaYVuX4HZho9c33339vfn/qqadk6tSpEhUVJQMHDpShQ4eGoowAACCd8LuNiQYgHk2bNpXt27fL5s2bTTuTGjVqBLt8AAAgHfXKCWgcE6WNXnUBAACpxwqwOsahcUnyApNXX3012Qfs379/IOUBAADJkK6HpJ80aVKyXySBCQAACGlg4umFg9Qx+/WhkjV7jrQuBhASA2J+SusiACFz8dyZVO29EhHg/mHZxgQAAKQ+K0yrcpwaMAEAgHSIjAkAAC5kWdrlN7D9nYjABAAAF4oIMDAJZN9QoioHAAC4OzBZu3at3HvvvVK3bl35/fffzbq5c+fKl19+GezyAQCABDCJ33999NFH0qJFC8mSJYt89913cuHCBbP+1KlT8uKLL4aijAAAIJGqnECWsAhMXnjhBZkxY4a88cYbkilTJu/6evXqybfffhvs8gEAgHTE78avO3bskAYNGly1PmfOnHLy5MlglQsAAKTDuXL8zpgUKlRIdu3addV6bV9SpkyZYJULAAAkY3bhQJawCEz69u0rAwYMkK+//to0nDl48KC8++67MmTIEHn44YdDU0oAAJDgkPSBLGFRlfPUU0/JlStX5LbbbpNz586Zap3MmTObwKRfv36hKSUAAEgX/A5MNEvy9NNPy9ChQ02VzpkzZ6RKlSqSPXv20JQQAACkmzYmKR75NTIy0gQkAAAg9UVIYO1EdP+wCEwaN258zUFZVqxYEWiZAABAOuV3YHLdddf5PL506ZJs2bJFtm7dKj169Ahm2QAAQCKoyvmvSZMmJbh+xIgRpr0JAAAIvQgm8bs2nTvnrbfeCtbhAABAOpTixq/xrV+/XqKiooJ1OAAAkERVTCCNX8OmKqdjx44+j23blkOHDsmmTZvk2WefDWbZAABAImhjEmdOnLgiIiKkYsWKMnLkSGnevHkwywYAANIZvwKTy5cvS69evaR69eqSO3fu0JUKAAA4qvHrmjVrZPz48bJ582ZTUxITEyPt27f3Pt+zZ095++23ffZp0aKFLFmyxL9y+bNxhgwZTFaEWYQBAEhbVhD+88fZs2elZs2aMnXq1ES3admypQlaPMt7770X+qqcatWqyZ49e6R06dJ+nwwAALgzY9KqVSuzXIvOnVeoUKHU7S78wgsvmAn7Fi9ebKKh2NhYnwUAALhHbLzP8QsXLqT4WKtWrZICBQqYtqcPP/ywHDt2LHSBiTZu1TRO69at5fvvv5e2bdtKsWLFTFsTXXLlykW7EwAAUjljEhHAoooXL246tniWMWPGpKg8Wo0zZ84cWb58uYwdO1ZWr15tMizaPjUkVTnPP/+8PPTQQ7Jy5cqUlBcAAASRZVnXnLsuOfurAwcOSHR0tE91TErcc8893t+1k0yNGjWkbNmyJoty2223BT8w0fFKVMOGDf0tKwAAcKjo6GifwCRYypQpI/ny5ZNdu3aFJjBRgURmAAAg/cyV89tvv5k2JoULF/ZrP78CkwoVKiQZnBw/ftyvAgAAAOeP/HrmzBmT/fDYu3evbNmyRfLkyWMWbfLRqVMn0ytn9+7d8sQTT0i5cuXMWCYhC0z0pPFHfgUAAOFv06ZN0rhxY+/jQYMGmZ89evSQ6dOnyw8//GAGWNOxzooUKWLGPRs1apTfbVYy+tuwRbsBAQCAtBVhWQFN4ufvvo0aNfK2N03IF198IcGQ7MCE9iUAADhHhMPbmKRUsscxuVaUBAAAkKoZkytXrgTlhAAAIAiswBq/+jlVTqrxe64cAACQ9iLEMksg+zsRgQkAAC5kpXJ34dTi9yR+AAAAoULGBAAAF4oI0145BCYAALhQRCqPY5JaqMoBAACOQcYEAAAXssK08SuBCQAAbu0ubIVfd2GqcgAAgGOQMQEAwIUsqnIAAICTqjwiAtzfiZxaLgAAkA6RMQEAwIUsyzJLIPs7EYEJAAAuZAU4QbAzwxICEwAAXImRXwEAAEKMjAkAAC5lSfghMAEAwIWsMB3HhKocAADgGGRMAABwIYvuwgAAwCkiGPkVAAAgtMiYAADgQhZVOQAAwCmsMB35laocAADgGGRMAABwIYuqHAAA4BQRYdorh8AEAAAXssI0Y+LUgAkAAKRDZEwAAHAhK0x75RCYAADgQhaT+AEAAIQWGRMAAFwoQiyzBLK/ExGYAADgQhZVOQAAAKFFxgQAABey/vtfIPs7EYEJAAAuZFGVAwAAEFpkTAAAcCErwF45Tq3KIWMCAICLq3KsABZ/rFmzRtq0aSNFihQx8+x8/PHHPs/bti3Dhw+XwoULS5YsWaRp06ayc+dOv18XgQkAAC5kpXJgcvbsWalZs6ZMnTo1wefHjRsnr776qsyYMUO+/vpryZYtm7Ro0ULOnz/v13moygEAAElq1aqVWRKi2ZLJkyfLM888I+3atTPr5syZIwULFjSZlXvuuUeSi4wJAAAu7i5sBfCfio2N9VkuXLjgd1n27t0rhw8fNtU3Hjlz5pQ6derI+vXr/ToWgQkAAC4UYQW+qOLFi5sgwrOMGTPG77JoUKI0QxKXPvY8l1xU5QAAkI4dOHBAoqOjvY8zZ86cpuUhYwIAQDquyomOjvZZUhKYFCpUyPw8cuSIz3p97HkuuQhMAABwISuVe+VcS+nSpU0Asnz5cu86ba+ivXPq1q3r17GoygEAAEk6c+aM7Nq1y6fB65YtWyRPnjxSokQJefzxx+WFF16Q8uXLm0Dl2WefNWOetG/fXvxBYAIAgAtZAY7e6u+emzZtksaNG3sfDxo0yPzs0aOHzJ49W5544gkz1skDDzwgJ0+elFtvvVWWLFkiUVFRfp2HwAQAABeKiNOzJqX7+6NRo0ZmvJLE6GiwI0eONEsgaGMCAAAcg4xJAEqVKmXq1HSBc23b/qss+myD7N13SE6cPCNDBtwpN9aq6H3+643bZdnKzbJn72E5c/YvGTvqfilV0r9W5EBaKps3qzQpn0+K54qSnFkyyZsb9suPh057n4/MECFtqhaQGkWiJWtkBjl+9qKs2X1cvtp3Ik3LjcBYcXrWpHR/J3JExkRHhcuQIYPcfvvtaV0UhKELFy5JyRIFpHf3lgk/f/GiVKxQXLre3STVywYEQ2TGCPn91Hn58PtDCT7foXpBqVwwu8zd9JuMWbZLVu0+Lp1qFpZqhXKkelkRnr1ywi5jMnPmTOnXr5/5efDgQdOKFwiW62uWM0tiGtSrYX4e/eNkKpYKCJ6fj5wxS2JK580q3+w/Jbv+PGcer993QuqVyi0lcmeRrYf/l1mBGxu/ppxD45K0z5ho96MFCxbIww8/bDIm2rLXY9WqVaYxjfaLrl27tmTNmlVuueUW2bFjh88xpk+fLmXLlpXIyEipWLGizJ071+d5Pcbrr78ud9xxhzlG5cqVTZZGuz1pYx6dAVGPu3v3bu8++rtORKTD6WbPnl1uvPFGWbZsWaKvo3fv3ub4cV26dEkKFChgAi4ASCt7j52T6oVzSM6of76LlsuXVfJnj5QdRxMPZoB0G5i8//77UqlSJRNQ3HvvvfLWW29d1er36aeflpdfftl0VcqYMaMJAjxiYmJkwIABMnjwYNm6das8+OCD0qtXL1m5cqXPMUaNGiXdu3c3fa71fF27djXbDhs2zBxXz/nYY4/5BEytW7c2QdF3330nLVu2lDZt2sj+/fsTfB3333+/6RZ16ND/UqmLFy+Wc+fOyd13353gPjpRUvzJkwAg2D784bAcPn1BRraqKBPbVZGHbylpqn12H/sngwJ3ihBLIqwAFofmTNI8MNFsggYkSj/8T506JatXr/bZZvTo0dKwYUOpUqWKPPXUU7Ju3To5f/68eW7ChAnSs2dPeeSRR6RChQqmX3XHjh3N+rg0WLnrrrvMNk8++aTs27dPunXrJi1atDAZFA1uNEPjUbNmTRO4VKtWzQwWo4GNZmU++eSTBF+HZlziZ2tmzZold955p8m4JEQnSoo7cZJOpAQAwdagTB4pmTuL/Hv9rzJh5W75eOsR6VyzsFTIny2ti4YgVOVYASxOlKaBiVbJfPPNN9KlSxfzWLMhml2IX/VRo8Y/bQBU4cKFzc+jR4+anz///LPUq1fPZ3t9rOsTO4Zn9sPq1av7rNNgx5O10IzJkCFDTNCSK1cuE1zoMRPLmHiyJhqMeOYH+Pzzz32yO/FptkYDMc+iEykBQDBlirDkjqoF5OMfD8tPh8/IwdgLsnbPcfnu91hpUj5vWhcPcFbjVw1A/v77b5/GrlqlohMIvfbaa951mTJl8mkvoq5cueLXuRI6xrWOq0HJ0qVLTealXLlykiVLFuncubNcvHgx0XNoVZFmdLT9imZ1dEje+vXrJ7q9vs60nsURQHiLiLAkY0SExB8W64ptO7a7KNJ369c0C0w0IJkzZ45pO9K8eXOf53Rc/ffee8+0BUmKZjS++uorMySuhz7Wap9A6DG0iqhDhw7eDIpW/1xL3rx5Tdk1a6LBiVYfIe2dP39RDh857n2svW/2/XpYsmfLIvny5ZQzZ/6SP4+dMmOcqIOHjpmfuXJml1y5Eq6GA5xExynRxqweebNGStGcUXLu4mU58dcl2fnHWWlXraBcunxFjp+7JOXyZZMbS+QyWRS4lxWm45ikWWCiDUNPnDghffr0Me0r4urUqZPJpowfPz7J4wwdOtS0Hbn++uuladOmsmjRIlm4cOE1e9Akh7Yr0eNog1fNpuhkRMnJ0mh1jvbOuXz5sk+whLSze+9BGTnmHe/jOfOWmp8Nb60hjzzQVjZ994tMf2OR9/lXpsWYn53b15c7OzZMgxID/imRO0r61S/tfdyhxj8DBH796wmZ9+1BeXvjb2aAtftqFzMDrJ04d0k+3XZUvtrLAGtwnjQLTDTw0EAiflDiCUzGjRsnP/zwQ5LH0QzFK6+8YqpctAGrVp9oxkK7AQdi4sSJpn2INmrNly+faTCbnF4z+pq0HUzVqlUZj8UhqlYuJQvmPJPo843q1zQL4FY6PsmAmJ8Sff70hb9NgIIwYwU4SJozEyZi2deakQd+0yqfokWLmuBIewf5QwMfDdTeW/eLZM3OiIwIT59u/6eqDAhHF8+dkdk9bzYdGqKjo0Nyjtj/flas2LJfsudI+TnOnI6VJteVCGlZXTvyazjQap4///zTtJnRXjxt27ZN6yIBAOA6BCZBot2ItRqpWLFiZvRa7foMAEDIWPTKQRIzDVMrBgBILRa9cgAAgFNYATZ+derswmk+JD0AAIAHGRMAAFzICs8mJgQmAAC4khWekQlVOQAAwDHImAAA4EIWvXIAAIBTWPTKAQAACC0yJgAAuJAVnm1fCUwAAHAlKzwjE6pyAACAY5AxAQDAhSx65QAAAKewwrRXDoEJAAAuZIVnExPamAAAAOcgYwIAgBtZ4ZkyITABAMCFrDBt/EpVDgAAcAwyJgAAuJBFrxwAAOAUVng2MaEqBwAAOAcZEwAA3MgKz5QJgQkAAC5k0SsHAAAgtMiYAADgQha9cgAAgFNY4dnEhKocAABcHZlYASx+GDFihFiW5bNUqlQp6C+LjAkAAEiWqlWryrJly7yPM2YMfhhBYAIAgAtZadArRwORQoUKSShRlQMAgBtZ/2sAm5LFE5fExsb6LBcuXEj0lDt37pQiRYpImTJlpFu3brJ///6gvywCEwAA0rHixYtLzpw5vcuYMWMS3K5OnToye/ZsWbJkiUyfPl327t0r9evXl9OnTwe1PFTlAACQjnvlHDhwQKKjo73rM2fOnOD2rVq18v5eo0YNE6iULFlS3n//fenTp48EC4EJAADpODKJjo72CUySK1euXFKhQgXZtWuXBBNVOQAAwG9nzpyR3bt3S+HChSWYCEwAAHBxrxwrgP/8MWTIEFm9erXs27dP1q1bJx06dJAMGTJIly5dgvq6qMoBAMCFrFQekv63334zQcixY8ckf/78cuutt8qGDRvM78FEYAIAAJI0f/58SQ0EJgAAuJAVpnPlEJgAAOBGVnhGJgQmAAC4kJUGQ9KnBnrlAAAAxyBjAgCAW2tyrMD2dyICEwAAXMgKzyYmVOUAAADnIGMCAIALWak8wFpqITABAMCVrLCszKEqBwAAOAYZEwAAXMiiKgcAADiFFZYVOVTlAAAAByFjAgCAC1lU5QAAAKewwnSuHAITAADcyArPRia0MQEAAI5BxgQAABeywjNhQmACAIAbWWHa+JWqHAAA4BhkTAAAcCGLXjkAAMAxrPBsZEJVDgAAcAwyJgAAuJAVngkTAhMAANzIolcOAABAaJExAQDAlawAe9Y4M2VCYAIAgAtZVOUAAACEFoEJAABwDKpyAABwIStMq3IITAAAcCErTIekpyoHAAA4BhkTAABcyKIqBwAAOIUVpkPSU5UDAAAcg4wJAABuZIVnyoTABAAAF7LolQMAABBaZEwAAHAhi145AADAKazwbGJCVQ4AAK6OTKwAlhSYOnWqlCpVSqKioqROnTryzTffBPVlEZgAAIBkWbBggQwaNEiee+45+fbbb6VmzZrSokULOXr0qAQLgQkAAC7ulWMF8J+/Jk6cKH379pVevXpJlSpVZMaMGZI1a1Z56623gva6CEwAAHBx41crgMUfFy9elM2bN0vTpk296yIiIszj9evXB+110fjVQWzbNj/PnT2T1kUBQubiOe5vhK+Lf531eT8PpdjY2KDsH/84mTNnNkt8f/75p1y+fFkKFizos14fb9++XYKFwMRBTp8+bX72aXZDWhcFABDg+3nOnDlDcuzIyEgpVKiQlC9dPOBjZc+eXYoX9z2Oth8ZMWKEpBUCEwcpUqSIHDhwQHLkyCGWUzuYhxn9pqD/KPW6R0dHp3VxgKDi/k59minRoETfz0MlKipK9u7da6pWglHe+J83CWVLVL58+SRDhgxy5MgRn/X6WAOlYCEwcRCtqytWrFhaFyNd0jdt3rgRrri/U1eoMiXxgxNdUpNmamrVqiXLly+X9u3bm3VXrlwxjx977LGgnYfABAAAJIt2Fe7Ro4fUrl1bbrrpJpk8ebKcPXvW9NIJFgITAACQLHfffbf88ccfMnz4cDl8+LBcd911smTJkqsaxAaCwATpmtalakOvxOpUATfj/kYoaLVNMKtu4rPs1OjTBAAAkAwMsAYAAByDwAQAADgGgQkAAHAMAhMgBFatWmUGLTp58mRaFwUIGp3qXruHAqFEYALH69mzp/mQf+mll3zWf/zxx4yQC1fSCc90BM3bb789rYsCOA6BCVxBRzgcO3asnDhxImjHDMZwzkBKzJw5U/r16ydr1qyRgwcPpnVxAEchMIEr6LTaOhfDmDFjEt3mo48+kqpVq5oxGzTl/PLLL/s8r+tGjRol3bt3N8NzP/DAAzJ79mzJlSuXLF68WCpWrChZs2aVzp07y7lz5+Ttt982++TOnVv69+9vZtX0mDt3rhn5UOc10nJ17dpVjh49GtJrgPBw5swZWbBggTz88MMmY6L3YPwqQB3iW+8vvR9vueUW2bFjh88xpk+fLmXLljVDhOt9q/djXHqM119/Xe644w5zjMqVK5ssza5du6RRo0aSLVs2c9zdu3d799Hf27VrZwbK0ondbrzxRlm2bFmir6N3797m+HFdunRJChQoYAIvIMV0HBPAyXr06GG3a9fOXrhwoR0VFWUfOHDArI+JidExeMzvmzZtsiMiIuyRI0faO3bssGfNmmVnyZLF/PQoWbKkHR0dbU+YMMHetWuXWfT5TJky2c2aNbO//fZbe/Xq1XbevHnt5s2b23fddZf9008/2YsWLbIjIyPt+fPne481c+ZM+7PPPrN3795tr1+/3q5bt67dqlUr7/MrV640ZTtx4kSqXis4n947tWvXNr/rvVW2bFn7ypUrPvdNnTp17FWrVpn7r379+vYtt9zi3V//Heg9O3XqVHOvv/zyy3aGDBnsFStWeLfRYxQtWtResGCB2aZ9+/Z2qVKl7CZNmthLliyxt23bZt988812y5Ytvfts2bLFnjFjhv3jjz/av/zyi/3MM8+Yf2+//vqrz7+hSZMmmd+/+uorc96DBw/6lC1btmz26dOnQ3wVEc4ITOCawETpm2nv3r2vCky6du1qgou4hg4dalepUsXnTVXfoOPSwESPoUGKx4MPPmhnzZrV5821RYsWZn1iNm7caI7j2YfABInRIGPy5Mnm90uXLtn58uUz90vc+2bZsmXe7T/99FOz7q+//vLu37dvX59j3nnnnXbr1q29j3V7DSw8NHjWdRoUebz33nsm8LiWqlWr2lOmTEkwMFH672vs2LHex23atLF79uzp5xUBfFGVA1fRdiZaxfLzzz/7rNfH9erV81mnj3fu3OlTBaPp8fg01a1pcQ9NZWsVjqaz466LW1WzefNmadOmjZQoUcJU5zRs2NCs379/f5BeKcKRVsl888030qVLF/M4Y8aMZu6R+FUfNWrU8P5euHBh89Nz/yV2r8f/NxH3GJ55TKpXr+6z7vz58xIbG+utYhoyZIip9tHqTb3/9ZjXuqfvv/9+mTVrlvn9yJEj8vnnn5sqHiAQBCZwlQYNGkiLFi1k2LBhKdpf69bjy5Qp01X18wmt0+m9lc6kqWXQdirvvvuubNy4UWJiYsxzNKjFtWgA8vfff0uRIkVMUKKLthfR9lGnTp3ybhf3/vP0PPPcf8mV0DGudVwNSvQ+fvHFF2Xt2rWyZcsWE8hc657W9lp79uwx7VfeeecdKV26tNSvX9+vcgLxMYkfXEe7DeuMltroz0O/5X311Vc+2+njChUqmG6ZwbR9+3Y5duyYKUfx4sXNuk2bNgX1HAg/GpDMmTPHNMpu3ry5z3Pt27eX9957TypVqpTkcTz3uk4976GPq1SpElD59BjaNb9Dhw7eDMq+ffuuuU/evHlN2TVrosFJr169AioDoAhM4Dr6La5bt27y6quvetcNHjzY9CLQXjeaGtc3yddee02mTZsW9PNr9Y32hpgyZYo89NBDsnXrVnNe4Fq055d2d+/Tp4/kzJnT57lOnTqZbMr48eOTPM7QoUPlrrvukuuvv970Vlu0aJEsXLjwmj1okqN8+fLmOFpFqdmUZ599NllZGq3O0d45WmUaN1gCUoqqHLjSyJEjfd40b7jhBnn//fdl/vz5Uq1aNRk+fLjZRr8BBlv+/PlNF88PPvjAfEvVzMmECROCfh6EFw08NJCIH5R4AhPNuv3www9JHkczFK+88oq557R7vHYL1oyFdgMOxMSJE03XeO1GrMGJVlfqv6uk6GvSdjC6vVZRAYGytAVswEcBAKRLWuVTtGhRExx17NgxrYuDMEBVDgDAb5qx/PPPP02bGe3F07Zt27QuEsIEgQkAwG/ajVh74RQrVsxUbWoPIyAYqMoBAACOQeNXAADgGAQmAADAMQhMAACAYxCYAAAAxyAwAeBDB6XTQbw8dOCuxx9/PNXLsWrVKjMC6cmTJxPdRp//+OOPk33MESNGmOkMAqHDtOt5dS4ZAMFHYAK4JFjQD0NddDj8cuXKmZFtdf6VUNNhypM75H5yggkAuBY6ngMu0bJlSzO65oULF+Szzz6TRx991MwWm9BMyzojrAYwwZAnT56gHAcAkoOMCeASmTNnlkKFCknJkiXl4YcfNnOUfPLJJz7VL6NHjzbzlXhmXj5w4ICZ8E1H5tQAo127dj4zxurEa4MGDTLP60yxTzzxhMQf2ih+VY4GRk8++aSZWVnLpNkbnQdGj9u4cWOzjc65opkTz1xFOkromDFjzIBcWbJkkZo1a8qHH37ocx4NtnQ2aH1ej5PUzLYJ0XLpMbJmzSplypQxE9FdunTpqu10fhktv26n1+fUqVM+z7/55ptmFt+oqCgz428oJoMEkDACE8Cl9ANcMyMey5cvlx07dsjSpUvNTLb6gawTq+XIkUPWrl1rprXPnj27ybx49tPhxHXUzrfeeku+/PJLOX78uMTExFzzvN27d5f33nvPzO78888/mw95Pa5+0H/00UdmGy3HoUOHzGRzSoOSOXPmyIwZM+Snn36SgQMHyr333iurV6/2BlA6z4pOHqdtN3TG2qeeesrva6KvVV/Ptm3bzLnfeOMNmTRpks82u3btMhM+6qy8S5Yske+++04eeeQR7/PvvvuumQRSgzx9fS+++KIJcN5++22/ywMgBXTkVwDO1qNHD7tdu3bm9ytXrthLly61M2fObA8ZMsT7fMGCBe0LFy5495k7d65dsWJFs72HPp8lSxb7iy++MI8LFy5sjxs3zvv8pUuX7GLFinnPpRo2bGgPGDDA/L5jxw5Np5jzJ2TlypXm+RMnTnjXnT9/3s6aNau9bt06n2379Oljd+nSxfw+bNgwu0qVKj7PP/nkk1cdKz59PiYmJtHnx48fb9eqVcv7+LnnnrMzZMhg//bbb951n3/+uR0REWEfOnTIPC5btqw9b948n+OMGjXKrlu3rvl979695rzfffddoucFkHK0MQFcQrMgmpnQTIhWjXTt2tX0MvGoXr26T7uS77//3mQHNIsQ1/nz52X37t2m+kKzGnXq1PE+p/Od1K5d+6rqHA/NZmTIkEEaNmyY7HJrGc6dOyfNmjXzWa9Zm+uvv978rpmJuOVQdevWFX8tWLDAZHL09emst9o4ODo62mebEiVKmNlw455Hr6dmefRa6b59+vSRvn37erfR4+TMmdPv8gDwH4EJ4BLa7mL69Okm+NB2JPEnTcuWLZvPY/1grlWrlqmaiC9//vwprj7yl5ZDffrppz4BgdI2KsGyfv166datmzz//POmCksDifnz55vqKn/LqlVA8QMlDcgAhB6BCeASGnhoQ9PkuuGGG0wGoUCBAldlDTwKFy4sX3/9tTRo0MCbGdi8ebPZNyGaldHsgrYN0ca38XkyNtqo1qNKlSomANHZaBPLtGhDU09DXo8NGzaIP9atW2caBj/99NPedb/++utV22k5Dh48aII7z3kiIiJMg+GCBQua9Xv27DFBDoDUR+NXIEzpB2u+fPlMTxxt/Lp3714zzkj//v3lt99+M9sMGDBAXnrpJTNI2fbt200j0GuNQVKqVCnp0aOH9O7d2+zjOaY2JlUaGGhvHK12+uOPP0wGQqtHhgwZYhq8agNSrSr59ttvZcqUKd4GpQ899JDs3LlThg4daqpU5s2bZxqx+qN8+fIm6NAsiZ5Dq3QSasirPW30NWhVl14XvR7aM0d7PCnNuGhjXd3/l19+kR9//NF00544caJf5QGQMgQmQJjSrrBr1qwxbSq0x4tmJbTthLYx8WRQBg8eLPfdd5/5oNa2FhpEdOjQ4ZrH1eqkzp07myBGu9JqW4yzZ8+a57SqRj/YtUeNZh8ee+wxs14HaNOeLfqBr+XQnkFataPdh5WWUXv0aLCjXYm19472hvFH27ZtTfCj59TRXTWDoueMT7NOej1at24tzZs3lxo1avh0B9YeQdpdWIMRzRBplkeDJE9ZAYSWpS1gQ3wOAACAZCFjAgAAHIPABAAAOAaBCQAAcAwCEwAA4BgEJgAAwDEITAAAgGMQmAAAAMcgMAEAAI5BYAIAAByDwAQAADgGgQkAAHAMAhMAACBO8f8C52Mjz49fNAAAAABJRU5ErkJggg==" }, "metadata": {}, "output_type": "display_data", @@ -685,7 +688,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data", @@ -698,7 +701,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data", @@ -718,8 +721,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-08T12:44:23.257405Z", - "start_time": "2026-01-08T12:44:23.238074100Z" + "end_time": "2026-01-12T08:21:32.214615900Z", + "start_time": "2026-01-12T08:21:32.177505500Z" } }, "cell_type": "code", @@ -770,8 +773,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-08T12:44:23.423567300Z", - "start_time": "2026-01-08T12:44:23.288919900Z" + "end_time": "2026-01-12T08:21:32.754895600Z", + "start_time": "2026-01-12T08:21:32.303730300Z" } }, "cell_type": "code", @@ -805,7 +808,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data", @@ -825,8 +828,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-08T12:44:35.723922500Z", - "start_time": "2026-01-08T12:44:23.466997300Z" + "end_time": "2026-01-12T08:21:45.802629500Z", + "start_time": "2026-01-12T08:21:33.224452Z" } }, "cell_type": "code", @@ -851,18 +854,18 @@ { "data": { "text/plain": [ - "s_dhw_supply_temperature_setpoint 0.405723\n", - "p_net_meter_flow 0.099440\n", - "p_net_return_temperature 0.092462\n", - "p_hc1_return_temperature 0.075755\n", - "p_net_meter_heat_power 0.074011\n", - "s_dhw_lower_storage_temperature 0.073638\n", - "s_dhw_upper_storage_temperature 0.058171\n", - "p_net_supply_temperature 0.039459\n", - "outdoor_temperature 0.034128\n", - "s_dhw_supply_temperature 0.028003\n", - "s_hc1_supply_temperature 0.010396\n", - "s_hc1_supply_temperature_setpoint 0.008813\n", + "s_dhw_supply_temperature_setpoint 0.208051\n", + "s_hc1_supply_temperature_setpoint 0.146244\n", + "outdoor_temperature 0.117945\n", + "p_net_meter_heat_power 0.116884\n", + "s_dhw_lower_storage_temperature 0.082830\n", + "p_net_supply_temperature 0.076468\n", + "s_hc1_supply_temperature 0.072472\n", + "s_dhw_upper_storage_temperature 0.051432\n", + "p_hc1_return_temperature 0.044122\n", + "p_net_meter_flow 0.041088\n", + "s_dhw_supply_temperature 0.024492\n", + "p_net_return_temperature 0.017975\n", "dtype: float32" ] }, @@ -876,8 +879,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-08T12:44:36.211049200Z", - "start_time": "2026-01-08T12:44:35.945780300Z" + "end_time": "2026-01-12T08:21:46.424395400Z", + "start_time": "2026-01-12T08:21:45.946579100Z" } }, "cell_type": "code", @@ -895,7 +898,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 10, @@ -907,7 +910,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data", From d18dfb4985b85e1503023760ab96c3418aaefbce Mon Sep 17 00:00:00 2001 From: croelofs <25582572+roelofsc@users.noreply.github.com> Date: Mon, 12 Jan 2026 13:58:56 +0100 Subject: [PATCH 08/10] Fix bug in data_downloads.py regarding recursive unzipping and flattening the file structure. --- energy_fault_detector/utils/data_downloads.py | 39 ++++++++++++++----- 1 file changed, 29 insertions(+), 10 deletions(-) diff --git a/energy_fault_detector/utils/data_downloads.py b/energy_fault_detector/utils/data_downloads.py index 03ce1f9..1742155 100644 --- a/energy_fault_detector/utils/data_downloads.py +++ b/energy_fault_detector/utils/data_downloads.py @@ -141,6 +141,30 @@ def safe_extract_zip(zip_path: Path, dest_dir: Path): zf.extractall(dest_dir) +def recursive_safe_extract(zip_path: Path, dest_dir: Path, remove_archives: bool = True): + """ + Recursively extracts ZIP files, including those found inside other ZIPs. + + Args: + zip_path: Path to the .zip archive. + dest_dir: Directory to extract into. + remove_archives: Whether to delete the .zip file after successful extraction. + """ + logger.info(f"Extracting {zip_path.name} to {dest_dir}") + safe_extract_zip(zip_path, dest_dir) + + if remove_archives: + try: + zip_path.unlink() + except OSError as e: + logger.warning(f"Could not remove archive {zip_path}: {e}") + + # After extraction, check if any new .zip files were created in the dest_dir + for item in list(dest_dir.rglob("*.zip")): + recursive_safe_extract(item, item.parent, remove_archives=remove_archives) + + + def prepare_output_dir(out_dir: Path, overwrite: bool) -> None: """Ensure the output directory is ready. @@ -171,7 +195,7 @@ def prepare_output_dir(out_dir: Path, overwrite: bool) -> None: def download_zenodo_data(identifier: str = "10.5281/zenodo.15846963", dest: Path = "./downloads", - overwrite: bool = False, flatten_file_structure: bool = True, + remove_zip: bool = True, overwrite: bool = False, flatten_file_structure: bool = True, expected_file_types: Union[List[str], str] = "*.csv") -> Path: """ Download a Zenodo record via API and unzip any .zip files. @@ -183,6 +207,7 @@ def download_zenodo_data(identifier: str = "10.5281/zenodo.15846963", dest: Path identifier (str): Zenodo record ID, DOI (e.g., 10.5281/zenodo.15846963), or record URL. Defaults to the CARE2Compare dataset. dest (Path): Local output directory to save downloaded files. (default: downloads) + remove_zip (bool): If True, ZIP archives will be removed after extraction. overwrite (bool): If True and dest already exists, contents of dest will be overwritten. Default is False. flatten_file_structure (bool): If True and unzipping results in a single top-level folder @@ -241,25 +266,19 @@ def download_zenodo_data(identifier: str = "10.5281/zenodo.15846963", dest: Path # Unzip any downloaded .zip files for p in downloaded: if p.suffix.lower() == ".zip": - extract_target = out_dir # Extract directly into dest + extract_target = out_dir # Extract directly into dest logger.info(f"Unzipping: {p.name} -> {extract_target}") try: - safe_extract_zip(p, extract_target) + recursive_safe_extract(p, extract_target, remove_archives=remove_zip) except Exception as e: logger.error(f"Unzipping failed for {p.name}: {e}") - else: - try: - p.unlink() - logger.info(f"Removed archive: {p.name}") - except OSError as e: - logger.warning(f"Could not remove {p}: {e}") if flatten_file_structure: logger.info(f"Flattening file structure.") # Standardize structure: If unzipping created a single subfolder, move its contents up # This often happens with Zenodo zips. subdirs = [d for d in out_dir.iterdir() if d.is_dir()] - if len(subdirs) == 1 and not any(out_dir.glob(pattern) for pattern in expected_file_types): + if len(subdirs) == 1 and not any(next(out_dir.glob(pattern), None) for pattern in expected_file_types): redundant_dir = subdirs[0] logger.info(f"Flattening directory structure from {redundant_dir}") for item in redundant_dir.iterdir(): From 24def2223e7e32455dc6779b05b791341abba176 Mon Sep 17 00:00:00 2001 From: croelofs <25582572+roelofsc@users.noreply.github.com> Date: Tue, 13 Jan 2026 11:17:01 +0100 Subject: [PATCH 09/10] Remove time features from configs to remove work arounds and improve docstrings and comments in PreDist.ipynb and predist_utils.py. --- notebooks/PreDist/PreDist.ipynb | 305 +++++++++++++--------- notebooks/PreDist/configs/m1_cond_ae.yaml | 1 - notebooks/PreDist/configs/m1_doy_ae.yaml | 1 - notebooks/PreDist/configs/m2_cond_ae.yaml | 1 - notebooks/PreDist/configs/m2_doy_ae.yaml | 1 - notebooks/PreDist/predist_utils.py | 134 +++++++--- 6 files changed, 273 insertions(+), 170 deletions(-) diff --git a/notebooks/PreDist/PreDist.ipynb b/notebooks/PreDist/PreDist.ipynb index 48fa6d7..f6b46dd 100644 --- a/notebooks/PreDist/PreDist.ipynb +++ b/notebooks/PreDist/PreDist.ipynb @@ -4,7 +4,7 @@ "metadata": {}, "cell_type": "markdown", "source": [ - "# EnergyFaultDetector @ District Heatin\n", + "# EnergyFaultDetector @ District Heating\n", "\n", "This notebook shows how to apply the EnergyFaultDetector on the PreDist dataset (available on [zenodo](https://doi.org/10.5281/zenodo.17522254)) and how to reproduce results from the accompanying paper (preprint available on [arXiv](https://doi.org/10.48550/arXiv.2511.14791))." ], @@ -13,8 +13,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-12T08:17:49.721583300Z", - "start_time": "2026-01-12T08:17:43.412263500Z" + "end_time": "2026-01-13T10:50:14.641401100Z", + "start_time": "2026-01-13T10:50:07.635583200Z" } }, "cell_type": "code", @@ -28,7 +28,7 @@ "from energy_fault_detector.utils.visualisation import plot_reconstruction\n", "from energy_fault_detector.utils.analysis import create_events\n", "\n", - "from predist_utils import train_or_get_model, find_optimal_threshold, get_arcana_importances" + "from predist_utils import train_or_get_model, find_optimal_threshold, get_arcana_importances, calculate_earliness" ], "id": "a149ecfec1850ff7", "outputs": [ @@ -46,14 +46,14 @@ { "metadata": {}, "cell_type": "markdown", - "source": "### Load dataset", + "source": "### Load the PreDist dataset", "id": "5cab669e1b0c15d" }, { "metadata": { "ExecuteTime": { - "end_time": "2026-01-12T08:17:49.785659800Z", - "start_time": "2026-01-12T08:17:49.730587300Z" + "end_time": "2026-01-13T10:50:14.704952800Z", + "start_time": "2026-01-13T10:50:14.647830300Z" } }, "cell_type": "code", @@ -409,14 +409,23 @@ { "metadata": {}, "cell_type": "markdown", - "source": "### Create or load models (uses optimized configs)", + "source": [ + "### Create or load models (uses optimized configs)\n", + "\n", + "Models defined are:\n", + " - the default autoencoder,\n", + " - conditional autoencoder with day-of-week and hour-of-day time features, and\n", + " - day-of-year autoencoder with day-of-week, hour-of-day and day-of-year time features.\n", + "\n", + "The code size (bottleneck, latent dimension) of the autoencoder is represented as fraction of the input dimension." + ], "id": "ad56a689d11f8d2b" }, { "metadata": { "ExecuteTime": { - "end_time": "2026-01-12T08:17:49.953720900Z", - "start_time": "2026-01-12T08:17:49.839560800Z" + "end_time": "2026-01-13T10:50:14.854728100Z", + "start_time": "2026-01-13T10:50:14.744744800Z" } }, "cell_type": "code", @@ -424,22 +433,28 @@ "model_configs = {\n", " 1: {\n", " 'config_files': {\n", - " 'default_ae': './configs/m1_default_ae.yaml',\n", - " 'cond_ae': './configs/m1_cond_ae.yaml',\n", - " 'doy_ae': './configs/m1_doy_ae.yaml'\n", + " 'Default AE': './configs/m1_default_ae.yaml',\n", + " 'Conditional AE': './configs/m1_cond_ae.yaml',\n", + " 'Day-of-year AE': './configs/m1_doy_ae.yaml'\n", " },\n", - " 'bottleneck': 0.65\n", + " 'bottleneck': 0.65,\n", " },\n", " 2: {\n", " 'config_files': {\n", - " 'default_ae': './configs/m2_default_ae.yaml',\n", - " 'cond_ae': './configs/m2_cond_ae.yaml',\n", - " 'doy_ae': './configs/m2_doy_ae.yaml'\n", + " 'Default AE': './configs/m2_default_ae.yaml',\n", + " 'Conditional AE': './configs/m2_cond_ae.yaml',\n", + " 'Day-of-year AE': './configs/m2_doy_ae.yaml'\n", " },\n", " 'bottleneck': 0.25\n", " }\n", "}\n", "\n", + "time_features = {\n", + " 'Default AE': [],\n", + " 'Conditional AE': ['hour_of_day', 'day_of_week'],\n", + " 'Day-of-year AE': ['hour_of_day', 'day_of_week', 'day_of_year'],\n", + "}\n", + "\n", "# Model file exists, load the model\n", "load_from_file = True" ], @@ -450,8 +465,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-12T08:21:15.715824Z", - "start_time": "2026-01-12T08:17:50.035077400Z" + "end_time": "2026-01-13T10:51:42.942459900Z", + "start_time": "2026-01-13T10:50:15.097719300Z" } }, "cell_type": "code", @@ -462,36 +477,33 @@ "\n", "# Select which dataset(s) and model configs to test:\n", "manufacturers = [1, 2] # [1, 2]\n", - "models = ['default_ae', 'cond_ae'] # ['default_ae', 'cond_ae', 'doy_ae']\n", + "models = ['Default AE', 'Conditional AE'] # ['Default AE', 'Conditional AE', 'Day-of-year AE']\n", "\n", "results = {}\n", "for manufacturer in manufacturers:\n", " results[manufacturer] = {}\n", - " for config_name, config_file in model_configs[manufacturer]['config_files'].items():\n", - " if config_name not in models:\n", + " for model_name, config_file in model_configs[manufacturer]['config_files'].items():\n", + " if model_name not in models:\n", " continue\n", "\n", + " # get configuration and time features\n", " conf = Config(config_file)\n", - " dp_params = conf.config_dict['train']['data_preprocessor']['params']\n", - " ts_features = None\n", - " if dp_params.get('ts_features'):\n", - " ts_features = dp_params.pop('ts_features') # remove time features from config\n", "\n", " # Prepare parameters for parallel execution\n", " bottleneck_ratio = model_configs[manufacturer]['bottleneck']\n", - " events_to_process = dataset.events[manufacturer].iterrows()\n", + " events_to_process = dataset.events[manufacturer].index\n", "\n", " # Run parallel over events\n", " # n_jobs=-1 uses all CPU cores. Adjust if memory is an issue.\n", " parallel_results = Parallel(n_jobs=-1, verbose=10)(\n", " delayed(train_or_get_model)(\n", - " event_id, dataset, manufacturer, config_name,\n", - " conf, bottleneck_ratio, load_from_file, ts_features\n", - " ) for event_id, event_row in events_to_process\n", + " event_id, dataset, manufacturer, model_name,\n", + " conf, bottleneck_ratio, load_from_file, time_features[model_name]\n", + " ) for event_id in events_to_process\n", " )\n", "\n", " # Create the results dictionary\n", - " results[manufacturer][config_name] = dict(parallel_results)" + " results[manufacturer][model_name] = dict(parallel_results)" ], "id": "d6f9edc9349242ca", "outputs": [ @@ -500,45 +512,45 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 20 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 27.1s\n", - "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 42.2s\n", - "[Parallel(n_jobs=-1)]: Done 21 tasks | elapsed: 57.9s\n", - "[Parallel(n_jobs=-1)]: Done 32 out of 64 | elapsed: 1.0min remaining: 1.0min\n", - "[Parallel(n_jobs=-1)]: Done 39 out of 64 | elapsed: 1.2min remaining: 44.5s\n", - "[Parallel(n_jobs=-1)]: Done 46 out of 64 | elapsed: 1.2min remaining: 28.1s\n", - "[Parallel(n_jobs=-1)]: Done 53 out of 64 | elapsed: 1.2min remaining: 15.4s\n", - "[Parallel(n_jobs=-1)]: Done 60 out of 64 | elapsed: 1.3min remaining: 5.2s\n", - "[Parallel(n_jobs=-1)]: Done 64 out of 64 | elapsed: 1.3min finished\n", + "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 27.9s\n", + "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 34.2s\n", + "[Parallel(n_jobs=-1)]: Done 21 tasks | elapsed: 35.7s\n", + "[Parallel(n_jobs=-1)]: Done 32 out of 64 | elapsed: 39.7s remaining: 39.7s\n", + "[Parallel(n_jobs=-1)]: Done 39 out of 64 | elapsed: 40.6s remaining: 26.0s\n", + "[Parallel(n_jobs=-1)]: Done 46 out of 64 | elapsed: 43.6s remaining: 17.0s\n", + "[Parallel(n_jobs=-1)]: Done 53 out of 64 | elapsed: 44.3s remaining: 9.1s\n", + "[Parallel(n_jobs=-1)]: Done 60 out of 64 | elapsed: 45.2s remaining: 2.9s\n", + "[Parallel(n_jobs=-1)]: Done 64 out of 64 | elapsed: 45.8s finished\n", "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 20 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 12.2s\n", - "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 16.3s\n", - "[Parallel(n_jobs=-1)]: Done 21 tasks | elapsed: 26.8s\n", - "[Parallel(n_jobs=-1)]: Done 32 out of 64 | elapsed: 31.8s remaining: 31.8s\n", - "[Parallel(n_jobs=-1)]: Done 39 out of 64 | elapsed: 35.4s remaining: 22.7s\n", - "[Parallel(n_jobs=-1)]: Done 46 out of 64 | elapsed: 44.4s remaining: 17.3s\n", - "[Parallel(n_jobs=-1)]: Done 53 out of 64 | elapsed: 46.2s remaining: 9.5s\n", - "[Parallel(n_jobs=-1)]: Done 60 out of 64 | elapsed: 49.3s remaining: 3.2s\n", - "[Parallel(n_jobs=-1)]: Done 64 out of 64 | elapsed: 50.2s finished\n", + "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 3.3s\n", + "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 4.9s\n", + "[Parallel(n_jobs=-1)]: Done 21 tasks | elapsed: 8.4s\n", + "[Parallel(n_jobs=-1)]: Done 32 out of 64 | elapsed: 9.8s remaining: 9.8s\n", + "[Parallel(n_jobs=-1)]: Done 39 out of 64 | elapsed: 10.6s remaining: 6.8s\n", + "[Parallel(n_jobs=-1)]: Done 46 out of 64 | elapsed: 13.7s remaining: 5.3s\n", + "[Parallel(n_jobs=-1)]: Done 53 out of 64 | elapsed: 14.5s remaining: 2.9s\n", + "[Parallel(n_jobs=-1)]: Done 60 out of 64 | elapsed: 15.7s remaining: 1.0s\n", + "[Parallel(n_jobs=-1)]: Done 64 out of 64 | elapsed: 16.1s finished\n", "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 20 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 9.2s\n", - "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 9.8s\n", - "[Parallel(n_jobs=-1)]: Done 23 out of 56 | elapsed: 19.8s remaining: 28.4s\n", - "[Parallel(n_jobs=-1)]: Done 29 out of 56 | elapsed: 23.5s remaining: 21.9s\n", - "[Parallel(n_jobs=-1)]: Done 35 out of 56 | elapsed: 25.7s remaining: 15.4s\n", - "[Parallel(n_jobs=-1)]: Done 41 out of 56 | elapsed: 32.5s remaining: 11.8s\n", - "[Parallel(n_jobs=-1)]: Done 47 out of 56 | elapsed: 33.6s remaining: 6.4s\n", - "[Parallel(n_jobs=-1)]: Done 53 out of 56 | elapsed: 34.8s remaining: 1.9s\n", - "[Parallel(n_jobs=-1)]: Done 56 out of 56 | elapsed: 36.2s finished\n", + "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 2.9s\n", + "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 3.5s\n", + "[Parallel(n_jobs=-1)]: Done 23 out of 56 | elapsed: 6.7s remaining: 9.7s\n", + "[Parallel(n_jobs=-1)]: Done 29 out of 56 | elapsed: 7.5s remaining: 7.0s\n", + "[Parallel(n_jobs=-1)]: Done 35 out of 56 | elapsed: 8.4s remaining: 5.0s\n", + "[Parallel(n_jobs=-1)]: Done 41 out of 56 | elapsed: 11.0s remaining: 4.0s\n", + "[Parallel(n_jobs=-1)]: Done 47 out of 56 | elapsed: 11.4s remaining: 2.1s\n", + "[Parallel(n_jobs=-1)]: Done 53 out of 56 | elapsed: 12.0s remaining: 0.6s\n", + "[Parallel(n_jobs=-1)]: Done 56 out of 56 | elapsed: 12.4s finished\n", "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 20 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 10.0s\n", - "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 10.4s\n", - "[Parallel(n_jobs=-1)]: Done 23 out of 56 | elapsed: 21.5s remaining: 30.8s\n", - "[Parallel(n_jobs=-1)]: Done 29 out of 56 | elapsed: 25.5s remaining: 23.8s\n", - "[Parallel(n_jobs=-1)]: Done 35 out of 56 | elapsed: 27.9s remaining: 16.7s\n", - "[Parallel(n_jobs=-1)]: Done 41 out of 56 | elapsed: 34.6s remaining: 12.6s\n", - "[Parallel(n_jobs=-1)]: Done 47 out of 56 | elapsed: 34.7s remaining: 6.6s\n", - "[Parallel(n_jobs=-1)]: Done 53 out of 56 | elapsed: 37.1s remaining: 2.0s\n", - "[Parallel(n_jobs=-1)]: Done 56 out of 56 | elapsed: 39.1s finished\n" + "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 3.2s\n", + "[Parallel(n_jobs=-1)]: Done 10 tasks | elapsed: 3.8s\n", + "[Parallel(n_jobs=-1)]: Done 23 out of 56 | elapsed: 7.5s remaining: 10.7s\n", + "[Parallel(n_jobs=-1)]: Done 29 out of 56 | elapsed: 8.2s remaining: 7.7s\n", + "[Parallel(n_jobs=-1)]: Done 35 out of 56 | elapsed: 9.2s remaining: 5.5s\n", + "[Parallel(n_jobs=-1)]: Done 41 out of 56 | elapsed: 11.9s remaining: 4.3s\n", + "[Parallel(n_jobs=-1)]: Done 47 out of 56 | elapsed: 12.2s remaining: 2.2s\n", + "[Parallel(n_jobs=-1)]: Done 53 out of 56 | elapsed: 12.8s remaining: 0.6s\n", + "[Parallel(n_jobs=-1)]: Done 56 out of 56 | elapsed: 13.2s finished\n" ] } ], @@ -549,15 +561,15 @@ "cell_type": "markdown", "source": [ "### Find optimal criticality threshold based on the reliability score\n", - "Calculate max criticality before report date and optimize criticality threshold using 5-fold CV" + "Calculate max criticality before the report timestamp and optimize criticality threshold. We use cross-validation to find the criticality threshold to prevent overfitting, so the model will generalize better to unseen data." ], "id": "3c0ee0eeabed5068" }, { "metadata": { "ExecuteTime": { - "end_time": "2026-01-12T08:21:30.617322700Z", - "start_time": "2026-01-12T08:21:17.307176200Z" + "end_time": "2026-01-13T10:51:46.183337500Z", + "start_time": "2026-01-13T10:51:43.076058800Z" } }, "cell_type": "code", @@ -568,30 +580,34 @@ "true_anomalies = {}\n", "\n", "for manufacturer in results.keys():\n", + " # prepare result dictionaries\n", " max_criticality_results[manufacturer] = {}\n", " criticality_thresholds[manufacturer] = {}\n", " predicted_anomalies[manufacturer] = {}\n", "\n", + " # save true anomalies for easy access later\n", " true_anomalies[manufacturer] = (dataset.events[manufacturer]['Event type'] == 'anomaly').astype(int)\n", "\n", - " for config_name, results_dict in results[manufacturer].items():\n", + " for model_name, results_dict in results[manufacturer].items():\n", "\n", + " # calculate max criticality for each event\n", " max_criticality_list = []\n", " for event_id, prediction in results_dict.items():\n", " event_row = dataset.events[manufacturer].loc[event_id]\n", " max_criticality = prediction.criticality().loc[:event_row['Report date']].max()\n", " max_criticality_list += [(event_id, max_criticality)]\n", "\n", + " # Transform results to pandas series with max criticality with event id as index\n", " c = pd.DataFrame(max_criticality_list, columns=['event_id', 'max_criticality'])\n", " c = c.set_index('event_id')['max_criticality']\n", - " max_criticality_results[manufacturer][config_name] = c\n", + " max_criticality_results[manufacturer][model_name] = c\n", "\n", - " criticality_threshold = find_optimal_threshold(\n", + " criticality_threshold, _ = find_optimal_threshold(\n", " true_anomalies=true_anomalies[manufacturer],\n", - " max_criticalities=max_criticality_results[manufacturer][config_name],\n", + " max_criticalities=max_criticality_results[manufacturer][model_name],\n", " )\n", - " criticality_thresholds[manufacturer][config_name] = criticality_threshold\n", - " predicted_anomalies[manufacturer][config_name] = c > criticality_threshold" + " criticality_thresholds[manufacturer][model_name] = criticality_threshold\n", + " predicted_anomalies[manufacturer][model_name] = c > criticality_threshold" ], "id": "4f741a688f149cd7", "outputs": [], @@ -606,38 +622,52 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-12T08:21:31.920364500Z", - "start_time": "2026-01-12T08:21:30.617322700Z" + "end_time": "2026-01-13T10:51:47.519369900Z", + "start_time": "2026-01-13T10:51:46.252375100Z" } }, "cell_type": "code", "source": [ "for manufacturer in results.keys():\n", " print(f'Manufacturer m{manufacturer}')\n", - " for config_name in results[manufacturer].keys():\n", - " print(f'Model {config_name}:')\n", + " for model_name in results[manufacturer].keys():\n", + " print(f'Model {model_name}:')\n", "\n", " reliability = fbeta_score(\n", - " true_anomalies[manufacturer], predicted_anomalies[manufacturer][config_name],\n", + " true_anomalies[manufacturer], predicted_anomalies[manufacturer][model_name],\n", " beta=0.5\n", " )\n", " precision = precision_score(\n", - " true_anomalies[manufacturer], predicted_anomalies[manufacturer][config_name]\n", + " true_anomalies[manufacturer], predicted_anomalies[manufacturer][model_name]\n", " )\n", " recall = recall_score(\n", - " true_anomalies[manufacturer], predicted_anomalies[manufacturer][config_name]\n", + " true_anomalies[manufacturer], predicted_anomalies[manufacturer][model_name]\n", " )\n", - " print(f'Reliability: {reliability:.2f}, Precision: {precision:.2f}, Recall: {recall:.2f}')\n", + "\n", + " # Average earliness score over reports\n", + " earliness_scores = []\n", + " for event_id, predictions in results[manufacturer][model_name].items():\n", + " if dataset.events[manufacturer].loc[event_id]['Event type'] == 'anomaly':\n", + " criticality = predictions.criticality()\n", + " detection_time, earliness = calculate_earliness(\n", + " criticality_threshold=criticality_thresholds[manufacturer][model_name],\n", + " report_ts=dataset.events[manufacturer].loc[event_id]['Report date'],\n", + " criticality=criticality\n", + " )\n", + " earliness_scores.append(earliness)\n", + " avg_earliness = sum(earliness_scores) / len(earliness_scores)\n", + "\n", + " print(f'Reliability: {reliability:.2f}, Precision: {precision:.2f}, Recall: {recall:.2f}, Earliness: {avg_earliness:.2f}')\n", "\n", " fig, ax = plt.subplots()\n", " disp = ConfusionMatrixDisplay.from_predictions(\n", - " y_true=true_anomalies[manufacturer], y_pred=predicted_anomalies[manufacturer][config_name],\n", + " y_true=true_anomalies[manufacturer], y_pred=predicted_anomalies[manufacturer][model_name],\n", " cmap='Blues',\n", " labels=[False, True],\n", " display_labels=['Normal', 'Anomaly'],\n", " ax=ax\n", " )\n", - " ax.set_title(f'Confusion matrix m{manufacturer}, model {config_name}.')\n" + " ax.set_title(f'Confusion matrix - Manufacturer M{manufacturer} - {model_name}.')\n" ], "id": "3b5c248383e4592e", "outputs": [ @@ -646,15 +676,15 @@ "output_type": "stream", "text": [ "Manufacturer m1\n", - "Model default_ae:\n", - "Reliability: 0.89, Precision: 1.00, Recall: 0.62\n", - "Model cond_ae:\n", - "Reliability: 0.89, Precision: 1.00, Recall: 0.62\n", + "Model Default AE:\n", + "Reliability: 0.89, Precision: 1.00, Recall: 0.62, Earliness: 0.57\n", + "Model Conditional AE:\n", + "Reliability: 0.89, Precision: 1.00, Recall: 0.62, Earliness: 0.56\n", "Manufacturer m2\n", - "Model default_ae:\n", - "Reliability: 0.73, Precision: 0.86, Recall: 0.46\n", - "Model cond_ae:\n", - "Reliability: 0.73, Precision: 1.00, Recall: 0.35\n" + "Model Default AE:\n", + "Reliability: 0.73, Precision: 0.86, Recall: 0.46, Earliness: 0.39\n", + "Model Conditional AE:\n", + "Reliability: 0.73, Precision: 1.00, Recall: 0.35, Earliness: 0.26\n" ] }, { @@ -662,7 +692,7 @@ "text/plain": [ "
" ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiYAAAHHCAYAAACLPpP8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABIPElEQVR4nO3dB5gT5dbA8TMLLEtbeu+9gwqKiFSRpnQsgFLFa6FIU7kqIqhIEVCkWBAERbDhFVT86CBFAUVFBGkKSlPaUqQI8z3n9SY3WXbZzSbZncn+fz7jksmUN8kkOTlvs2zbtgUAAMABotK6AAAAAB4EJgAAwDEITAAAgGMQmAAAAMcgMAEAAI5BYAIAAByDwAQAADgGgQkAAHAMAhMAAOAYBCYIq507d0qzZs0kZ86cYlmWfPzxxyE9/i+//GKOO2vWrJAeNxKUKlVKevTokdbFiGh63en1p9dhoEaMGGH2TalGjRqZJSX+/vtvefTRR6V48eISFRUl7dq1E6c9P0i/CEzSgd27d8u//vUvKVOmjMTExEhsbKzUq1dPXnrpJfnrr7/Ceu7u3bvLDz/8IM8995zMmTNHateuHdbzRaJt27aZLzG3f7j/3//9n/Tu3VuqVasmGTJkMIET0sabb74p48aNk06dOslbb70lAwcOTLVzT506lR8SuKqMV78bbvfpp5/KHXfcIZkzZ5Zu3bqZL4ULFy7Il19+KUOHDpUff/xRXnvttbCcW4Oe9evXyxNPPCF9+/YNyzlKlixpzpMpUyaJ5MDkmWeeMb+OA/ky37Fjh/k17BRz586V+fPny3XXXSdFihRJ6+Kka8uXL5eiRYvKxIkTU/3cGpjky5ePbB4SRWASwfbu3St33323+fLWD6LChQt773v44Ydl165dJnAJlz/++MP8zZUrV9jOoWlizQLhHzon57lz5yRLliwmGHWS559/Xl5//XUTRN5+++2ydevWtC5SunXkyJGwvi+BYDjn5xRCbuzYsXL69GmZMWOGX1DiUa5cORkwYIBfvfOoUaOkbNmy5ktNf53/+9//lvPnz/vtp+v1i0WzLjfccIMJDLSaaPbs2d5ttOpBAyKlmRkNIDy/9vWXUkK//BOqc1+yZIncfPPN5kM0e/bsUrFiRVOmpNqYaCBWv359yZYtm9m3bdu28tNPPyV4Pg3QtEy6nbaF6dmzp5w9ezbJ51czGJqB+v7776Vhw4aSNWtW85x+8MEH5v5Vq1ZJnTp1TJCg5V66dKnf/r/++qs89NBD5j7dJm/evCa75Vtlo49L16nGjRub8uqycuVKv9fiiy++MNVkepxXX33Ve5/nV6kGLLp//vz5zZeSh2bPqlevbl7zM2fOJPpY9Xx63vfee89kb/TXdo4cOUxVwMmTJ8018sgjj0iBAgXM66TPYfzrRrMkoc5sBfsaqG+//VZatmxpqji17Lfccots2LDhiu00u9ikSRNzrGLFismzzz4rly9fTrBcn3/+uff60+fptttuM/unlGY19TXSc+t7bs2aNQlup8/5008/bZ4DfQ9rGxJtS+J5LTzvlxUrVpjyxL+exo8fLzfddJO5FvVctWrV8j6XyWnXpev1fZUYvSb1vPq6eM4dSDuZmTNnmtdArzN9fFWqVJFp06alymuAVGQjYhUtWtQuU6ZMsrfv3r27rZdEp06d7ClTptjdunUzt9u1a+e3XcmSJe2KFSvaBQsWtP/973/br7zyin3dddfZlmXZW7duNdt899139sSJE83+nTt3tufMmWMvWLDAex49RnxPP/202d5DjxUdHW3Xrl3bfumll+zp06fbQ4YMsRs0aODdZu/evWafmTNnetctWbLEzpgxo12hQgV77Nix9jPPPGPny5fPzp07t9k+/vmuvfZau0OHDvbUqVPt++67z6x79NFHk3y+GjZsaBcpUsQuXry4PXToUHvy5Ml2lSpV7AwZMtjz5s2zCxUqZI8YMcKeNGmSeS1y5sxpx8XFefd///337Zo1a9rDhw+3X3vtNfNcahn1uTlz5ozZZvfu3Xb//v1NmfR+fR51OXTokPe1KFeunNnv8ccfN8/RihUrvPfpc+2xZ88eO3v27Hb79u2963Qffd1WrVp11ceqx9QyXHPNNXbdunXtl19+2ZRL97377rvtLl262C1btjTXzb333mu21ec9MbfddluC10Cggn0N9BrLli2bXbhwYXvUqFH2Cy+8YJcuXdrOnDmzvWHDBu92Bw8etPPnz2+eZz3euHHj7PLly9s1atQwj9X3upo9e7Z5Xlq0aGHKM2bMGLtUqVJ2rly5Erz+kvLGG2+Y7W666SbzvD/yyCPmWPre1sfvcenSJbtZs2Z21qxZzTavvvqq3bdvX/NeaNu2rdnm9OnT5vqpVKmSXaxYsSuuJ1330EMPmff0hAkT7BtuuMGce9GiRVd9z3noen1cHrqN7/OjnwF6Dj2/59z/93//l8xX27avv/56u0ePHuazRZ9bfbx6fC2vr+S+BnAmApMIdfLkSfOG9XwgJWXLli1me/1i9qWBgK5fvny5d51+oei61atXe9cdOXLEfJgPHjz4ig8w/RD3ldzAxBPY/PHHH4mWO6EPSf3yLFCggH306FHvOg2UoqKiTLAV/3y9evXyO6Z+cefNm9dOin4p6P5z5871rtu+fbtZp+fy/WL74osvrijn2bNnrzjm+vXrzXb6weobwOg6T8Dhy/NaLF68OMH7fAMTpV9Wuv3bb79tyqdf4PollhRPYFKtWjX7woUL3vUadOoXgAYlvjR4uVrgEcrAJJjXQINuDX41APQ4cOCAnSNHDr8AWJ8j3ferr77yu+Y10PH94j116pT58uvTp49fOfWLX7f1XZ+cwESfa72W9Zo+f/68d70Gsrqvb2CiX/L6mNesWeN3DA1Wddu1a9f6PW9Vq1a94nzxr0k9v77mTZo0CUlgovS8vuUORELvmebNm/v9AAvkNYAzUZUToeLi4sxfTWEmx2effWb+Dho0yG/94MGDzd/4bVE0happUg+tItBU+Z49eyRUPHXg//nPfxJNmcd38OBB2bJli6nCyJMnj3d9jRo15NZbb/U+Tl8PPPCA3219XEePHvU+h1ejqX9tx+Ohz4GWu3LlyqYKwcPzb9/nR1PlHhcvXjTn1BS87v/NN99IcpUuXVqaN2+erG3vv/9+s22/fv3k3nvvNdUD2vYjubQBtW91jD4u/T7q1auX33a6fv/+/aZ6MNxS+hpcunTJ9BTSrrJaFemh1Z5dunQxVZWea0CvmxtvvNFUo/he8127dr2i6vHEiRPSuXNn+fPPP72L9kLS82sVSiA2bdpkqt70Go2Ojvau1+tbqx19vf/+++YxV6pUye/cWvWhknNu32vy+PHjpppO3w+BXI/h5Fs+LZs+Pq3C09dUb4fjNUDqo/FrhNL6cnXq1Klkba/tHbQHh34x+ipUqJD5kNf7fZUoUeKKY+TOndt8mIXKXXfdJW+88Ybcd9998vjjj5u6/w4dOph2DYn1NvGUU7+c4tMPbW2LoW0ptN45sceij0PpY/E8j4nRtgbx28XoF4bW7cdf5zmmh/YmGj16tKk3//33380XvIfnQza5gUkgtM2RBiQ6xsy6dev8PuyTEv+58jyuhB6vBpP6OLS9Qjil9DXQxtnaliixa0XLr8FV1apVzXXlG+R4xN9Xn1PlCQbiS+p6Sux6Ll++vN96DQ59gynPubUdlQZMCfFtW5SYRYsWmbYzGtz7thEKZryVUFq7dq1pQ6O9/eK3A9NrTV/jUL8GSH0EJhFK33za2DDQng/J/QDSXx8J8f1yDfQc+gvWl35hrl692vzC0YzN4sWLTXdT/cDRX7qJlSFQwTyWxPZNzjE1a6FBiTYarVu3rncQOv31n9wMkQoksFDa0NHzpaNjzOi5kyuYxxsuTiqT53XTMXs0qI8vY8aMYT23NmSeMGFCgvfHD9Ti0wa1bdq0kQYNGpguvZo50gBIr1Ht6h3o+zcc4zHpjxPNCOlj1MejWSTNZmm3Z89zn5avAUKDVyiCaW8Nbc2vvy6S+vLRHjT6htZfG/pr0ePw4cMmLerpYRMKmpHQY8YXPyujNDOiH0a66IeRVjvouCgarDRt2jTBx+EZwyO+7du3m/ETfLMlaUl7O+gAdC+++KJ3nXb1jf/chPLXqlZ1aUCko/Hqh/qQIUNM1U4oX1+30MyC9uJJ7FrRa8/zZa7Pj+eXuK/4+2omSmmvkYSuz0B5Xhc9t28GQKv+dDiAmjVr+p37u+++M++VlFwzH374oelhp1lF367mGpgklFGMf50m9P5NSEqv54ULF5qA+pNPPvHL3MWvmgn1a4DURxuTCKbdBPVLWKtCNMBI6BeIjv6qWrVqZf5OmjTJbxvPry/tahcq+sGhaVft4un7hblgwQK/7Y4dO3bFvtdcc435G78rqof+ytNtdDRL3w9OzRxplsXzOJ1Af9HH//U+efLkK355egKphIK5QPXp08cEoFqdo0Gr/nrU0VhTI7PhNPr8a4CmbZh8u2jre0UzBNpN3ZP21+tGuxB//fXX3u20Kuidd97xO6YGebqPBtAaPCQ2tk9yaRdwDaCmT59uunZ7aFfd+NfDnXfeaaoEdayY+LTa8GrdwT3PhwYNvtefPi/xp5HQx6cBvmYzfWmWJTn0ek7JtezJgMWv8owfOAXyGuj+GoQGUnWK8CNjEsE0ANAPWG2roVkQ35FftW2BNpbzjHOhv7z017t+WemHhjYo0w9h/YLXxoE6BkaoaFXFY489Ju3bt5f+/fubumIdi6BChQp+jexGjhxpPvw0KNJfjlpHrh9+2qZAvzQSo0Nt67gUmiXSL139UNYvfK0qudoYC2mR0dJ0s5ZLGxNrZkvH2YjfJkMDLf1QHjNmjPkA1V+znrEcAqEf4Folpl9q+hwqfV7uuece8/zrmCrhpIGo/tpVOnaMPhZtz+C5/lq3bu3d1jPOTbiH4dfze8bK0cevgZqOA6OBr44D5Bvk62vVokULM/aPfrnqe0WvS98AW78Q9bnUhsU6wq1e6xpY7Nu3zzz3OhXEK6+8kuzyaVWKllGnlNDXXN/LminR1zJ+GxM9p44zow1lNYug59IgQ794db1nrJvE6PtMf4joY9TGv/p+mzJliml35vsYlf7YeeGFF8xfPaa+T3/++edkPSYdG0WfI31cemy9jhNrD+LLk+XT60SfDx2jSYMw3V9/2KTkNdAfQzrmjj6fjETrIGndLQjh9/PPP5suctqPX7tGalfIevXqmf79586d82538eJFM/aEjuOQKVMmMzbEsGHD/LZR2s1Tu3vGp10AfbsBJtZdWOnYBdoNUcujY6Jo99X43SeXLVtmujvrOBW6nf7V7qn6eJLqurh06VLzGLNkyWLHxsbarVu3trdt2+a3jed88bsjJ9TFMSGJdblM7PnRYz788MPe28ePH7d79uxpxljR8UW026N2dU2om+/rr79uukRq917frsOJnctzn+c4+/fvN10l9XmIT7tH61geOs5JUt2FtetyQs/Vxo0bk3xuPdsmtMR/vPqc3HjjjXZSgn0N1DfffGOee30NdAyQxo0b2+vWrbti3++//96cLyYmxoyJouOezJgxI8FrRZ8vPaY+57p92bJlzfgbmzZtuuI5Sg4dY8czvoqO66Nd9eO/3zzde3XMDn1OdFsdd6VWrVrmfa1DCCT1vOnj0fFZdF8da0Rfs4TKqd12e/fubR6ffp7ceeedpvt0croLa7ddfW10v/hdnpPyySefmLFj9DnVzzN9rG+++WaKXwNP+RLq+oy0Y+n/0jo4AgDfuYG0J4z2EAllFSIAd6CNCQBH0WoIrYYjKAHSJzImAIA0dejQoSS7xMcfUA6Ri8AEAJCmkupCrA3zE5o0EJGJXjkAgDSlPaOuRgeLRNrT3k66eHrLaVuw4cOHm16QSmeK1pmjfWkPKu3uHggyJgAAIFmD3OnQBTpFgoYOOpyEDs/w7bffmiBFAxMd9kGHevDQQQwDnQaAjAkAAEiS71hD6rnnnjMZFB18UAMTTyCS0FQAgSAwcRAdkfPAgQNmRmCnTJoFAEg+zSTo5Kla/ZTYZKOhcO7cOb/RgIMpb/zvGx3E0XdagoTo4H06SKeOKOw75YmOhvz222+b4EQDmaeeesoEK4EgMHEQDUqSmmgLAOB8OjO1Z4TlcAQlWXLkFfnbf4bllMiePbsZRdeXzuCc2CjZnok/tQy6r46eqyNXKx0xWEdD1qBMRwvWEb51PqmPPvoooDLRxsRBdIjuXLlySXSV7mJliE7r4gBhsW/l+LQuAhA2p+LipFzp4mZqj3B1cY6LizPHzlylu0gw3xWXLsj5bW+ZIMq3HcjVMiaapdHh/fX7SicifeONN0yDV09w4mv58uVmUkmdgsIzuWJykDFxEE86TYMSAhNEqkAbwgFulCrV8RljgvqusK0o73syue9Lna9I5zjyzHu0ceNGMxmszjEVX506dcxfAhMAANIDy0RAwe0fgraRic32vmXLFu+s74EgMAEAwI2sqH+WYPYPwLBhw8yYJSVKlDANfHX2+pUrV5qZq3fv3m1ut2rVysyQrm1MBg4cKA0aNJAaNWoEdB4CEwAAkKQjR45It27d5ODBg6aNiwYcGpTceuutpp3K0qVLZdKkSaanjnbk6Nixozz55JMSKAITAADcyLKCrMoJbN8ZM2Ykep8GIvFHfU0pAhMAANzISt2qnNTizFIBAIB0iYwJAABuZKVuVU5qITABAMCVooKsjnFmpYkzSwUAANIlMiYAALiRRVUOAABwCoteOQAAAGFFxgQAADeyqMoBAABOYUVmVQ6BCQAAbmRFZsbEmeESAABIl8iYAADgRhZVOQAAwFFVOVHB7e9AzgyXAABAukTGBAAAN4qy/lmC2d+BCEwAAHAjKzLbmDizVAAAIF0iYwIAgBtZkTmOCYEJAABuZFGVAwAAEFZkTAAAcCOLqhwAAOAUVmRW5RCYAADgRlZkZkycGS4BAIB0iYwJAABuZFGVAwAAnMKiKgcAACCsyJgAAOBKUUFWxzgzN0FgAgCAG1lU5QAAAIQVGRMAAFybMYkKbn8HIjABAMCNrMjsLuzMUgEAgHSJjAkAAG5kRWbjVwITAADcyIrMqhwCEwAA3MiKzIyJM8MlAACQLpExAQDAjSyqcgAAgFNYVOUAAACEFRkTAABcyLIsswRxAHEiMiYAALg4MLGCWAIxbdo0qVGjhsTGxpqlbt268vnnn3vvP3funDz88MOSN29eyZ49u3Ts2FEOHz4c8OMiMAEAAEkqVqyYvPDCC7J582bZtGmTNGnSRNq2bSs//vijuX/gwIGycOFCef/992XVqlVy4MAB6dChgwSKqhwAANzI+u8SzP4BaN26td/t5557zmRRNmzYYIKWGTNmyNy5c03AombOnCmVK1c29994443JPg8ZEwAA0nFVTlxcnN9y/vz5JM996dIlmTdvnpw5c8ZU6WgW5eLFi9K0aVPvNpUqVZISJUrI+vXrA3pcBCYAAKRjxYsXl5w5c3qX0aNHJ7rtDz/8YNqPZM6cWR544AFZsGCBVKlSRQ4dOiTR0dGSK1cuv+0LFixo7gsEVTkAAKTjXjn79+83jVk9NOhITMWKFWXLli1y8uRJ+eCDD6R79+6mPUkoEZgAAJCOA5PY//aySQ7NipQrV878u1atWrJx40Z56aWX5K677pILFy7IiRMn/LIm2iunUKFCARWLqhwAAFzISuXuwgm5fPmyaZOiQUqmTJlk2bJl3vt27Ngh+/btM21QAkHGBAAAJGnYsGHSsmVL06D11KlTpgfOypUr5YsvvjBtU3r37i2DBg2SPHnymAxMv379TFASSI8cRWACAIAbWanbXfjIkSPSrVs3OXjwoAlEdLA1DUpuvfVWc//EiRMlKirKDKymWZTmzZvL1KlTAy4WgQkAAC5kpfKQ9DpOydXExMTIlClTzBIM2pgAAADHIGMCAIALWdY/WZOUH0AcicAEAAAXsiTYnjXOjEyoygEAAI5BxgQAABeyUrnxa2ohMAEAwI2s1O0unFqoygEAAI5BxgQAADeygqvKsanKAQAATmljYhGYAACAULEiNDChjQkAAHAMMiYAALiRFZm9cghMAABwIYuqHAAAgPAiYwIAgAtZEZoxITABAMCFrAgNTKjKAQAAjkHGBAAAF7IiNGNCYAIAgBtZkdldmKocAADgGGRMAABwIYuqHAAA4BQWgQkAAHAKK0IDE9qYAAAAxyBjAgCAG1mR2SuHwAQAABeyqMoBAAAILzImYbRy5Upp3LixHD9+XHLlypXWxUm3enW8WXp1rC/FC+cxt7fvOSTjZnwuS9dtM7cXTh8gN9cq77fPzA+/lEEvzEuT8gKh8vp7q2Ty28vkyNE4qVa+qIwZeofUqloqrYuFELHImKStHj16mCfxhRde8Fv/8ccfO/bJhTMcOHJCnnnlP9K421hp0n2crNn0s7wz/n6pVKaQd5tZC9ZKxRbDvMvTkz9O0zIDwfro/zbLk5MWyGP3tZSVcx4zgUnHflPkj2On0rpoCBFL/7OCWBzayMQ1gYmKiYmRMWPGmAxEqFy4cCFkx4IzLV6zVZas2yZ79v8hu/cdkWenLZQzZ89L7Wqlvdv8de6CHDl6yrucOnMuTcsMBGvq3OXSrd1N0rVNXalUprBMGHa3ZI2Jlrc/WZ/WRQMiJzBp2rSpFCpUSEaPHp3oNh9++KFUrVpVMmfOLKVKlZIXX3zR735dN2rUKOnWrZvExsbK/fffL7NmzTJVLYsWLZKKFStK1qxZpVOnTnL27Fl56623zD65c+eW/v37y6VLl7zHmjNnjtSuXVty5MhhytWlSxc5cuRIWJ8DBCcqypIOt9aSrFmiZeMPe73r72hRW3YteUHWzfu3DH+4jWTJnClNywkE48LFv2XL9v3S6IaK3nVRUVHS8IaKftc93M0KJlsSZDVQOLmqjUmGDBnk+eefNwGABgnFihXzu3/z5s1y5513yogRI+Suu+6SdevWyUMPPSR58+Y1VUEe48ePl+HDh8vTTz9tbq9Zs8YEIS+//LLMmzdPTp06JR06dJD27dubgOWzzz6TPXv2SMeOHaVevXrm2OrixYsmyNFgRgOSQYMGmfPo9nCWKmWLyBdvDpaY6Ixy5q/zcu/Q12XH3kPmvg++2CT7Dx6TQ3+clKrli8jTfdtKuZIFpNujb6R1sYEUOXritFy6dFny58nhtz5/nljZ+cvhNCsXQsyiu7AjaLBwzTXXmKBixowZfvdNmDBBbrnlFnnqqafM7QoVKsi2bdtk3LhxfoFJkyZNZPDgwd7bGphokDFt2jQpW7asWacZE82IHD58WLJnzy5VqlQxDVlXrFjhDUx69erlPUaZMmVMYHP99dfL6dOnzT5JOX/+vFk84uLignpukLidvx6WBl1HS2z2LNL2lmtl6oh75fZ/vWSCk7cWrPVut233ATn0Z5x8Mq2/lCqaT375/c80LTcApDeuqsrx0HYmWsXy008/+a3X25rR8KW3d+7c6VcFo9Uv8Wn1jScoUQULFjRVOL4Bhq7zrarRDE3r1q2lRIkSpjqnYcOGZv2+ffuS9Ti0SipnzpzepXjx4snaD4G7+Pcl2fvbn/Ld9v0ycsonsnXn7/LA3Y0S3Hbz1l/M3zLF86dyKYHQyJsru2TIEHVFQ9c/jsVJgbyxaVYuhJYVoVU5rgxMGjRoIM2bN5dhw4alaP9s2bJdsS5TJv82BfqCJbTu8uXL5t9nzpwxZdB2Ku+8845s3LhRFixYEFCDWi3/yZMnvcv+/ftT9HgQuCjLkujohBOG1Sv8U0V4+M+TqVwqIDSiM2WUayoVl1Ubd3jX6WfX6o0/y/XV/9foG+5mRWhg4rqqHA/tNqxVOtq+w6Ny5cqydu3/0vJKb2uVjrZPCaXt27fL0aNHTTk8mY5NmzYFdAxtoKsLwksbsy5d96PsP3RccmSNkU4taptxSzr2m2qqa/T2krU/yrGTZ0yXyucGdpC13+yUH3cdSOuiAyn2UJcm8tAzc+TayiXkuqqlZNq7K0z7qq6tb0zroiFELOufJZj9nci1gUn16tWla9eupl2Hh7Yb0TYe2iBV24GsX79eXnnlFZk6dWrIz6/VN9HR0TJ58mR54IEHZOvWrea8cJ58ubPLtBHdpGC+WIk7fU5+3PW7CUpWfr1dihbMZXouPHh3Y9NT5/fDx2Xh8i0y/s0v0rrYQFA6NKslf544Lc+/+qnpAl+9QlH54OWHqcqB47k2MFEjR46U+fPne29fd9118t5775keNxokFC5c2Gzj2/A1VPLnz2+6Gf/73/82wZGeW3v7tGnTJuTnQnD6Pzs30ft+P3zCNIIFItH9dzY0CyI5Y2IFtb8TWbZt22ldCPyvV442gs1cvY9YGaLTujhAWBzf+EpaFwEI6+d4wbw5TbtBbYMYzu+KMv0/kAyZr2wzmVyXzp+RPS93CmtZ003jVwAAEJlcXZUDAEB6ZTGJHwAAcApPr5xglkDo2FvawUTH7SpQoIC0a9dOduz4X5d01ahRoyu6JGsHkUAQmAAAgCStWrVKHn74YdmwYYMsWbLEjJjerFkzM66Xrz59+sjBgwe9y9ixYyUQVOUAAODSSUmjolJeHWMHuO/ixYv9bmvPVM2c6CjoOvCp70jqOrFtSpExAQDAhaxUrsqJT3vzqDx58vit19HQ8+XLJ9WqVTMjnOskuYEgYwIAQDoWF28C2eSMSq5THDzyyCNmPjoNQDy6dOkiJUuWlCJFisj3338vjz32mGmH8tFHHyW7PAQmAACk4145xeNNIPv000/LiBEjrrqvtjXREc+//PJLv/X333+/3wjtOtDpLbfcIrt37/abKPdqCEwAAEjHc+Xs37/fb4C1pLIlffv2lUWLFsnq1aulWLF/Jj1NTJ06dczfXbt2EZgAABDJrBBlTDQoSc7IrzpQfL9+/WTBggWycuVKKV066Zmqt2zZYv5q5iS5CEwAAECStPpm7ty58p///MeMZXLo0CGzXofHz5Ili6mu0ftbtWolefPmNW1MBg4caHrs1KhRQ5KLwAQAABeyUnnk12nTpnkHUfM1c+ZMM1ludHS0LF26VCZNmmTGNtG2Kx07dpQnn3wyoPMQmAAAkI7bmCRXUnP+aiCig7AFi3FMAACAY5AxAQDAhSwJsipHnDmJH4EJAAAuZKVyVU5qoSoHAAA4BhkTAABcyErlXjmphcAEAAAXsqjKAQAACC8yJgAAuJBFVQ4AAHAKK0KrcghMAABwIStCMya0MQEAAI5BxgQAADeygqyOcWbChMAEAAA3sqjKAQAACC8yJgAAuJBFrxwAAOAUFlU5AAAA4UXGBAAAF7KoygEAAE5hUZUDAAAQXmRMAABwIStCMyYEJgAAuJBFGxMAAOAUVoRmTGhjAgAAHIOMCQAALmRRlQMAAJzCoioHAAAgvMiYAADgQlaQ1THOzJcQmAAA4EpRlmWWYPZ3IqpyAACAY5AxAQDAhSx65QAAAKewIrRXDoEJAAAuFGX9swSzvxPRxgQAADgGGRMAANzICrI6xqEZEwITAABcyIrQxq9U5QAAAMcgYwIAgAtZ//0vmP2diMAEAAAXiqJXDgAAQHiRMQEAwIWs9DzA2ieffJLsA7Zp0yaY8gAAgHTcKydZgUm7du2SHX1dunQp2DIBAACHGT16tHz00Ueyfft2yZIli9x0000yZswYqVixonebc+fOyeDBg2XevHly/vx5ad68uUydOlUKFiwY2jYmly9fTtZCUAIAQOqIsqygl0CsWrVKHn74YdmwYYMsWbJELl68KM2aNZMzZ854txk4cKAsXLhQ3n//fbP9gQMHpEOHDqnXxkQjo5iYmGAOAQAAXFCVs3jxYr/bs2bNkgIFCsjmzZulQYMGcvLkSZkxY4bMnTtXmjRpYraZOXOmVK5c2QQzN954Y3h65WhWZNSoUVK0aFHJnj277Nmzx6x/6qmnTIEAAEDqNX61gliCoYGIypMnj/mrAYpmUZo2berdplKlSlKiRAlZv359so8bcGDy3HPPmShp7NixEh0d7V1frVo1eeONNwI9HAAASENxcXF+i7YNSYo233jkkUekXr165vtfHTp0yMQFuXLl8ttW25fofWELTGbPni2vvfaadO3aVTJkyOBdX7NmTdMgBgAApF5VjhXEoooXLy45c+b0LtrINSna1mTr1q2mkWuoBdzG5Pfff5dy5colGD1pCgcAAIRfVAoasMbfX+3fv19iY2O96zNnznzV/fr27SuLFi2S1atXS7FixbzrCxUqJBcuXJATJ074ZU0OHz5s7kt2uQJ8HFKlShVZs2bNFes/+OADufbaawM9HAAASEOxsbF+S2KBiW3bJihZsGCBLF++XEqXLu13f61atSRTpkyybNky77odO3bIvn37pG7duuHLmAwfPly6d+9uMieaJdE+zXpireLRCAoAAISf9d8lmP0DodU32uPmP//5j+TIkcPbbkSrf3RcE/3bu3dvGTRokGkQq0FOv379TFCS3B45KcqYtG3b1vRRXrp0qWTLls0EKj/99JNZd+uttwZ6OAAA4IJeOdOmTTM9cRo1aiSFCxf2LvPnz/duM3HiRLn99tulY8eOpguxVuFoAiPs45jUr1/fDK4CAADSB9u2k9xGxzabMmWKWVIqxQOsbdq0yWRKPO1OtG4JAACkjijrnyWY/Z0o4MDkt99+k86dO8vatWu9rW61Ba6Oma/dhnxb6AIAgPCwInR24YDbmNx3332mW7BmS44dO2YW/bc2hNX7AAAAUi1jopPyrFu3zm82Qf335MmTTdsTAACQOixnJj1SNzDREeISGkhN59ApUqRIqMoFAACugqqc/xo3bpzpl6yNXz303wMGDJDx48eHunwAAOAqjV+DWVybMcmdO7dfZHXmzBmpU6eOZMz4z+5///23+XevXr2kXbt24SstAACIaMkKTCZNmhT+kgAAAEnvVTnJCkx0CHoAAJB+h6RPLSkeYE2dO3fOzCToy3eGQgAAgLAGJtq+5LHHHpP33ntPjh49mmDvHAAAEF5RlmWWYPaPiF45jz76qJnuWCfz0amR33jjDXnmmWdMV2GdYRgAAISfZQW/RETGRGcR1gBEZxfs2bOnGVStXLlyUrJkSXnnnXeka9eu4SkpAACIeAFnTHQI+jJlynjbk+htdfPNN8vq1atDX0IAAJBor5xglogITDQo2bt3r/l3pUqVTFsTTybFM6kfAAAILytCq3ICDky0+ua7774z/3788cdlypQpEhMTIwMHDpShQ4eGo4wAACCdCLiNiQYgHk2bNpXt27fL5s2bTTuTGjVqhLp8AAAgHfXKCWocE6WNXnUBAACpxwqyOsahcUnyApOXX3452Qfs379/MOUBAADJkK6HpJ84cWKyHySBCQAACGtg4umFg9Qx69WhkjV7jrQuBhAWAxb8mNZFAMLmwtnTqdp7JSrI/SOyjQkAAEh9VoRW5Tg1YAIAAOkQGRMAAFzIsrTLb3D7OxGBCQAALhQVZGASzL7hRFUOAABwd2CyZs0aueeee6Ru3bry+++/m3Vz5syRL7/8MtTlAwAACWASv//68MMPpXnz5pIlSxb59ttv5fz582b9yZMn5fnnnw9HGQEAQCJVOcEsERGYPPvsszJ9+nR5/fXXJVOmTN719erVk2+++SbU5QMAAOlIwI1fd+zYIQ0aNLhifc6cOeXEiROhKhcAAEiHc+UEnDEpVKiQ7Nq164r12r6kTJkyoSoXAABIxuzCwSwREZj06dNHBgwYIF999ZVpOHPgwAF55513ZMiQIfLggw+Gp5QAACDBIemDWSKiKufxxx+Xy5cvyy233CJnz5411TqZM2c2gUm/fv3CU0oAAJAuBByYaJbkiSeekKFDh5oqndOnT0uVKlUke/bs4SkhAABIN21MUjzya3R0tAlIAABA6ouS4NqJ6P4REZg0btz4qoOyLF++PNgyAQCAdCrgwOSaa67xu33x4kXZsmWLbN26Vbp37x7KsgEAgERQlfNfEydOTHD9iBEjTHsTAAAQflFM4nd1OnfOm2++GarDAQCAdCjFjV/jW79+vcTExITqcAAAIImqmGAav0ZMVU6HDh38btu2LQcPHpRNmzbJU089FcqyAQCARNDGxGdOHF9RUVFSsWJFGTlypDRr1iyUZQMAAOlMQIHJpUuXpGfPnlK9enXJnTt3+EoFAAAc1fh19erVMm7cONm8ebOpKVmwYIG0a9fOe3+PHj3krbfe8tunefPmsnjx4sDKFcjGGTJkMFkRZhEGACBtWSH4LxBnzpyRmjVrypQpUxLdpkWLFiZo8Szvvvtu+KtyqlWrJnv27JHSpUsHfDIAAODOjEnLli3NcjU6d16hQoVSt7vws88+aybsW7RokYmG4uLi/BYAAOAecfG+x8+fP5/iY61cuVIKFChg2p4++OCDcvTo0fAFJtq4VdM4rVq1ku+++07atGkjxYoVM21NdMmVKxftTgAASOWMSVQQiypevLjp2OJZRo8enaLyaDXO7NmzZdmyZTJmzBhZtWqVybBo+9SwVOU888wz8sADD8iKFStSUl4AABBClmVdde665Oyv9u/fL7GxsX7VMSlx9913e/+tnWRq1KghZcuWNVmUW265JfSBiY5Xoho2bBhoWQEAgEPFxsb6BSahUqZMGcmXL5/s2rUrPIGJCiYyAwAA6WeunN9++820MSlcuHBA+wUUmFSoUCHJ4OTYsWMBFQAAADh/5NfTp0+b7IfH3r17ZcuWLZInTx6zaJOPjh07ml45u3fvlkcffVTKlStnxjIJW2CiJ40/8isAAIh8mzZtksaNG3tvDxo0yPzt3r27TJs2Tb7//nszwJqOdVakSBEz7tmoUaMCbrOSMdCGLdoNCAAApK0oywpqEr9A923UqJG3vWlCvvjiCwmFZAcmtC8BAMA5ohzexiSlkj2OydWiJAAAgFTNmFy+fDkkJwQAACFgBdf4NcCpclJNwHPlAACAtBclllmC2d+JCEwAAHAhK5W7C6eWgCfxAwAACBcyJgAAuFBUhPbKITABAMCFolJ5HJPUQlUOAABwDDImAAC4kBWhjV8JTAAAcGt3YSvyugtTlQMAAByDjAkAAC5kUZUDAACcVOURFeT+TuTUcgEAgHSIjAkAAC5kWZZZgtnfiQhMAABwISvICYKdGZYQmAAA4EqM/AoAABBmZEwAAHApSyIPgQkAAC5kReg4JlTlAAAAxyBjAgCAC1l0FwYAAE4RxcivAAAA4UXGBAAAF7KoygEAAE5hRejIr1TlAAAAxyBjAgCAC1lU5QAAAKeIitBeOQQmAAC4kBWhGROnBkwAACAdImMCAIALWRHaK4fABAAAF7KYxA8AACC8yJgAAOBCUWKZJZj9nYjABAAAF7KoygEAAAgvMiYAALiQ9d//gtnfiQhMAABwIYuqHAAAgPAiYwIAgAtZQfbKcWpVDhkTAABcXJVjBbEEYvXq1dK6dWspUqSImWfn448/9rvftm0ZPny4FC5cWLJkySJNmzaVnTt3Bvy4CEwAAHAhK5UDkzNnzkjNmjVlypQpCd4/duxYefnll2X69Ony1VdfSbZs2aR58+Zy7ty5gM5DVQ4AAEhSy5YtzZIQzZZMmjRJnnzySWnbtq1ZN3v2bClYsKDJrNx9992SXGRMAABwcXdhK4j/VFxcnN9y/vz5gMuyd+9eOXTokKm+8ciZM6fUqVNH1q9fH9CxCEwAAHChKCv4RRUvXtwEEZ5l9OjRAZdFgxKlGRJfettzX3JRlQMAQDq2f/9+iY2N9d7OnDlzmpaHjAkAAOm4Kic2NtZvSUlgUqhQIfP38OHDfuv1tue+5CIwAQDAhaxU7pVzNaVLlzYByLJly7zrtL2K9s6pW7duQMeiKgcAACTp9OnTsmvXLr8Gr1u2bJE8efJIiRIl5JFHHpFnn31WypcvbwKVp556yox50q5dOwkEgQkAAC5kBTl6a6B7btq0SRo3buy9PWjQIPO3e/fuMmvWLHn00UfNWCf333+/nDhxQm6++WZZvHixxMTEBHQeAhMAAFwoyqdnTUr3D0SjRo3MeCWJ0dFgR44caZZg0MYEAAA4BhmTIJQqVcrUqekC59q2/VdZ+NkG2fvLQTl+4rQMGXCHXF+rovf+rzZul6UrNsuevYfk9Jm/ZMyo+6RUycBakQNpqWzerNKkfD4pnitGcmbJJG9s2Cc/HDzlvT86Q5S0rlpAahSJlazRGeTYmQuyevcxWfvL8TQtN4Jj+fSsSen+TuSIjImOCpchQwa57bbb0rooiEDnz1+UkiUKSK9uLRK+/8IFqVihuHS5q0mqlw0IheiMUfL7yXPywXcHE7y/ffWCUrlgdpmz6TcZvXSXrNx9TDrWLCzVCuVI9bIiMnvlRFzGZMaMGdKvXz/z98CBA6YVLxAq19YsZ5bENKhXw/w98seJVCwVEDo/HT5tlsSUzptVvt53Unb9edbcXv/LcalXKreUyJ1Fth76X2YFbmz8mnIOjUvSPmOi3Y/mz58vDz74oMmYaMtej5UrV5rGNNovunbt2pI1a1a56aabZMeOHX7HmDZtmpQtW1aio6OlYsWKMmfOHL/79Rivvvqq3H777eYYlStXNlka7fakjXl0BkQ97u7du7376L91IiIdTjd79uxy/fXXy9KlSxN9HL169TLH93Xx4kUpUKCACbgAIK3sPXpWqhfOITlj/vktWi5fVsmfPVp2HEk8mAHSbWDy3nvvSaVKlUxAcc8998ibb755RavfJ554Ql588UXTVSljxowmCPBYsGCBDBgwQAYPHixbt26Vf/3rX9KzZ09ZsWKF3zFGjRol3bp1M32u9XxdunQx2w4bNswcV8/Zt29fv4CpVatWJij69ttvpUWLFtK6dWvZt29fgo/jvvvuM92iDh78Xyp10aJFcvbsWbnrrrsS3EcnSoo/eRIAhNoH3x+SQ6fOy8iWFWVC2yry4E0lTbXP7qP/ZFDgTlFiSZQVxOLQnEmaByaaTdCAROmX/8mTJ2XVqlV+2zz33HPSsGFDqVKlijz++OOybt06OXfunLlv/Pjx0qNHD3nooYekQoUKpl91hw4dzHpfGqzceeedZpvHHntMfvnlF+natas0b97cZFA0uNEMjUfNmjVN4FKtWjUzWIwGNpqV+eSTTxJ8HJpxiZ+tmTlzptxxxx0m45IQnSjJd+IknUgJAEKtQZk8UjJ3Fnlt/a8yfsVu+XjrYelUs7BUyJ8trYuGEFTlWEEsTpSmgYlWyXz99dfSuXNnc1uzIZpdiF/1UaPGP20AVOHChc3fI0eOmL8//fST1KtXz297va3rEzuGZ/bD6tWr+63TYMeTtdCMyZAhQ0zQkitXLhNc6DETy5h4siYajHjmB/j888/9sjvxabZGAzHPohMpAUAoZYqy5PaqBeTjHw7Jj4dOy4G487JmzzH59vc4aVI+b1oXD3BW41cNQP7++2+/xq5apaITCL3yyivedZkyZfJrL6IuX74c0LkSOsbVjqtByZIlS0zmpVy5cpIlSxbp1KmTXLhwIdFzaFWRZnS0/YpmdXRI3vr16ye6vT7OtJ7FEUBki4qyJGNUlMQfFuuybTu2uyjSd+vXNAtMNCCZPXu2aTvSrFkzv/t0XP13333XtAVJimY01q5da4bE9dDbWu0TDD2GVhG1b9/em0HR6p+ryZs3rym7Zk00ONHqI6S9c+cuyKHDx7y3tffNL78ekuzZski+fDnl9Om/5M+jJ80YJ+rAwaPmb66c2SVXroSr4QAn0XFKtDGrR96s0VI0Z4ycvXBJjv91UXb+cUbaVisoFy9dlmNnL0q5fNnk+hK5TBYF7mVF6DgmaRaYaMPQ48ePS+/evU37Cl8dO3Y02ZRx48YleZyhQ4eatiPXXnutNG3aVBYuXCgfffTRVXvQJIe2K9HjaINXzaboZETJydJodY72zrl06ZJfsIS0s3vvARk5+m3v7dlzl5i/DW+uIQ/d30Y2ffuzTHt9off+l6YuMH87tasvd3RomAYlBgJTIneM9Ktf2nu7fY1/Bgj86tfjMvebA/LWxt/MAGv31i5mBlg7fvaifLrtiKzdywBrcJ40C0w08NBAIn5Q4glMxo4dK99//32Sx9EMxUsvvWSqXLQBq1afaMZCuwEHY8KECaZ9iDZqzZcvn2kwm5xeM/qYtB1M1apVGY/FIapWLiXzZz+Z6P2N6tc0C+BWOj7JgAU/Jnr/qfN/mwAFEcYKcpA0ZyZMxLKvNiMPAqZVPkWLFjXBkfYOCoQGPhqovbvuZ8manREZEZk+3f5PVRkQiS6cPS2zetxoOjTExsaG5Rxx//2uWL5ln2TPkfJznD4VJ02uKRHWsrp25NdIoNU8f/75p2kzo7142rRpk9ZFAgDAdQhMQkS7EWs1UrFixczotdr1GQCAsLHolYMkZhqmVgwAkFoseuUAAACnsIJs/OrU2YXTfEh6AAAADzImAAC4kBWZTUwITAAAcCUrMiMTqnIAAIBjkDEBAMCFLHrlAAAAp7DolQMAABBeZEwAAHAhKzLbvhKYAADgSlZkRiZU5QAAAMcgYwIAgAtZ9MoBAABOYUVorxwCEwAAXMiKzCYmtDEBAADOQcYEAAA3siIzZUJgAgCAC1kR2viVqhwAAOAYZEwAAHAhi145AADAKazIbGJCVQ4AAHAOMiYAALiRFZkpEwITAABcyKJXDgAAQHiRMQEAwIUseuUAAACnsCKziQlVOQAAuDoysYJYAjBixAixLMtvqVSpUsgfFhkTAACQLFWrVpWlS5d6b2fMGPowgsAEAAAXstKgV44GIoUKFZJwoioHAAA3sv7XADYliycuiYuL81vOnz+f6Cl37twpRYoUkTJlykjXrl1l3759IX9YBCYAAKRjxYsXl5w5c3qX0aNHJ7hdnTp1ZNasWbJ48WKZNm2a7N27V+rXry+nTp0KaXmoygEAIB33ytm/f7/ExsZ612fOnDnB7Vu2bOn9d40aNUygUrJkSXnvvfekd+/eEioEJgAApOPIJDY21i8wSa5cuXJJhQoVZNeuXRJKVOUAAICAnT59Wnbv3i2FCxeWUCIwAQDAxb1yrCD+C8SQIUNk1apV8ssvv8i6deukffv2kiFDBuncuXNIHxdVOQAAuJCVykPS//bbbyYIOXr0qOTPn19uvvlm2bBhg/l3KBGYAACAJM2bN09SA4EJAAAuZEXoXDkEJgAAuJEVmZEJgQkAAC5kpcGQ9KmBXjkAAMAxyJgAAODWmhwruP2diMAEAAAXsiKziQlVOQAAwDnImAAA4EJWKg+wlloITAAAcCUrIitzqMoBAACOQcYEAAAXsqjKAQAATmFFZEUOVTkAAMBByJgAAOBCFlU5AADAKawInSuHwAQAADeyIrORCW1MAACAY5AxAQDAhazITJgQmAAA4EZWhDZ+pSoHAAA4BhkTAABcyKJXDgAAcAwrMhuZUJUDAAAcg4wJAAAuZEVmwoTABAAAN7LolQMAABBeZEwAAHAlK8ieNc5MmRCYAADgQhZVOQAAAOFFYAIAAByDqhwAAFzIitCqHAITAABcyIrQIempygEAAI5BxgQAABeyqMoBAABOYUXokPRU5QAAAMcgYwIAgBtZkZkyITABAMCFLHrlAAAAhBcZEwAAXMiiVw4AAHAKKzKbmFCVAwCAqyMTK4glBaZMmSKlSpWSmJgYqVOnjnz99dchfVgEJgAAIFnmz58vgwYNkqefflq++eYbqVmzpjRv3lyOHDkioUJgAgCAi3vlWEH8F6gJEyZInz59pGfPnlKlShWZPn26ZM2aVd58882QPS4CEwAAXNz41QpiCcSFCxdk8+bN0rRpU++6qKgoc3v9+vUhe1w0fnUQ27bN37NnTqd1UYCwuXCW6xuR68JfZ/w+z8MpLi4uJPvHP07mzJnNEt+ff/4ply5dkoIFC/qt19vbt2+XUCEwcZBTp06Zv71vvS6tiwIACPLzPGfOnGE5dnR0tBQqVEjKly4e9LGyZ88uxYv7H0fbj4wYMULSCoGJgxQpUkT2798vOXLkEMupHcwjjP5S0DelPu+xsbFpXRwgpLi+U59mSjQo0c/zcImJiZG9e/eaqpVQlDf+901C2RKVL18+yZAhgxw+fNhvvd7WQClUCEwcROvqihUrltbFSJf0Q5sPbkQqru/UFa5MSfzgRJfUpJmaWrVqybJly6Rdu3Zm3eXLl83tvn37huw8BCYAACBZtKtw9+7dpXbt2nLDDTfIpEmT5MyZM6aXTqgQmAAAgGS566675I8//pDhw4fLoUOH5JprrpHFixdf0SA2GAQmSNe0LlUbeiVWpwq4Gdc3wkGrbUJZdROfZadGnyYAAIBkYIA1AADgGAQmAADAMQhMAACAYxCYAGGwcuVKM2jRiRMn0rooQMjoVPfaPRQIJwITOF6PHj3Ml/wLL7zgt/7jjz9mhFy4kk54piNo3nbbbWldFMBxCEzgCjrC4ZgxY+T48eMhO2YohnMGUmLGjBnSr18/Wb16tRw4cCCtiwM4CoEJXEGn1da5GEaPHp3oNh9++KFUrVrVjNmgKecXX3zR735dN2rUKOnWrZsZnvv++++XWbNmSa5cuWTRokVSsWJFyZo1q3Tq1EnOnj0rb731ltknd+7c0r9/fzOrpsecOXPMyIc6r5GWq0uXLnLkyJGwPgeIDKdPn5b58+fLgw8+aDImeg3GrwLUIb71+tLr8aabbpIdO3b4HWPatGlStmxZM0S4Xrd6PfrSY7z66qty++23m2NUrlzZZGl27doljRo1kmzZspnj7t6927uP/rtt27ZmoCyd2O3666+XpUuXJvo4evXqZY7v6+LFi1KgQAETeAEppuOYAE7WvXt3u23btvZHH31kx8TE2Pv37zfrFyxYoGPwmH9v2rTJjoqKskeOHGnv2LHDnjlzpp0lSxbz16NkyZJ2bGysPX78eHvXrl1m0fszZcpk33rrrfY333xjr1q1ys6bN6/drFkz+84777R//PFHe+HChXZ0dLQ9b94877FmzJhhf/bZZ/bu3bvt9evX23Xr1rVbtmzpvX/FihWmbMePH0/V5wrOp9dO7dq1zb/12ipbtqx9+fJlv+umTp069sqVK831V79+ffumm27y7q/vA71mp0yZYq71F1980c6QIYO9fPly7zZ6jKJFi9rz588327Rr184uVaqU3aRJE3vx4sX2tm3b7BtvvNFu0aKFd58tW7bY06dPt3/44Qf7559/tp988knzfvv111/93kMTJ040/167dq0574EDB/zKli1bNvvUqVNhfhYRyQhM4JrAROmHaa9eva4ITLp06WKCC19Dhw61q1Sp4vehqh/QvjQw0WNokOLxr3/9y86aNavfh2vz5s3N+sRs3LjRHMezD4EJEqNBxqRJk8y/L168aOfLl89cL77XzdKlS73bf/rpp2bdX3/95d2/T58+fse844477FatWnlv6/YaWHho8KzrNCjyePfdd03gcTVVq1a1J0+enGBgovT9NWbMGO/t1q1b2z169AjwGQH8UZUDV9F2JlrF8tNPP/mt19v16tXzW6e3d+7c6VcFo+nx+DTVrWlxD01laxWOprN91/lW1WzevFlat24tJUqUMNU5DRs2NOv37dsXokeKSKRVMl9//bV07tzZ3M6YMaOZeyR+1UeNGjW8/y5cuLD567n+ErvW478nfI/hmcekevXqfuvOnTsncXFx3iqmIUOGmGofrd7U61+PebVr+r777pOZM2eafx8+fFg+//xzU8UDBIPABK7SoEEDad68uQwbNixF+2vdenyZMmW6on4+oXU6vbfSmTS1DNpO5Z133pGNGzfKggULzH00qMXVaADy999/S5EiRUxQoou2F9H2USdPnvRu53v9eXqeea6/5EroGFc7rgYleh0///zzsmbNGtmyZYsJZK52TWt7rT179pj2K2+//baULl1a6tevH1A5gfiYxA+uo92GdUZLbfTnob/y1q5d67ed3q5QoYLplhlK27dvl6NHj5pyFC9e3KzbtGlTSM+ByKMByezZs02j7GbNmvnd165dO3n33XelUqVKSR7Hc63r1PMeertKlSpBlU+PoV3z27dv782g/PLLL1fdJ2/evKbsmjXR4KRnz55BlQFQBCZwHf0V17VrV3n55Ze96wYPHmx6EWivG02N64fkK6+8IlOnTg35+bX6RntDTJ48WR544AHZunWrOS9wNdrzS7u79+7dW3LmzOl3X8eOHU02Zdy4cUkeZ+jQoXLnnXfKtddea3qrLVy4UD766KOr9qBJjvLly5vjaBWlZlOeeuqpZGVptDpHe+dolalvsASkFFU5cKWRI0f6fWhed9118t5778m8efOkWrVqMnz4cLON/gIMtfz585sunu+//775laqZk/Hjx4f8PIgsGnhoIBE/KPEEJpp1+/7775M8jmYoXnrpJXPNafd47RasGQvtBhyMCRMmmK7x2o1YgxOtrtT3VVL0MWk7GN1eq6iAYFnaAjboowAA0iWt8ilatKgJjjp06JDWxUEEoCoHABAwzVj++eefps2M9uJp06ZNWhcJEYLABAAQMO1GrL1wihUrZqo2tYcREApU5QAAAMeg8SsAAHAMAhMAAOAYBCYAAMAxCEwAAIBjEJgA8KOD0ukgXh46cNcjjzyS6uVYuXKlGYH0xIkTiW6j93/88cfJPuaIESPMdAbB0GHa9bw6lwyA0CMwAVwSLOiXoS46HH65cuXMyLY6/0q46TDlyR1yPznBBABcDR3PAZdo0aKFGV3z/Pnz8tlnn8nDDz9sZotNaKZlnRFWA5hQyJMnT0iOAwDJQcYEcInMmTNLoUKFpGTJkvLggw+aOUo++eQTv+qX5557zsxX4pl5ef/+/WbCNx2ZUwOMtm3b+s0YqxOvDRo0yNyvM8U++uijEn9oo/hVORoYPfbYY2ZmZS2TZm90Hhg9buPGjc02OueKZk48cxXpKKGjR482A3JlyZJFatasKR988IHfeTTY0tmg9X49TlIz2yZEy6XHyJo1q5QpU8ZMRHfx4sUrttP5ZbT8up0+PydPnvS7/4033jCz+MbExJgZf8MxGSSAhBGYAC6lX+CaGfFYtmyZ7NixQ5YsWWJmstUvZJ1YLUeOHLJmzRozrX327NlN5sWznw4nrqN2vvnmm/Lll1/KsWPHZMGCBVc9b7du3eTdd981szv/9NNP5ktej6tf9B9++KHZRstx8OBBM9mc0qBk9uzZMn36dPnxxx9l4MCBcs8998iqVau8AZTOs6KTx2nbDZ2x9vHHHw/4OdHHqo9n27Zt5tyvv/66TJw40W+bXbt2mQkfdVbexYsXy7fffisPPfSQ9/533nnHTAKpQZ4+vueff94EOG+99VbA5QGQAjryKwBn6969u922bVvz78uXL9tLliyxM2fObA8ZMsR7f8GCBe3z589795kzZ45dsWJFs72H3p8lSxb7iy++MLcLFy5sjx071nv/xYsX7WLFinnPpRo2bGgPGDDA/HvHjh2aTjHnT8iKFSvM/cePH/euO3funJ01a1Z73bp1ftv27t3b7ty5s/n3sGHD7CpVqvjd/9hjj11xrPj0/gULFiR6/7hx4+xatWp5bz/99NN2hgwZ7N9++8277vPPP7ejoqLsgwcPmttly5a1586d63ecUaNG2XXr1jX/3rt3rznvt99+m+h5AaQcbUwAl9AsiGYmNBOiVSNdunQxvUw8qlev7teu5LvvvjPZAc0i+Dp37pzs3r3bVF9oVqNOnTre+3S+k9q1a19RneOh2YwMGTJIw4YNk11uLcPZs2fl1ltv9VuvWZtrr73W/FszE77lUHXr1pVAzZ8/32Ry9PHprLfaODg2NtZvmxIlSpjZcH3Po8+nZnn0udJ9e/fuLX369PFuo8fJmTNnwOUBEDgCE8AltN3FtGnTTPCh7UjiT5qWLVs2v9v6xVyrVi1TNRFf/vz5U1x9FCgth/r000/9AgKlbVRCZf369dK1a1d55plnTBWWBhLz5s0z1VWBllWrgOIHShqQAQg/AhPAJTTw0IamyXXdddeZDEKBAgWuyBp4FC5cWL766itp0KCBNzOwefNms29CNCuj2QVtG6KNb+PzZGy0Ua1HlSpVTACis9EmlmnRhqaehrweGzZskECsW7fONAx+4oknvOt+/fXXK7bTchw4cMAEd57zREVFmQbDBQsWNOv37NljghwAqY/Gr0CE0i/WfPnymZ442vh17969ZpyR/v37y2+//Wa2GTBggLzwwgtmkLLt27ebRqBXG4OkVKlS0r17d+nVq5fZx3NMbUyqNDDQ3jha7fTHH3+YDIRWjwwZMsQ0eNUGpFpV8s0338jkyZO9DUofeOAB2blzpwwdOtRUqcydO9c0Yg1E+fLlTdChWRI9h1bpJNSQV3va6GPQqi59XvT50J452uNJacZFG+vq/j///LP88MMPppv2hAkTAioPgJQhMAEilHaFXb16tWlToT1eNCuhbSe0jYkngzJ48GC59957zRe1trXQIKJ9+/ZXPa5WJ3Xq1MkEMdqVVttinDlzxtynVTX6xa49ajT70LdvX7NeB2jTni36ha/l0J5BWrWj3YeVllF79Giwo12JtfeO9oYJRJs2bUzwo+fU0V01g6LnjE+zTvp8tGrVSpo1ayY1atTw6w6sPYK0u7AGI5oh0iyPBkmesgIIL0tbwIb5HAAAAMlCxgQAADgGgQkAAHAMAhMAAOAYBCYAAMAxCEwAAIBjEJgAAADHIDABAACOQWACAAAcg8AEAAA4BoEJAABwDAITAADgGAQmAABAnOL/AZezhow5BE7zAAAAAElFTkSuQmCC" + "image/png": "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" }, "metadata": {}, "output_type": "display_data", @@ -675,7 +705,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data", @@ -688,7 +718,7 @@ "text/plain": [ "
" ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiYAAAHHCAYAAACLPpP8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABE4ElEQVR4nO3dCZxNdf/A8e+ZwYxt7Pu+y5rokWQrEWVNshQipUJlqVSiVAqhKG0iHpKUikoPZQstKskTspWRrYSxNEzm/F/fX8+9/7ljtjv33plz7nzeXsfce+5Zfvfcc+/93u9vOZZt27YAAAA4QER2FwAAAMCDwAQAADgGgQkAAHAMAhMAAOAYBCYAAMAxCEwAAIBjEJgAAADHIDABAACOQWACAAAcg8AEIbVr1y5p166dFCpUSCzLkvfffz+o2//ll1/MdufOnRvU7YaDypUry4ABA7K7GGFNzzs9//Q89Nf48ePNupnVunVrM2XG33//LQ888IBUqFBBIiIipGvXruK044Oci8AkB9izZ4/ceeedUrVqVYmOjpaYmBhp3ry5PP/88/LXX3+FdN/9+/eXH3/8UZ566imZP3++NGnSJKT7C0c//fST+RJz84f72bNn5cUXXzRBapkyZaRgwYLSqFEjmTVrlly4cCG7i5fjvPHGGzJ58mTp0aOHvPnmm3L//fdn2b5feuklfkggTbnSfhhu99FHH8lNN90kUVFR0q9fP6lXr56cP39evvjiCxk9erT897//lVdffTUk+9agZ9OmTfLII4/I0KFDQ7KPSpUqmf3kzp1bwjkwefzxx82vY82CZNTOnTvNr2En2Lt3rwwbNkyuueYaGTFihAmOP/30U7n77rvlyy+/NF+OyDqff/65lCtXTqZNm5bl+9bApHjx4mTzkCoCkzC2b98+6dWrl/ny1g8i/aXqcc8998ju3btN4BIqv//+u/lbuHDhkO1D08SaBcI/9Jqc8fHxkjdvXhOMOkXp0qVN5qxu3breeZrFGzhwoMyZM0fGjh0r1atXz9Yy5iRHjx4N6fsSCIQzfk4hJCZNmiSnT5+W2bNn+wQlHvpFcO+99/rUO0+YMEGqVatmvtT01/nDDz8s586d81lP599www0m6/Kvf/3LBAZaTTRv3jzvMlr1oAGR0syMBhCeX/v6SymlX/4p1bmvXLlSrrrqKvMhWqBAAalVq5YpU3ptTDQQa9GiheTPn9+s26VLF9m+fXuK+9MATcuky2lbmNtuu81UPaRHMxiagdq6dau0atVK8uXLZ47pkiVLzONr166Vpk2bmiBBy71q1Sqf9X/99VeTMdDHdJlixYqZ7FbSKht9XjpPtWnTxpRXpzVr1vi8Fpp90Goy3c4rr7zifczzq1QDFl2/RIkS5kvJQ7Nn9evXN6/5mTNnUn2uuj/d7+LFi032Rn9ta3WMVgWcPHnSnCP33XeflCxZ0rxOegyTnjf6CzlpUOLRrVs38zf5a5NRgb4G6vvvv5cOHTqYLI6WXbM6msVJTrOLV199tdlW+fLl5cknn5TExMQUy/XJJ594zz89Ttdff71ZP7M0q6mvke5b33Pr169PcTk95uPGjTPHQN/D2oZE25J4XgvP+2X16tWmPMnPpylTpsiVV15pzkXdV+PGjb3HMiPtunS+vq9So+ek7ldfF8++/Wkno0GsvgZ6nunzq1OnjqkOzIrXAFnIRtgqV66cXbVq1Qwv379/f1tPiR49etgvvvii3a9fP3O/a9euPstVqlTJrlWrll2qVCn74YcftmfOnGlfdtlltmVZ9rZt28wyP/zwgz1t2jSzfu/eve358+fbS5cu9e5Ht5HcuHHjzPIeuq08efLYTZo0sZ9//nn75ZdftkeNGmW3bNnSu8y+ffvMOnPmzPHOW7lypZ0rVy67Zs2a9qRJk+zHH3/cLl68uF2kSBGzfPL9NWrUyO7evbv90ksv2bfffruZ98ADD6R7vFq1amWXLVvWrlChgj169Gh7xowZdp06dezIyEh70aJFdunSpe3x48fb06dPN69FoUKF7Li4OO/677zzjt2wYUP7scces1999VVzLLWMemzOnDljltmzZ489fPhwUyZ9XI+jTocPH/a+FtWrVzfrPfTQQ+YYrV692vuYHmuPvXv32gUKFLC7devmnafr6Ou2du3aNJ+rblPLcOmll9rNmjWzX3jhBVMuXbdXr152nz597A4dOpjz5tZbbzXL6nFPjz5vXXbjxo12ZgT6Gug5lj9/frtMmTL2hAkT7GeeecauUqWKHRUVZX/55Zfe5Q4dOmSXKFHCHGfd3uTJk+0aNWrYDRo0MOVPel7NmzfPHJfrrrvOlOfZZ5+1K1eubBcuXDjF8y89r7/+ulnuyiuvNMf9vvvuM9vS97Y+f48LFy7Y7dq1s/Ply2eWeeWVV+yhQ4ea90KXLl3MMqdPnzbnT+3ate3y5ctfdD7pvLvvvtu8p6dOnWr/61//Mvtevnx5mu85D52vz8tDl0l6fPQzQPeh+/fs+z//+U8GX23bvvzyy+0BAwaYzxY9tvp8dfta3qQy+hrAmQhMwtTJkyfNG9bzgZSeLVu2mOX1izkpDQR0/ueff+6dp194Om/dunXeeUePHjUf5iNHjrzoA0w/xJPKaGDiCWx+//33VMud0oekfnmWLFnSPnbsmHeeBkoREREm2Eq+v4EDB/psU7+4ixUrZqdHvxR0/YULF3rn7dixw8zTfSX9Yvv0008vKufZs2cv2uamTZvMcvrBmjSA0XmegCMpz2uxYsWKFB9LGpgo/bLS5f/973+b8ukXuH6JpccTmNSrV88+f/68d74GnfoFoEFJUhq8pPQaJ3Xu3DkTRGggkJCQYGdGoK+BBt0a/GoA6HHw4EG7YMGCPgGwHiNd96uvvvI55zXQSfrFe+rUKfPlN3jwYJ9y6he/Lpt0fkYCEz3Wei7rOa3HK3lAlzQw0S95fc7r16/32YYGq7rshg0bfI5b3bp1L9pf8nNS96+v+dVXXx2UwETpfpOW2x8pvWfat2/v8wPMn9cAzkRVTpiKi4szfzWFmREff/yx+asNE5MaOXKk+Zu8LYqmUDVN6qFVBJoq10aOweKpA//ggw9STZknd+jQIdmyZYupwihatKh3foMGDeTaa6/1Ps+khgwZ4nNfn9exY8e8xzAtmvrXdjweegy03JdccompQvDw3E56fDRV7pGQkGD2qSl4Xf+7776TjKpSpYq0b98+Q8vecccdZlltiHrrrbea6oGnn346w/vSBtRJGxrr89LvI20rkpTOj42NNdWDqdEG0dqwd+bMmZIrV+abu2X2NdDeQP/5z39MV1mtivTQas8+ffqYqkrPOaDnzRVXXGGqUZKe83379r2o6vHEiRPSu3dv+eOPP7xTZGSk2b9Wofhj8+bNpupNz9E8efJ45+v5rdWOSb3zzjvmOdeuXdtn31r1oTKy76Tn5PHjx001nb4f/DkfQylp+bRs+vy0Ck9fU70fitcAWY/Gr2FK68vVqVOnMrS8tnfQHhzJGyBqo0X9kNfHk6pYseJF2yhSpIj5MAuWm2++WV5//XW5/fbb5aGHHjJ1/927dzftGlLrbeIpp345Jacf2toWQ9tSaL1zas9Fn4fS5+I5jqnRtgbJ28XoF4bW7Sef59mmh/Ymmjhxoqk3/+2338wXvIfnQzajgYk/tM2RBiQ6xszGjRt9PuzTk/xYeZ5XSs9Xg0l9HtpeITntqvraa6+ZNk0dO3aUQGT2NdDG2dqWKLVzRcuvwZW2jdHzKmmQ45F8XT2myhMMJJfe+ZTa+VyjRg2f+RocJg2mPPvWtjoaMKUkadui1Cxfvty0ndHgPmkboUDGWwmmDRs2mDY02tsveTswPdf0NQ72a4CsR2ASpvTNV7ZsWdm2bZtf62X0A0h/faQk6Zerv/tIPp6FfmGuW7fO/MLRjM2KFSvk7bffNh84+ks3tTL4K5Dnktq6GdmmZi00KNFGo82aNfMOQqe//jOaIVL+BBZKGzp6vnS0p4zuO6MCeb4e2mjywQcfNFmARx99NMP7DmWZgsXzuumYPRrUJxdIZigj+9aGzFOnTk3x8eSBWnLaoLZz587SsmVL06VXM0caAOk5unDhQr/fv6EYj0l/nGhGSJ+jPh/NImk2S7s9e459dr4GCA5eoTCmvTW0Nb/+ukjvy0d70OgbWn9t6K9FjyNHjpi0qKeHTTBoRkK3mVzyrIzSzIh+GOmkH0Za7aDjomiw0rZt2xSfh2cMj+R27NhheockzZZkJ+3toAPQPffcc9552tU3+bEJ5q9VrerSgEgHOtMP9VGjRpmqnWC+vmnRajnNgGnmSwdcy06aWdBePKmdK3rueb7M9fh4foknlXxdzUQp7TWS0vnpL8/rovtOmgHQqj8dDqBhw4Y++/7hhx/MeyUz58y7775rethpVjFpV3MNTFLKKCY/T1N6/6Yks+fzsmXLTED94Ycf+mTuklfNBPs1QNajjUkY026C+iWsXwQaYKT0C0RHf1WedPr06dN9lvH8+tKudsGiHxyadtUunkm/MJcuXeqz3J9//nnRupdeeqn5m7wLs4f+ytNldMCupB+cmjnSLEug1QbBpL/ok/96nzFjxkW/PD2BVErBnL8GDx5sAlCtztGgVX89Dho0KKRZBA/Nfmk2SH+RL1iwINsHf9PjrwGaBktJu2jre0UzBNpN3ZP21/NGuxB//fXX3uW0KkifR1Ia5Ok6GkBr8JDa2D4ZpV3ANYB6+eWXTdfupFmn5OdDz549TZWgVpElp9WGaXUH9xwPDRqSnn96XJJfRkKfnwb4+nompVmWjNDzOTPnsicDlrzKM3ng5M9roOtrEOpP1SlCj4xJGNMAQD9gta2GZkGSjvyqbQu0sZxnnAv95aW/3vXLSj80tEGZfgjrF7w2DtQxMIJFv5w0la9jWAwfPtzUFetYBDVr1vRpZPfEE0+YDz8NivSXo9aR64eftinQL43UaPsFHZdCs0T6pasfyvqFr1UlaY2xkB0ZLU03a7m0MbFmtnScjeRtMjTQ0g/lZ5991nyA6q9Zz1gO/tAPcK0S0y81PYZKj8stt9xijr+OqRIq+mtaqwn0i0/bCOm5l5Q2TtbJwzPOTaiH4df2FJ6xcvT5a6Cm48Bo4KvjACUN8vW1uu6668zYP/rlqu8VPS+TBtj6hajHUhsWX3bZZeZc18Bi//795tjrpSC0sW9GaVWKllEHo9PXXN/LminR1zJ5GxPdp44zo1VkmkXQfWmQoV+8Ot8z1k1q9H2mP0T0OWrjX32/aVZL250lfY5Kf+w888wz5q9uU9+nP//8c4aek46NosdIn5duW8/j1NqDJOXJ8nXq1MkcDx2jSYMwXV9/2GTmNdAfQzrmjh5PRqJ1kOzuFoTQ+/nnn00XOe3Hr10jtStk8+bNTf/++Ph473LaZVPHntDum7lz5zZjQ4wZM8ZnGaXdQK+//vqL9qNdAJN2A0ytu7DSsQu0G6KWR8dE0e6rybtPfvbZZ6a7s45TocvpX+2eqs8nva6Lq1atMs8xb968dkxMjN2pUyf7p59+8lnGs7/k3ZFT6uKYktS6XKZ2fHSb99xzj/f+8ePH7dtuu82MsaLji2i3R+3qmlI339dee810idTuvUm7Dqe2L89jnu3ExsaarpJ6HJLT7tE6loeOc5Jed2HtupzSsfrmm2/SPLae9VObknYxVXpMrrjiCjs9gb4G6rvvvjPHXl8DHQOkTZs2KY6rsnXrVrO/6OhoMyaKjnsye/bsFM8Vfb66TT3muny1atXM+BubN2++6BhlhI6x4xlfRcf10a76yd9vnu69OmaHHhNdVsddady4sXlf6xAC6R03fT46Pouuq2ON6OubUjm12+6gQYPM89PPk549e5ru0xnpLqzddvW10fWSd3lOz4cffmjGjtFjqp9n+lzfeOONTL8GnvKl1PUZ2cfS/7I7OAIAD+1CrD1htIdIMKsQAbgDbUwAOIpWQ2g1HEEJkDORMQEAZKvDhw+n2yU++YByCF8EJgCAbJVeF2JtmJ/SRQMRnuiVAwDIVtozKi06WCRyDjImAADAMWj8CgAAHIOqHAfRETkPHjxorgjslItmAQAyTish9OKpWv0UytGN4+PjfUYDziwdtE4vReAkBCYOokFJehfaAgA4n16Z2jPCciiCkrwFi4n87XuF5czQCx3qaMJOCk4ITBxEMyUqT53+YkXmye7iACGxf82U7C4CEDKn4uKkepUK3s/zUDivmZK/z0pUnf4igXxXXDgvh39602yPwAQp8lTfaFBCYIJw5bkwHhDOsqQ6Pld0QN8VtuXMZqYEJgAAuJFlIqDA1ncgAhMAANzIivhnCmR9B3JmqQAAQI5ExgQAADeyrACrcpxZl0NgAgCAG1lU5QAAAIQUGRMAANzIoioHAAA4RkSA1THOrDRxZqkAAECORMYEAAA3sqjKAQAATmHRKwcAACCkyJgAAOBGFlU5AADAKazwrMohMAEAwI2s8MyYODNcAgAAORIZEwAA3MiiKgcAADiqKicisPUdyJnhEgAAyJHImAAA4EYR1j9TIOs7EIEJAABuZIVnGxNnlgoAAORIZEwAAHAjKzzHMSEwAQDAjSyqcgAAAEKKjAkAAG5kUZUDAACcwgrPqhwCEwAA3MgKz4yJM8MlAACQI5ExAQDAjSyqcgAAgFNYVOUAAACEFBkTAABcKSLA6hhn5iYITAAAcCOLqhwAAICQIjABAMC1GZOIACb/MiYTJ06Uyy+/XAoWLCglS5aUrl27ys6dO32Wad26tViW5TMNGTLEr/0QmAAA4EZWIEGJ/+1T1q5dK/fcc498+eWXsnLlSklISJB27drJmTNnfJYbPHiwHDp0yDtNmjTJr/3QxgQAAKRrxYoVPvfnzp1rMifffvuttGzZ0js/X758Urp0acksMiYAALi58asVwBSAkydPmr9Fixb1mb9gwQIpXry41KtXT8aMGSNnz571a7tkTAAAyMEjv8bFxfnMjoqKMlNaEhMT5b777pPmzZubAMSjT58+UqlSJSlbtqxs3bpVHnzwQdMO5b333stwsQhMAADIwd2FK1So4DN73LhxMn78+DRX1bYm27Ztky+++MJn/h133OG9Xb9+fSlTpoxcc801smfPHqlWrVqGikVgAgBADhYbGysxMTHe++llS4YOHSrLly+XdevWSfny5dNctmnTpubv7t27CUwAAAhrVnCqcjQoSRqYpMa2bRk2bJgsXbpU1qxZI1WqVEl3nS1btpi/mjnJKAITAADcyMrakV+1+mbhwoXywQcfmLFMDh8+bOYXKlRI8ubNa6pr9PGOHTtKsWLFTBuT+++/3/TYadCgQYb3Q2ACAADSNWvWLO8gaknNmTNHBgwYIHny5JFVq1bJ9OnTzdgm2nblxhtvlEcffVT8QWACAIALWf8bWTWADfi1uFblpEUDER2ELVAEJgAAuJCVxYFJVmGANQAA4BhkTAAAcCPrf1Mg6zsQgQkAAC5kUZUDAAAQWmRMAABwIStMMyYEJgAAuJBFYAIAAJzCCtPAhDYmAADAMciYAADgRhbdhQEAgENYVOUAAACEFhkTAABcyLL+yZpkfgPiSAQmAAC4kKX/AqqOcWZkQlUOAABwDDImAAC4kBWmjV8JTAAAcCMrPLsLU5UDAAAcg4wJAABuZAVWlWNTlQMAAJzSxsQiMAEAAMFihWlgQhsTAADgGGRMAABwIys8e+UQmAAA4EIWVTkAAAChRcYEAAAXssI0Y0JgAgCAC1lhGphQlQMAAByDjAkAAC5khWnGhMAEAAA3ssKzuzBVOQAAwDHImAAA4EIWVTkAAMApLAITAADgFFaYBia0MQEAAI5BxgQAADeywrNXDoEJAAAuZFGVAwAAEFpkTEJozZo10qZNGzl+/LgULlw4u4uTY90/oJ3c0Kah1KhUSuLPJcjXW/fK+JkfyO5fj3qXKVmsoDwxvJu0blpbCuSLMo8998ansmz1lmwtO5AZU+d8KstX/yC7fj0i0VG55V8Nqsr4oV2kRuVS2V00BJFFxiR7DRgwwBzEZ555xmf++++/79iDC2e48rLq8vo766TdwCnSfehMyZ0rUt6bMVTyRefxLjNrfD+pXqmk9BnxijTv/bQJSOZMHCj1a5bP1rIDmbHxu91y+00t5T9vjJL3Zg6VhL8vSPdhM+XMX+eyu2gIIkv/WQFMDm1k4prAREVHR8uzzz5rMhDBcv78+aBtC8500/CX5K3lX8mOvYdl267f5O7H/y0VyhSVSy+p4F1Gf1G+9vZa+e6nX+XX346ZbMnJU3/5LAO4xZIZ90ifTlfIJdXKmOD6pXG3yIHDx2XL9tjsLhoQXoFJ27ZtpXTp0jJx4sRUl3n33Xelbt26EhUVJZUrV5bnnnvO53GdN2HCBOnXr5/ExMTIHXfcIXPnzjVVLcuXL5datWpJvnz5pEePHnL27Fl58803zTpFihSR4cOHy4ULF7zbmj9/vjRp0kQKFixoytWnTx85evT/qwfgTDEFos3f43FnvfO0eqfbtY2lcEw+80ui+7WNJSoql3zx7a5sLCkQHHGn483fIjH5srsoCCIrkGxJgNVAoeSqwCQyMlKefvppmTFjhhw4cOCix7/99lvp2bOn9OrVS3788UcZP368jB071gQeSU2ZMkUaNmwo33//vXlcaRDywgsvyKJFi2TFihWmfUi3bt3k448/NpMGIa+88oosWbLEu52EhAQT5Pzwww+mSumXX34xVU5wLn0jThzRQ77cske27znknX/bmDckV65I2ffZJDmycbpMe7iX3Dr6Ndl34I9sLS8QqMTERBkzdYk0bVhV6lQvm93FQSi6C1sBTA7kusavGixceumlMm7cOJk9e7bPY1OnTpVrrrnGG2zUrFlTfvrpJ5k8ebJPwHD11VfLyJEjvffXr19vgoxZs2ZJtWrVzDzNmGgwcuTIESlQoIDUqVPHNGRdvXq13HzzzWaZgQMHerdRtWpVE9hcfvnlcvr0abNOes6dO2cmj7i4uICODdI35YGeJr3dYfA0n/mPDLlBChXMK13ufkH+PHFGOrZqYNqYdBw8XX7aczDbygsEatSkxSYI/+S1+7O7KED4ZUw8tJ2JVrFs377dZ77eb968uc88vb9r1y6fKhitfklOq288QYkqVaqUqcJJGmDovKRVNZqh6dSpk1SsWNFU57Rq1crM379/f4aeh1ZJFSpUyDtVqEB7hlCaNPomad+innS66wU5ePSEd37lcsXljptbybAJ/5Z13/xs2qFMev0T+X77ftOAEHCr0ZMWy6frt8myWcOlXKki2V0cBJlFVY5ztGzZUtq3by9jxozJ1Pr58+e/aF7u3Ll97usLltI8TYuqM2fOmDJoO5UFCxbIN998I0uXLvWrQa2W/+TJk94pNpaGaaEMSq5v3VA63/WC7D94zOcxT++cxETbZ/6FC7ZYEc584wJpsW3bBCUfrflBPpw1XCqVK57dRUIIWGEamLiuKsdDuw1rlY42VvW45JJLZMOGDT7L6X2t0tH2KcG0Y8cOOXbsmCmHJ9OxefNmv7ahDXR1QmhNebCn9GjfRPqMelVOn403Y5Z4GgTquCY//3JY9uw/KtPG9Jaxzy+VP0+eketbN5A2TWtJr/tfzu7iA34b9exiWfLpZlk45Q4pkC9ajvwR5234nTdJN3m4m2X9MwWyvhO5NjCpX7++9O3b17Tr8NB2I9rGQxukajuQTZs2ycyZM+Wll14K+v61+iZPnjymIe6QIUNk27ZtZr9wnkE9/qmO+eiV+3zm3/34fNON+O8LidLzvlkybmgXeWvqnZI/X5Tsi/1d7h4/X1Zu/CmbSg1k3hvvrjd/bxjyvM/8Fx+7xXQjBpzMtYGJeuKJJ+Ttt9/23r/ssstk8eLF8thjj5kgoUyZMmaZUPSUKVGihOnt8/DDD5vgSPetvX06d+4c9H0hMEUuH5ruMntjf5f+D76eJeUBQu34NzOzuwjIsoyJFdD6TmTZWhkJR9BeOdoINqr+YLEiSbciPPGliXD/HC9VrJBpN6htEEP5XVF1+BKJjLq4zWRGXTh3Rva+0COkZc0xjV8BAEB4cnVVDgAAOZUVphfxIzABAMCFwrVXDlU5AADAMciYAADgQhERlpkyy3boAJIEJgAAuJBFVQ4AAEBokTEBAMCFLHrlAAAAp7DCtCqHwAQAABeywjRjQhsTAADgGAQmAAC4OGNiBTD5Y+LEiXL55ZdLwYIFpWTJktK1a1fZuXOnzzLx8fFyzz33SLFixaRAgQJy4403ypEjR/zaD4EJAAAubmNiBTD5Y+3atSbo+PLLL2XlypWSkJAg7dq1kzNnzniXuf/++2XZsmXyzjvvmOUPHjwo3bt392s/tDEBAADpWrFihc/9uXPnmszJt99+Ky1btjRXKZ49e7YsXLhQrr76arPMnDlz5JJLLjHBzBVXXJH+TsiYAADgTpYEWJUj/6RM4uLifKZz585laP8aiKiiRYuavxqgaBalbdu23mVq164tFStWlE2bNmX4eRGYAACQg6tyKlSoIIUKFfJO2pYkPYmJiXLfffdJ8+bNpV69embe4cOHJU+ePFK4cGGfZUuVKmUeyyiqcgAAyMFiY2MlJibGez8qKirddbStybZt2+SLL74IenkITAAAyMHjmMTExPgEJukZOnSoLF++XNatWyfly5f3zi9durScP39eTpw44ZM10V45+lhGUZUDAIALWVncK8e2bROULF26VD7//HOpUqWKz+ONGzeW3Llzy2effeadp92J9+/fL82aNcvwfsiYAACADFXfaI+bDz74wIxl4mk3ou1S8ubNa/4OGjRIRowYYRrEahZm2LBhJijJaI8cRWACAIALWVk8JP2sWbPM39atW/vM1y7BAwYMMLenTZsmERERZmA17d3Tvn17eemll/zaD4EJAAAuZGXxRfy0Kic90dHR8uKLL5opswhMAABwIYuL+AEAAIQWGRMAANzICqwq538DvzoOgQkAAC5kUZUDAAAQWmRMAABwISuLe+VkFQITAABcyKIqBwAAILTImAAA4EIWVTkAAMApLKpyAAAAQouMCQAALmSFacaEwAQAABeyaGMCAACcwgrTjAltTAAAgGOQMQEAwIUsqnIAAIBTWFTlAAAAhBYZEwAAXMgKsDrGmfkSAhMAAFwpwrLMFMj6TkRVDgAAcAwyJgAAuJBFrxwAAOAUVpj2yiEwAQDAhSKsf6ZA1nci2pgAAADHIGMCAIAbWQFWxzg0Y0JgAgCAC1lh2viVqhwAAOAYZEwAAHAh63//AlnfiQhMAABwoQh65QAAAIQWGRMAAFzIyskDrH344YcZ3mDnzp0DKQ8AAMjBvXIyFJh07do1w9HXhQsXAi0TAADIoTIUmCQmJoa+JAAAIMMiLMtMmRXIuo5tYxIfHy/R0dHBKw0AAMjRVTl+98rRqpoJEyZIuXLlpECBArJ3714zf+zYsTJ79uxQlBEAAKTS+DWQKSwCk6eeekrmzp0rkyZNkjx58njn16tXT15//fVglw8AAOQgfgcm8+bNk1dffVX69u0rkZGR3vkNGzaUHTt2BLt8AAAgjaqcQKawaGPy22+/SfXq1VNsIJuQkBCscgEAgBzY+NXvjEmdOnVk/fr1F81fsmSJNGrUKFjlAgAAOZDfGZPHHntM+vfvbzInmiV57733ZOfOnaaKZ/ny5aEpJQAA8KH5jkByHs7Ml2QiY9KlSxdZtmyZrFq1SvLnz28Cle3bt5t51157bWhKCQAAckSvnEyNY9KiRQtZuXJl8EsDAABytEwPsLZ582aTKfG0O2ncuHEwywUAANIQYf0zZVYg6zoqMDlw4ID07t1bNmzYIIULFzbzTpw4IVdeeaUsWrRIypcvH4pyAgCAHHB1Yb/bmNx+++2mW7BmS/78808z6W1tCKuPAQAAZFnGZO3atbJx40apVauWd57enjFjhml7AgAAsoblzKRH1gYmFSpUSHEgNb2GTtmyZYNVLgAAkAaqcv5n8uTJMmzYMNP41UNv33vvvTJlypRglw8AAKTR+DWQybUZkyJFivhEVmfOnJGmTZtKrlz/rP7333+b2wMHDpSuXbuGrrQAACCsZSgwmT59euhLAgAAJKdX5WQoMNEh6AEAgHNYYTokfaYHWFPx8fFy/vx5n3kxMTGBlgkAAORQfgcm2r7kwQcflMWLF8uxY8dS7J0DAABCK8KyzBTI+mHRK+eBBx6Qzz//XGbNmiVRUVHy+uuvy+OPP266CusVhgEAQOhZVuBTWGRM9CrCGoC0bt1abrvtNjOoWvXq1aVSpUqyYMEC6du3b2hKCgAAwp7fGRMdgr5q1are9iR6X1111VWybt264JcQAACk2isnkCksAhMNSvbt22du165d27Q18WRSPBf1AwAAoWWFaVWO34GJVt/88MMP5vZDDz0kL774okRHR8v9998vo0ePDkUZAQBADuF3YKIByPDhw83ttm3byo4dO2ThwoXy/fffm2HpAQBA1vXKiQhg8oc21+jUqZPp7KLVQO+//77P4wMGDLioqui6667L2nFMlDZ61QkAAGQdK8DqGH/X1eFCGjZsaC4/07179xSX0UBkzpw53vvaezckgckLL7yQ4Q16sikAACB8hqTv0KGDmdKigUjp0qUlEBkKTKZNm5bhJ0lgAgCAe8TFxV0UXGQm06HWrFkjJUuWNBf/vfrqq+XJJ5+UYsWKBT8w8fTCQdYYOm6IROUrkN3FAEJi/uZfs7sIQMj8deZUljYSjQhwfVWhQgWf+ePGjZPx48f7vT2txtEqnipVqsiePXvk4YcfNhmWTZs2SWRkZNa1MQEAAO6tyomNjfW5zl1msyW9evXy3q5fv740aNBAqlWrZrIo11xzTYa3E0iwBQAAXC4mJsZnymxgktK4Z8WLF5fdu3f7tR4ZEwAAXMiytMtwYOuH0oEDB8zFfsuUKePXegQmAAC4UESAgYm/654+fdon+6HtT7ds2SJFixY1k17Q98YbbzS9crSNiV70V6+l1759e7/2Q2ACAADStXnzZmnTpo33/ogRI8zf/v37y6xZs2Tr1q3y5ptvyokTJ8wgbO3atZMJEyb4XTWUqcBk/fr18sorr5iIaMmSJVKuXDmZP3++aYmrF/MDAADhNY5J69atxbbtVB//9NNPJRj8bvz67rvvmrRM3rx5zTD0586dM/NPnjwpTz/9dFAKBQAAMlaVE8jkRH4HJjpYyssvvyyvvfaa5M6d2zu/efPm8t133wW7fAAAIAfxuypn586d0rJly4vmFypUyNQrAQCA8LtWjmMzJtraNqU+yV988YXpswwAAMLv6sKODUwGDx4s9957r3z11Vem4czBgwdlwYIFMmrUKLnrrrtCU0oAAJDikPSBTGFRlfPQQw9JYmKiGV727NmzplpHuwJpYDJs2LDQlBIAAOQIfgcmmiV55JFHZPTo0aZKRwdcqVOnjhQowEXnAADIKlaYtjHJ9ABrefLkMQEJAADIehESWDsRXT8sAhMd9S2tQVk+//zzQMsEAAByKL8Dk0svvdTnfkJCghkrf9u2bWZYWgAAEHoWVTn/mDZtWorzx48fb9qbAACA8LuIX1YJWm+hW265Rd54441gbQ4AAORAQbu68KZNmyQ6OjpYmwMAAOlUxQTS+DVsqnK6d+/uc1+vNHjo0CFzOeSxY8cGs2wAACAVtDFJck2cpCIiIqRWrVryxBNPSLt27YJZNgAAkMP4FZhcuHBBbrvtNqlfv74UKVIkdKUCAABpovGriERGRpqsCFcRBgAge1lB+BcWvXLq1asne/fuDU1pAACAXxmTQKawCEyefPJJc8G+5cuXm0avcXFxPhMAAEDI25ho49aRI0dKx44dzf3OnTv7DE2vvXP0vrZDAQAAoRURpm1MMhyYPP744zJkyBBZvXp1aEsEAADSpcmAtK5dl5H1XR2YaEZEtWrVKpTlAQAAOViucIiuAADIaSJyelWOqlmzZrrByZ9//hlomQAAQDoY+fV/7UySj/wKAACQLYFJr169pGTJkkHbOQAAyJwIywroIn6BrOuIwIT2JQAAOEdEmLYxifC3Vw4AAEC2Z0wSExNDVggAAOCnABu/OvRSOf61MQEAAM4QIZaZAlnfiQhMAABwIStMuwv7fRE/AACAUCFjAgCAC0WEaa8cAhMAAFwoIkzHMaEqBwAAOAYZEwAAXMgK08avBCYAALi1u7AVft2FqcoBAACOQcYEAAAXsqjKAQAATqryiAhwfSdyarkAAEAORMYEAAAXsizLTIGs70QEJgAAuJAV4AWCnRmWEJgAAOBKjPwKAAAQYmRMAABwKUvCD4EJAAAuZIXpOCZU5QAAAMcgYwIAgAtZdBcGAABOEcHIrwAAAKFFxgQAABeyqMoBAABOYYXpyK9U5QAAAMcgYwIAgAtZVOUAAACniAjTXjkEJgAAuJAVphkTpwZMAAAgByJjAgCAC1lh2iuHwAQAABeyuIgfAADIqdatWyedOnWSsmXLmvYp77//vs/jtm3LY489JmXKlJG8efNK27ZtZdeuXX7vh8AEAAAXihAr4MkfZ86ckYYNG8qLL76Y4uOTJk2SF154QV5++WX56quvJH/+/NK+fXuJj4/3az9U5QAA4EJWFlfldOjQwUwp0WzJ9OnT5dFHH5UuXbqYefPmzZNSpUqZzEqvXr0yvB8yJgAA5GBxcXE+07lz5/zexr59++Tw4cOm+sajUKFC0rRpU9m0aZNf2yIwAQDAhawg/FMVKlQwQYRnmjhxot9l0aBEaYYkKb3veSyjqMoBACAHV+XExsZKTEyMd35UVJRkJzImAADkYDExMT5TZgKT0qVLm79Hjhzxma/3PY9lFIEJAAAuZAXYI8dTlRMMVapUMQHIZ5995p2n7VW0d06zZs382hZVOQAAuJCVxb1yTp8+Lbt37/Zp8LplyxYpWrSoVKxYUe677z558sknpUaNGiZQGTt2rBnzpGvXrn7th8AEAAAXsrI4MNm8ebO0adPGe3/EiBHmb//+/WXu3LnywAMPmLFO7rjjDjlx4oRcddVVsmLFComOjvZrPwQmAAAgXa1btzbjlaRGR4N94oknzBQIAhMAAFzICrCdSDDbmAQTgQkAAC4UYf0zBbK+E9ErBwAAOAYZEwAAXMiiKgcAAOTUXjlZhaocAADgGGRMAABwISvA6hiHJkwITAAAcKMIeuUAAACEFhmTAFSuXNlcG0AnONeBfb/J5vXfypHffpczp85I51uul+p1qqW47Kr3P5etX2+T1te3kMuaN8rysgKZsXtXrHy28huJ3X9Y4k6ekdvv7CoNLq1hHrtw4YIs//AL+WnbXjn2x0mJzptHatWuJJ27tpJChQtkd9ERACtMe+U4ImOyadMmiYyMlOuvvz67i4IwlHA+QUqULiFXd26d5nK7/rtHDsUelvwx+bOsbEAwnD+XIOXKlZCberW9+LHzf8uB/UekfcdmMnpMPxl0R1c5euS4vDrrvWwpK4LfK8cKYHIiRwQms2fPlmHDhsm6devk4MGD2V0chJkqtSpL83bNpEbdlLMk6tTJ07J62Rrp0LO9REY44m0BZFidelXlhi4tpOGlNS96LG/eKLnn3p5yWePaUqp0UalStaz0uPkaid1/RP78My5byotgNn6VgCYnyvZPYL2M8ttvvy133XWXyZjoFQo91qxZYy4K9Nlnn0mTJk0kX758cuWVV8rOnTt9tjFr1iypVq2a5MmTR2rVqiXz58/3eVy38corr8gNN9xgtnHJJZeYLI1evlkvSpQ/f36z3T179njX0dtdunSRUqVKSYECBeTyyy+XVatWpfo8Bg4caLafVEJCgpQsWdIEXnAuO9GWFe/8R5q0aCzFSxXL7uIAIRf/1znza1mDFsBpsj0wWbx4sdSuXdsEFLfccou88cYbF1298JFHHpHnnnvOXHI5V65cJgjwWLp0qdx7770ycuRI2bZtm9x5551y2223yerVq322MWHCBOnXr59s2bLF7K9Pnz5m2TFjxpjt6j6HDh3qEzB17NjRBEXff/+9XHfdddKpUyfZv39/is/j9ttvN5d3PnTokHfe8uXL5ezZs3LzzTenuM65c+ckLi7OZ0LW+2bdZomIsKTRlQ2zuyhAyCUk/C0fLF0nlzW5hMDE5SLEkggrgMmhOZNsD0w0m6ABidIv/5MnT8ratWt9lnnqqaekVatWUqdOHXnooYdk48aNEh8fbx6bMmWKDBgwQO6++26pWbOmjBgxQrp3727mJ6XBSs+ePc0yDz74oPzyyy/St29fad++vcmgaHCjGRqPhg0bmsClXr16UqNGDRPYaFbmww8/TPF5aMYlebZmzpw5ctNNN5mMS0omTpwohQoV8k4VKlQI4EgiM478dlS+2/iDtO9xrcmsAeFMG8LOeU0/w2zp2fva7C4OAmRRlRN8WiXz9ddfS+/evc19zYZodiF51UeDBg28t8uUKWP+Hj161Pzdvn27NG/e3Gd5va/zU9uGVs+o+vXr+8zTYMeTtdCMyahRo0zQUrhwYRNc6DZTy5h4siYajKgjR47IJ5984pPdSU6zNRqIeabY2Ng0jhZC4bdffpOzZ87Ka5PmyLRHZ5gp7sQpWfvxF/L6pH9eSyCcghJtV3LP8J5kS+BY2dpdWAOQv//+W8qWLeudp1UqUVFRMnPmTO+83Llze297ftUmJib6ta+UtpHWdjUoWblypcm8VK9eXfLmzSs9evSQ8+fPp7oPrSrSjI62X9GsTpUqVaRFixapLq/PUydkn0sa1ZaK1Sr6zHt37vtS59LaUrdxnWwrFxCKoOT3oydk6P03S/4CebO7SAgGK8C0h0NTJtkWmGhAMm/ePNN2pF27dj6Pde3aVd566y3TFiQ9mtHYsGGD9O/f3ztP72u1TyB0G1pF1K1bN28GRat/0lKsWDFTds2aaHCi1UfIfufPnZcTx05675/8M06OHvxdovNFS0zhgpI3n++HtPbKyV8wnxQtUSQbSgv471z8efn99+Pe+8eOnZQDsUckX/68UqhQfpn96ofm/p13dxc7MVHiTp42y+njuXJFZmPJEQgrTMcxybbARBuGHj9+XAYNGmTaVyR14403mmzK5MmT093O6NGjTduRRo0aSdu2bWXZsmXy3nvvpdmDJiO0XYluRxu8ajZl7NixGcrSaHWO9s7RXyhJgyVkbzuSd17//zEb1n683vytc9klcl0P6tnhfvv3H5YZ09723l+65J/G//+6oq50uKG5bNu629x/9qk3fdYbdv/NUqOmb8YQyLGBiQYeGkgkD0o8gcmkSZNk69at6W5HMxTPP/+8qXLRBqxafaIZC+0GHIipU6ea9iHaqLV48eKmwWxGes3oc9J2MHXr1vWpokL2qVC1vIx4eniGl7/9ATJdcBcNLl6YNTrVx9N6DC5mBThImjMTJmLZyfvmIiBa5VOuXDkTHGnvIH9o4KOB2sgl30pUPoaKRniqXIR2VQhff505Jfe2rW86NMTExIRkH3H/+674fMt+KVAw8/s4fSpOrr60YkjLmhlcKydItJrnjz/+MG1mtBdP586ds7tIAAC4DoFJkGg3Yq1GKl++vBm9Vrs+AwAQMha9cpDOlYapFQMAZBWLXjkAAMAprAAbvzp1sOtsH5IeAADAg4wJAAAuZIVnExMCEwAAXMkKz8iEqhwAAOAYZEwAAHAhi145AADAKSx65QAAAIQWGRMAAFzICs+2rwQmAAC4khWekQlVOQAAwDHImAAA4EIWvXIAAIBTWGHaK4fABAAAF7LCs4kJbUwAAIBzkDEBAMCNrPBMmRCYAADgQlaYNn6lKgcAADgGGRMAAFzIolcOAABwCis8m5hQlQMAAJyDjAkAAG5khWfKhMAEAAAXsuiVAwAAEFpkTAAAcCGLXjkAAMAprPBsYkJgAgCAK1nhGZnQxgQAADgGGRMAAFzICtNeOQQmAAC4kRVgA1ZnxiVU5QAAAOcgYwIAgAtZ4dn2lcAEAABXssIzMqEqBwAAOAYZEwAAXMiiVw4AAHAKK0yHpKcqBwAApGv8+PFiWZbPVLt2bQk2MiYAALiQlQ1tX+vWrSurVq3y3s+VK/hhBIEJAABuZGV9ZKKBSOnSpSWUqMoBAMDFjV+tAP6puLg4n+ncuXOp7nPXrl1StmxZqVq1qvTt21f2798f9OdFYAIAQA5WoUIFKVSokHeaOHFiiss1bdpU5s6dKytWrJBZs2bJvn37pEWLFnLq1KmgloeqHAAA3FqTYwW2voqNjZWYmBjv/KioqBSX79Chg/d2gwYNTKBSqVIlWbx4sQwaNEiChcAEAIAc3MQkJibGJzDJqMKFC0vNmjVl9+7dEkxU5QAAAL+dPn1a9uzZI2XKlJFgIjABAMDFA6xZAUz+GDVqlKxdu1Z++eUX2bhxo3Tr1k0iIyOld+/eQX1eVOUAAOBKVpb2Fz5w4IAJQo4dOyYlSpSQq666Sr788ktzO5gITAAAQLoWLVokWYHABAAAF7LC9Fo5BCYAALiQlQ1D0mcFGr8CAADHIGMCAIALWVTlAAAAp7CSXO8ms+s7EYEJAABuZIVnIxPamAAAAMcgYwIAgAtZ4ZkwITABAMCNrDBt/EpVDgAAcAwyJgAAuJBFrxwAAOAYVng2MqEqBwAAOAYZEwAAXMgKz4QJgQkAAG5k0SsHAAAgtMiYAADgSlaAPWucmTIhMAEAwIUsqnIAAABCi8AEAAA4BlU5AAC4kBWmVTkEJgAAuJAVpkPSU5UDAAAcg4wJAAAuZFGVAwAAnMIK0yHpqcoBAACOQcYEAAA3ssIzZUJgAgCAC1n0ygEAAAgtMiYAALiQRa8cAADgFFZ4NjEhMAEAwJWs8IxMaGMCAAAcg4wJAAAuZIVprxwCEwAAXMii8StCzbZt8/fc2dPZXRQgZP7Kcz67iwCETPyZ0z6f56EUFxeXreuHCoGJg5w6dcr8ndmvVXYXBQAQ4Od5oUKFQrLtPHnySOnSpaVGlQoBb0u3o9tzEsvOirAOGZKYmCgHDx6UggULiuXUHFuY0V8MFSpUkNjYWImJicnu4gBBxfmd9fQrVYOSsmXLSkRE6PqXxMfHy/nzgWcfNSiJjo4WJyFj4iB6EpcvXz67i5Ej6Yc2H9wIV5zfWStUmZKkNJhwWkARLHQXBgAAjkFgAgAAHIPABDlaVFSUjBs3zvwFwg3nN9yIxq8AAMAxyJgAAADHIDABAACOQWACAAAcg8AECIE1a9aYQfJOnDiR3UUBgqZy5coyffr07C4GwhyBCRxvwIAB5kv+mWee8Zn//vvvM0IuXGnTpk0SGRkp119/fXYXBXAcAhO4go5w+Oyzz8rx48eDts1gDOcMZMbs2bNl2LBhsm7dOnMZCgD/j8AErtC2bVtzsamJEyemusy7774rdevWNWM2aMr5ueee83lc502YMEH69etnhue+4447ZO7cuVK4cGFZvny51KpVS/Llyyc9evSQs2fPyptvvmnWKVKkiAwfPlwuXLjg3db8+fOlSZMm5rpGWq4+ffrI0aNHQ3oMEB5Onz4tb7/9ttx1110mY6LnYPIqwM8++8ycX3o+XnnllbJz506fbcyaNUuqVatmrnOi562ej0npNl555RW54YYbzDYuueQSk6XZvXu3tG7dWvLnz2+2u2fPHu86ertLly5SqlQpKVCggFx++eWyatWqVJ/HwIEDzfaTSkhIkJIlS5rAC8g0HccEcLL+/fvbXbp0sd977z07Ojrajo2NNfOXLl2qY/CY25s3b7YjIiLsJ554wt65c6c9Z84cO2/evOavR6VKleyYmBh7ypQp9u7du82kj+fOndu+9tpr7e+++85eu3atXaxYMbtdu3Z2z5497f/+97/2smXL7Dx58tiLFi3ybmv27Nn2xx9/bO/Zs8fetGmT3axZM7tDhw7ex1evXm3Kdvz48Sw9VnA+PXeaNGlibuu5Va1aNTsxMdHnvGnatKm9Zs0ac/61aNHCvvLKK73r6/tAz9kXX3zRnOvPPfecHRkZaX/++efeZXQb5cqVs99++22zTNeuXe3KlSvbV199tb1ixQr7p59+sq+44gr7uuuu866zZcsW++WXX7Z//PFH++eff7YfffRR83779ddffd5D06ZNM7c3bNhg9nvw4EGfsuXPn98+depUiI8iwhmBCVwTmCj9MB04cOBFgUmfPn1McJHU6NGj7Tp16vh8qOoHdFIamOg2NEjxuPPOO+18+fL5fLi2b9/ezE/NN998Y7bjWYfABKnRIGP69OnmdkJCgl28eHFzviQ9b1atWuVd/qOPPjLz/vrrL+/6gwcP9tnmTTfdZHfs2NF7X5fXwMJDg2edp0GRx1tvvWUCj7TUrVvXnjFjRoqBidL317PPPuu936lTJ3vAgAF+HhHAF1U5cBVtZ6JVLNu3b/eZr/ebN2/uM0/v79q1y6cKRtPjyWmqW9PiHprK1iocTWcnnZe0qubbb7+VTp06ScWKFU11TqtWrcz8/fv3B+mZIhxplczXX38tvXv3Nvdz5colN99880VVHw0aNPDeLlOmjPnrOf9SO9eTvyeSbkPPX1W/fn2fefHx8RIXF+etYho1apSp9tHqTT3/dZtpndO33367zJkzx9w+cuSIfPLJJ6aKBwgEgQlcpWXLltK+fXsZM2ZMptbXuvXkcufOfVH9fErzEhMTze0zZ86YMmg7lQULFsg333wjS5cuNY/RoBZp0QDk77//lrJly5qgRCdtL6Lto06ePOldLun55+l55jn/MiqlbaS1XQ1K9Dx++umnZf369bJlyxYTyKR1Tmt7rb1795r2K//+97+lSpUq0qJFC7/KCSSX66I5gMNpt+FLL73UNPrz0F95GzZs8FlO79esWdN0ywymHTt2yLFjx0w5KlSoYOZt3rw5qPtA+NGAZN68eaZRdrt27Xwe69q1q7z11ltSu3btdLfjOdf79+/vnaf369SpE1D5dBvaNb9bt27eDMovv/yS5jrFihUzZdesiQYnt912W0BlABSBCVxHf8X17dtXXnjhBe+8kSNHml4E2utGU+P6ITlz5kx56aWXgr5/rb7R3hAzZsyQIUOGyLZt28x+gbRozy/t7j5o0CApVKiQz2M33nijyaZMnjw53e2MHj1aevbsKY0aNTK91ZYtWybvvfdemj1oMqJGjRpmO1pFqdmUsWPHZihLo9U52jtHq0yTBktAZlGVA1d64oknfD40L7vsMlm8eLEsWrRI6tWrJ4899phZRn8BBluJEiVMF8933nnH/ErVzMmUKVOCvh+EFw08NJBIHpR4AhPNum3dujXd7WiG4vnnnzfnnHaP127BmrHQbsCBmDp1qukar92INTjR6kp9X6VHn5O2g9HltYoKCJSlLWAD3goAIEfSKp9y5cqZ4Kh79+7ZXRyEAapyAAB+04zlH3/8YdrMaC+ezp07Z3eRECYITAAAftNuxNoLp3z58qZqU3sYAcFAVQ4AAHAMGr8CAADHIDABAACOQWACAAAcg8AEAAA4BoEJAB86KJ0O4uWhA3fdd999WV6ONWvWmBFIT5w4keoy+vj777+f4W2OHz/eXM4gEDpMu+5XryUDIPgITACXBAv6ZaiTDodfvXp1M7KtXn8l1HSY8owOuZ+RYAIA0kLHc8AlrrvuOjO65rlz5+Tjjz+We+65x1wtNqUrLesVYTWACYaiRYsGZTsAkBFkTACXiIqKktKlS0ulSpXkrrvuMtco+fDDD32qX5566ilzvRLPlZdjY2PNBd90ZE4NMLp06eJzxVi98NqIESPM43ql2AceeECSD22UvCpHA6MHH3zQXFlZy6TZG70OjG63TZs2Zhm95opmTjzXKtJRQidOnGgG5MqbN680bNhQlixZ4rMfDbb0atD6uG4nvSvbpkTLpdvIly+fVK1a1VyILiEh4aLl9PoyWn5dTo/PyZMnfR5//fXXzVV8o6OjzRV/Q3ExSAApIzABXEq/wDUz4vHZZ5/Jzp07ZeXKleZKtvqFrBdWK1iwoKxfv95c1r5AgQIm8+JZT4cT11E733jjDfniiy/kzz//lKVLl6a53379+slbb71lru68fft28yWv29Uv+nfffdcso+U4dOiQudic0qBk3rx58vLLL8t///tfuf/+++WWW26RtWvXegMovc6KXjxO227oFWsfeughv4+JPld9Pj/99JPZ92uvvSbTpk3zWWb37t3mgo96Vd4VK1bI999/L3fffbf38QULFpiLQGqQp8/v6aefNgHOm2++6Xd5AGSCjvwKwNn69+9vd+nSxdxOTEy0V65caUdFRdmjRo3yPl6qVCn73Llz3nXmz59v16pVyyzvoY/nzZvX/vTTT839MmXK2JMmTfI+npCQYJcvX967L9WqVSv73nvvNbd37typ6RSz/5SsXr3aPH78+HHvvPj4eDtfvnz2xo0bfZYdNGiQ3bt3b3N7zJgxdp06dXwef/DBBy/aVnL6+NKlS1N9fPLkyXbjxo2998eNG2dHRkbaBw4c8M775JNP7IiICPvQoUPmfrVq1eyFCxf6bGfChAl2s2bNzO19+/aZ/X7//fep7hdA5tHGBHAJzYJoZkIzIVo10qdPH9PLxKN+/fo+7Up++OEHkx3QLEJS8fHxsmfPHlN9oVmNpk2beh/T6500adLkouocD81mREZGSqtWrTJcbi3D2bNn5dprr/WZr1mbRo0amduamUhaDtWsWTPx19tvv20yOfr89Kq32jg4JibGZ5mKFSuaq+Em3Y8eT83y6LHSdQcNGiSDBw/2LqPbKVSokN/lAeA/AhPAJbTdxaxZs0zwoe1Ikl80LX/+/D739Yu5cePGpmoiuRIlSmS6+shfWg710Ucf+QQEStuoBMumTZukb9++8vjjj5sqLA0kFi1aZKqr/C2rVgElD5Q0IAMQegQmgEto4KENTTPqsssuMxmEkiVLXpQ18ChTpox89dVX0rJlS29m4NtvvzXrpkSzMppd0LYh2vg2OU/GRhvVetSpU8cEIHo12tQyLdrQ1NOQ1+PLL78Uf2zcuNE0DH7kkUe883799deLltNyHDx40AR3nv1ERESYBsOlSpUy8/fu3WuCHABZj8avQJjSL9bixYubnjja+HXfvn1mnJHhw4fLgQMHzDL33nuvPPPMM2aQsh07dphGoGmNQVK5cmXp37+/DBw40Kzj2aY2JlUaGGhvHK12+v33300GQqtHRo0aZRq8agNSrSr57rvvZMaMGd4GpUOGDJFdu3bJ6NGjTZXKwoULTSNWf9SoUcMEHZol0X1olU5KDXm1p40+B63q0uOix0N75miPJ6UZF22sq+v//PPP8uOPP5pu2lOnTvWrPAAyh8AECFPaFXbdunWmTYX2eNGshLad0DYmngzKyJEj5dZbbzVf1NrWQoOIbt26pbldrU7q0aOHCWK0K622xThz5ox5TKtq9Itde9Ro9mHo0KFmvg7Qpj1b9Atfy6E9g7RqR7sPKy2j9ujRYEe7EmvvHe0N44/OnTub4Ef3qaO7agZF95mcZp30eHTs2FHatWsnDRo08OkOrD2CtLuwBiOaIdIsjwZJnrICCC1LW8CGeB8AAAAZQsYEAAA4BoEJAABwDAITAADgGAQmAADAMQhMAACAYxCYAAAAxyAwAQAAjkFgAgAAHIPABAAAOAaBCQAAcAwCEwAA4BgEJgAAQJzi/wAE2LdasPILugAAAABJRU5ErkJggg==" + "image/png": "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" }, "metadata": {}, "output_type": "display_data", @@ -701,7 +731,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data", @@ -715,20 +745,27 @@ { "metadata": {}, "cell_type": "markdown", - "source": "### Visualise results", + "source": [ + "### Visualise results\n", + "\n", + "Here we show how to visualise results for a specific event and model.\n", + "\n", + "For the event chosen, 49 of manufacturer 1, the customer called because of lack of hot water. It turned out to be an operating error where the DHW controller was set to night mode, leading to a very low setpoint for the DHW storage temperatures" + ], "id": "570ebfedc795dd61" }, { "metadata": { "ExecuteTime": { - "end_time": "2026-01-12T08:21:32.214615900Z", - "start_time": "2026-01-12T08:21:32.177505500Z" + "end_time": "2026-01-13T10:51:47.618674Z", + "start_time": "2026-01-13T10:51:47.602650600Z" } }, "cell_type": "code", "source": [ + "# Choose event and model to plot results for\n", "manufacturer = 1\n", - "config_name = 'cond_ae'\n", + "model_name = 'Conditional AE'\n", "event_id = 49\n", "report_date = dataset.events[manufacturer].loc[event_id]['Report date']\n", "\n", @@ -767,25 +804,30 @@ { "metadata": {}, "cell_type": "markdown", - "source": "#### Criticality", + "source": [ + "#### Criticality\n", + "\n", + "Plot the criticality and the incident report timestamp." + ], "id": "e1d0ace838ed0d5f" }, { "metadata": { "ExecuteTime": { - "end_time": "2026-01-12T08:21:32.754895600Z", - "start_time": "2026-01-12T08:21:32.303730300Z" + "end_time": "2026-01-13T10:51:47.805480100Z", + "start_time": "2026-01-13T10:51:47.662858400Z" } }, "cell_type": "code", "source": [ - "predictions = results[manufacturer][config_name][event_id]\n", + "predictions = results[manufacturer][model_name][event_id]\n", "\n", "fig, ax = plt.subplots(1, 1, figsize=(8,3))\n", "crit = predictions.criticality()\n", - "crit.plot(ax=ax, label=config_name)\n", + "crit.plot(ax=ax, label=model_name)\n", "\n", - "ax.axvline(report_date, label='incident report', c='r', linestyle='-')\n", + "if pd.notna(report_date):\n", + " ax.axvline(report_date, label='incident report', c='r', linestyle='-')\n", "\n", "ax.legend(loc='upper left')\n", "ax.set_ylabel('criticality')\n", @@ -808,7 +850,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data", @@ -822,14 +864,19 @@ { "metadata": {}, "cell_type": "markdown", - "source": "#### ARCANA results", + "source": [ + "#### ARCANA results\n", + "\n", + "Here we first determine anomalous events detected by the model and then calculate the ARCANA feature importances for the longest detected anomaly event.\n", + "Afterward, we plot the top 3 features with the highest ARCANA feature importances." + ], "id": "814da89e48b3860c" }, { "metadata": { "ExecuteTime": { - "end_time": "2026-01-12T08:21:45.802629500Z", - "start_time": "2026-01-12T08:21:33.224452Z" + "end_time": "2026-01-13T10:51:58.483098200Z", + "start_time": "2026-01-13T10:51:47.845224700Z" } }, "cell_type": "code", @@ -845,7 +892,7 @@ "longest_anomaly_event = anomaly_events[anomaly_events['duration'] == anomaly_events['duration'].max()].iloc[0]\n", "\n", "# Calculate ARCANA feature importances\n", - "top_features = get_arcana_importances(manufacturer, event_id, config_name, test_data.loc[longest_anomaly_event['start']:report_date])\n", + "top_features = get_arcana_importances(manufacturer, event_id, model_name, test_data.loc[longest_anomaly_event['start']:report_date])\n", "\n", "top_features" ], @@ -854,18 +901,18 @@ { "data": { "text/plain": [ - "s_dhw_supply_temperature_setpoint 0.208051\n", - "s_hc1_supply_temperature_setpoint 0.146244\n", - "outdoor_temperature 0.117945\n", - "p_net_meter_heat_power 0.116884\n", - "s_dhw_lower_storage_temperature 0.082830\n", - "p_net_supply_temperature 0.076468\n", - "s_hc1_supply_temperature 0.072472\n", - "s_dhw_upper_storage_temperature 0.051432\n", - "p_hc1_return_temperature 0.044122\n", - "p_net_meter_flow 0.041088\n", - "s_dhw_supply_temperature 0.024492\n", - "p_net_return_temperature 0.017975\n", + "s_dhw_supply_temperature_setpoint 0.602189\n", + "outdoor_temperature 0.096260\n", + "s_dhw_supply_temperature 0.085659\n", + "s_hc1_supply_temperature_setpoint 0.059392\n", + "p_net_supply_temperature 0.050071\n", + "s_hc1_supply_temperature 0.034755\n", + "p_net_return_temperature 0.026886\n", + "s_dhw_lower_storage_temperature 0.023758\n", + "s_dhw_upper_storage_temperature 0.016889\n", + "p_net_meter_heat_power 0.002633\n", + "p_net_meter_flow 0.000893\n", + "p_hc1_return_temperature 0.000614\n", "dtype: float32" ] }, @@ -879,8 +926,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-01-12T08:21:46.424395400Z", - "start_time": "2026-01-12T08:21:45.946579100Z" + "end_time": "2026-01-13T10:51:59.243154700Z", + "start_time": "2026-01-13T10:51:58.602602600Z" } }, "cell_type": "code", @@ -898,7 +945,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 10, @@ -910,7 +957,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data", diff --git a/notebooks/PreDist/configs/m1_cond_ae.yaml b/notebooks/PreDist/configs/m1_cond_ae.yaml index 20d2f0c..d314d40 100644 --- a/notebooks/PreDist/configs/m1_cond_ae.yaml +++ b/notebooks/PreDist/configs/m1_cond_ae.yaml @@ -14,7 +14,6 @@ train: features_to_exclude: - p_net_meter_energy # we use power and flow - p_net_meter_volume - ts_features: ['hour_of_day', 'day_of_week'] autoencoder: name: conditional diff --git a/notebooks/PreDist/configs/m1_doy_ae.yaml b/notebooks/PreDist/configs/m1_doy_ae.yaml index bb5b832..e2fc23d 100644 --- a/notebooks/PreDist/configs/m1_doy_ae.yaml +++ b/notebooks/PreDist/configs/m1_doy_ae.yaml @@ -14,7 +14,6 @@ train: features_to_exclude: - p_net_meter_energy # we use power and flow - p_net_meter_volume - ts_features: ['hour_of_day', 'day_of_week', 'day_of_year'] autoencoder: name: conditional diff --git a/notebooks/PreDist/configs/m2_cond_ae.yaml b/notebooks/PreDist/configs/m2_cond_ae.yaml index 4f9137c..a171ac4 100644 --- a/notebooks/PreDist/configs/m2_cond_ae.yaml +++ b/notebooks/PreDist/configs/m2_cond_ae.yaml @@ -23,7 +23,6 @@ train: - s_hc1.2_room_temperature_setpoint - s_hc1.3_room_temperature_setpoint - s_hc1_room_temperature_setpoint - ts_features: ['hour_of_day', 'day_of_week'] autoencoder: name: conditional diff --git a/notebooks/PreDist/configs/m2_doy_ae.yaml b/notebooks/PreDist/configs/m2_doy_ae.yaml index c3a6434..5acfac6 100644 --- a/notebooks/PreDist/configs/m2_doy_ae.yaml +++ b/notebooks/PreDist/configs/m2_doy_ae.yaml @@ -23,7 +23,6 @@ train: - s_hc1.2_room_temperature_setpoint - s_hc1.3_room_temperature_setpoint - s_hc1_room_temperature_setpoint - ts_features: ['hour_of_day', 'day_of_week', 'day_of_year'] autoencoder: name: conditional diff --git a/notebooks/PreDist/predist_utils.py b/notebooks/PreDist/predist_utils.py index d2d19ab..9324b3b 100644 --- a/notebooks/PreDist/predist_utils.py +++ b/notebooks/PreDist/predist_utils.py @@ -1,7 +1,6 @@ from typing import List, Tuple from pathlib import Path from copy import deepcopy -import logging import gc import pandas as pd @@ -16,27 +15,36 @@ from energy_fault_detector.root_cause_analysis.arcana_utils import calculate_mean_arcana_importances -def train_or_get_model(event_id: int, dataset: PreDistDataset, manufacturer: int, config_name: str, conf: Config, - bottleneck_ratio: float, load_from_file: bool, ts_features_orig: List[str] | None +def train_or_get_model(event_id: int, dataset: PreDistDataset, manufacturer: int, model_name: str, conf: Config, + bottleneck_ratio: float, load_from_file: bool, time_features: List[str] | None ) -> Tuple[int, FaultDetectionResult]: - """Processes a single event: loads data, trains/loads model, and predicts.""" + """Processes a single event: loads data, trains/loads model, and predicts. - # Configure logging - logger = logging.getLogger('energy_fault_detector') - if not logger.handlers: - logging.basicConfig(level=logging.INFO) + Args: + event_id (int): ID of the event to process. + dataset (PreDistDataset): Dataset containing the event data. + manufacturer (int): Manufacturer ID for the event. + model_name (str): Name of the model to use for training. + conf (Config): Base configuration for training. + bottleneck_ratio (float): Ratio to determine the bottleneck size for the autoencoder. + load_from_file (bool): Whether to load the model from file if available. Otherwise, train and save a new model. + time_features (List[str] | None): List of time features to use for conditional autoencoders. - logger.info(f'Processing event {event_id} for manufacturer {manufacturer}...') + Returns: + Tuple[int, FaultDetectionResult]: A tuple containing the event ID and the fault detection result. + """ - # Local copy of ts_features and configuration to avoid mutation issues in parallel - ts_features = ts_features_orig.copy() if ts_features_orig else None + # Local copy of time features and configuration to avoid mutation issues in parallel + ts_features = time_features.copy() if time_features else None local_conf = deepcopy(conf) # Get specific event data data = dataset.get_event_data(manufacturer, event_id) + train_data = data['train_data'] + test_data = data['test_data'] # Create a new model or load from file - model_path = Path(f'./models/m{manufacturer}/event_{event_id}/{config_name}') + model_path = Path(f'./models/m{manufacturer}/event_{event_id}/{model_name}') if model_path.exists() and load_from_file: model = FaultDetector() @@ -45,23 +53,25 @@ def train_or_get_model(event_id: int, dataset: PreDistDataset, manufacturer: int with open(model_path / 'ts_features.txt', 'r') as f: ts_features = f.read().splitlines() else: - # Prepare data and config - train_data = data['train_data'] + # Add the code size to the AE configuration, based on the bottleneck ratio + # code_size is part of the model configuration, so we overwrite the parameter of the underlying dictionary. bottleneck = calculate_bottleneck(train_data, local_conf, bottleneck_ratio) local_conf['train']['autoencoder']['params']['code_size'] = bottleneck + + # For the conditional autoencoders, add time features if ts_features: train_data = add_cyclic_time_features(train_data, ts_features) model = FaultDetector(local_conf, model_directory=model_path) model_data = model.fit(train_data, data['train_normal_flag'], save_models=True, overwrite_models=True) if ts_features: - # save the time features as well + # For the conditional autoencoders, save the time features as well with open(Path(model_data.model_path) / 'ts_features.txt', 'w') as f: f.write('\n'.join(ts_features)) # Predict - test_data = data['test_data'] if ts_features: + # For the conditional autoencoders, add time features test_data = add_cyclic_time_features(test_data, ts_features) predictions = model.predict(test_data) @@ -91,17 +101,41 @@ def add_cyclic_time_features(df: pd.DataFrame, features: List[str]) -> pd.DataFr return df -def calculate_bottleneck(df: pd.DataFrame, config: Config, ratio: float = 0.75) -> int: - """Calculates code_size relative to input dimensions, accounting for exclusions/conditions.""" +def calculate_bottleneck(df: pd.DataFrame, config: Config, ratio: float) -> int: + """Calculates code_size (the bottleneck of the autoencoder) relative to input dimensions, accounting for excluded + features and conditional features. + + Args: + df (pd.DataFrame): Input dataframe to determine the number of input features of the AE. + config (Config): Configuration for the AE. + ratio (float, optional): Ratio between input and bottleneck dimensions. + + Returns: + int: The calculated bottleneck size for the autoencoder. + """ + + # Get the conditional features from the config ae_params = config['train']['autoencoder']['params'] cond_features = ae_params.get('conditional_features', []) - # Exclude conditions and existing data_preprocessor exclusions + # Exclude conditions (not compressed) input_dim = len(df.columns) - len([c for c in cond_features if c in df.columns]) - # Check for manual feature exclusions in config - dp_params = config['train'].get('data_preprocessor', {}).get('params', {}) - excluded = dp_params.get('features_to_exclude', []) + # Check for feature exclusions in config + excluded = [] + dp_config = config['train'].get('data_preprocessor', {}) + if dp_config.get('params'): + # params-based data prep config + excluded = dp_config.get('params').get('features_to_exclude', []) + else: + # steps-based data prep config + steps = config['train']['data_preprocessor'].get('steps', []) + for step in steps: + if step['name'] == 'column_selector': + excluded = step['params'].get('features_to_exclude', []) + break + + # Remove the excluded features from the input dimension input_dim -= len([e for e in excluded if e in df.columns]) return max(1, round(input_dim * ratio)) @@ -110,7 +144,7 @@ def calculate_bottleneck(df: pd.DataFrame, config: Config, ratio: float = 0.75) def find_optimal_threshold(true_anomalies: pd.Series, max_criticalities: pd.Series, thresholds: np.ndarray = np.arange(1, 100), - k: int = 5) -> int: + k: int = 5) -> Tuple[int, float]: """Finds the threshold maximizing reliability (Event-wise F0.5) using CV. Args: @@ -120,35 +154,55 @@ def find_optimal_threshold(true_anomalies: pd.Series, k (int, optional): Number of folds for CV. Defaults to 5. Returns: - Optimal criticality threshold. + Optimal criticality threshold and avg validation reliability score. """ y_true = true_anomalies.values + max_criticalities = max_criticalities.values skf = StratifiedKFold(n_splits=k, shuffle=True, random_state=42) - results = [] - for t in thresholds: - fold_f05 = [] - y_pred = (max_criticalities >= t).astype(int).values + chosen_thresholds = [] + val_scores = [] + + for train_idx, val_idx in skf.split(y_true, y_true): + y_train, max_crit_train = y_true[train_idx], max_criticalities[train_idx] + y_val, max_crit_val = y_true[val_idx], max_criticalities[val_idx] + + # Best threshold on training data + best_t = None + best_train_f05 = -1.0 + for t in thresholds: + y_pred_train = (max_crit_train >= t).astype(int) + f05_train = fbeta_score(y_train, y_pred_train, beta=0.5, zero_division=0) + if f05_train > best_train_f05: + best_train_f05 = f05_train + best_t = t - for train_idx, val_idx in skf.split(y_true, y_true): - score = fbeta_score(y_true[val_idx], y_pred[val_idx], beta=0.5, zero_division=0) - fold_f05.append(score) + chosen_thresholds.append(best_t) - results.append({'threshold': t, 'mean_f05': np.mean(fold_f05)}) + # Evaluate on validation data + y_pred_val = (max_crit_val >= best_t).astype(int) + f05_val = fbeta_score(y_val, y_pred_val, beta=0.5, zero_division=0) + val_scores.append(f05_val) - best_t = max(results, key=lambda x: x['mean_f05'])['threshold'] - return best_t + robust_t = int(np.median(chosen_thresholds)) + mean_val_f05 = float(np.mean(val_scores)) + + return robust_t, mean_val_f05 def get_arcana_importances(manufacturer: int, event_id: int, config_name: str, data: pd.DataFrame) -> pd.Series: + """Get ARCANA importances for a given event.""" model_path = Path(f'models/m{manufacturer}/event_{event_id}/{config_name}') model = FaultDetector() model.load_models(model_path) + + # Load the time features and add them to the data if available (for the conditional autoencoders) if (model_path / 'ts_features.txt').exists(): with open(model_path / 'ts_features.txt', 'r') as f: ts_features = f.read().splitlines() data = add_cyclic_time_features(data, ts_features) + bias, _, _ = model.run_root_cause_analysis(data, track_losses=False, track_bias=False) return calculate_mean_arcana_importances(bias).sort_values(ascending=False) @@ -156,12 +210,18 @@ def get_arcana_importances(manufacturer: int, event_id: int, config_name: str, d def calculate_earliness(criticality_threshold: int, report_ts: int | pd.Timestamp, criticality: pd.Series, min_detection_time: pd.Timedelta = pd.Timedelta(hours=24) ) -> Tuple[int | pd.Timestamp | None, float]: - """Calculate the detection time and earliness score. + """Calculate the detection time and earliness score: + + E = max(0, min(1, (report_ts - detection_timestamp) / min_detection_time)) + + The earliness score is 1 if the fault is detected at least min_detection_time before the report and 0 if the + fault is detected after the report or not detected at all. Between min_detection_time before the report and the + report timestamp, the earliness score linearly decreases to 0. Args: criticality_threshold (int): Threshold for determining whether the event is detected. report_ts (int | pd.Timestamp): Timestamp of the report. - criticality (pd.Series): Series containing the criticality of each event. + criticality (pd.Series): Series containing the criticality pd.Series of each event. min_detection_time (pd.Timedelta, optional): Minimum detection time. Defaults to pd.Timedelta(hours=24). Returns: @@ -177,6 +237,6 @@ def calculate_earliness(criticality_threshold: int, report_ts: int | pd.Timestam detection_timestamp = crit_threshold_reached.sort_index(ascending=True).index[0] detection_time = report_ts - detection_timestamp - # max(earliness, 0) to handle detection after fault is known + # max(earliness, 0) to handle detection after the fault is known earliness = max(min(1, detection_time / min_detection_time), 0) return detection_time, earliness From a9f6ac83547cd0f65ba470b2687d0822503c05fb Mon Sep 17 00:00:00 2001 From: Cyriana Roelofs Date: Tue, 13 Jan 2026 14:46:48 +0100 Subject: [PATCH 10/10] Add comment on reproducability and load predist csv with low_memory=False --- .../evaluation/predist_dataset.py | 2 +- .../CARE to Compare/CARE to Compare.ipynb | 107 +-- notebooks/PreDist/PreDist.ipynb | 735 +++++++++--------- notebooks/PreDist/predist_utils.py | 4 + 4 files changed, 434 insertions(+), 414 deletions(-) diff --git a/energy_fault_detector/evaluation/predist_dataset.py b/energy_fault_detector/evaluation/predist_dataset.py index 143c5e2..177bb4f 100644 --- a/energy_fault_detector/evaluation/predist_dataset.py +++ b/energy_fault_detector/evaluation/predist_dataset.py @@ -74,7 +74,7 @@ def _load_events(self, manufacturer: int, filter_efd: bool = True) -> pd.DataFra def load_substation_data(self, manufacturer: int, substation_id: int) -> pd.DataFrame: """Loads raw CSV, maps string values, and cleans indices.""" file_path = self.root_path / f"Manufacturer {manufacturer}" / 'operational_data' / f"substation_{substation_id}.csv" - df = pd.read_csv(file_path, sep=';', index_col='timestamp', parse_dates=['timestamp']) + df = pd.read_csv(file_path, sep=';', index_col='timestamp', parse_dates=['timestamp'], low_memory=False) df.index = df.index.tz_localize(None) df = df.sort_index() diff --git a/notebooks/CARE to Compare/CARE to Compare.ipynb b/notebooks/CARE to Compare/CARE to Compare.ipynb index 9a869a1..0b86a6e 100644 --- a/notebooks/CARE to Compare/CARE to Compare.ipynb +++ b/notebooks/CARE to Compare/CARE to Compare.ipynb @@ -2,6 +2,13 @@ "cells": [ { "cell_type": "markdown", + "id": "fe8e2b4b8752a26d", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "# CARE Score and Care2CompareDataset usage\n", "\n", @@ -12,14 +19,11 @@ "2. Using the CAREScore to evaluate a model on the dataset.\n", "3. Recreating the results of the CARE paper.\n", "4. Using Care2CompareDataset and CARE-Score for other datasets." - ], - "metadata": { - "collapsed": false - }, - "id": "fe8e2b4b8752a26d" + ] }, { "cell_type": "code", + "execution_count": null, "id": "initial_id", "metadata": { "collapsed": true, @@ -27,6 +31,7 @@ "outputs_hidden": true } }, + "outputs": [], "source": [ "import os\n", "from pathlib import Path\n", @@ -36,51 +41,49 @@ "from energy_fault_detector.fault_detector import FaultDetector\n", "from energy_fault_detector.config import Config\n", "from energy_fault_detector.evaluation import CAREScore, Care2CompareDataset" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": null, "id": "75ac0a42f7c2f795", "metadata": {}, + "outputs": [], "source": [ "data_dir = Path('..') / '..' / 'Care_To_Compare_v6'" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": null, "id": "70f2af66920ba09b", "metadata": {}, + "outputs": [], "source": [ "c2c = Care2CompareDataset(path=data_dir, download_dataset=False) # If you have not downloaded the dataset yet, set download_dataset to True" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": null, "id": "8a1422f3e62850ab", "metadata": {}, + "outputs": [], "source": [ "c2c.event_info_all" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": null, "id": "48309c102d52aeb0", "metadata": {}, + "outputs": [], "source": [ "# select data for a specific event\n", "x, y = c2c.load_event_dataset(0, statistics=['average', 'std_dev'])\n", "x.head()" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -91,8 +94,11 @@ ] }, { - "metadata": {}, "cell_type": "code", + "execution_count": null, + "id": "e9087f75625207d2", + "metadata": {}, + "outputs": [], "source": [ "c2c = Care2CompareDataset(data_dir)\n", "index_column = 'id' # us time_stamp as index column if you are using the TimestampTransformer\n", @@ -174,14 +180,14 @@ "\n", " # print final score:\n", " print('Final score: ', care_score.get_final_score())" - ], - "id": "e9087f75625207d2", - "outputs": [], - "execution_count": null + ] }, { - "metadata": {}, "cell_type": "code", + "execution_count": null, + "id": "a41c52ce61dd7e06", + "metadata": {}, + "outputs": [], "source": [ "# combine results and get final score over all events / wind farms\n", "all_evaluations = pd.concat([pd.read_csv(f'results_{wf}{suffix}.csv') for wf in ['A', 'B', 'C']])\n", @@ -203,10 +209,7 @@ "\n", "print('overall')\n", "care_score.get_final_score()" - ], - "id": "a41c52ce61dd7e06", - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -221,8 +224,10 @@ }, { "cell_type": "code", + "execution_count": null, "id": "ac23c5d8fe923863", "metadata": {}, + "outputs": [], "source": [ "# model config\n", "wf = 'A'\n", @@ -263,37 +268,47 @@ " predicted_anomalies=prediction.predicted_anomalies,\n", " ignore_normal_index=True,\n", " )\n" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": null, "id": "240be4ff7c0b1325", "metadata": {}, + "outputs": [], "source": [ "care_score.get_final_score()" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", + "id": "5b4cf2cd5b2f9516", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "# Reproducing results from the Paper\n", "To reproduce the results from (https://doi.org/10.3390/data9120138), an additional filter is needed (though only for wind farm C):\n", "- determine cut-in and cut-off wind speeds by power curve analysis\n", "- Remove potentially anomalous data from the training data:\n", " - Remove rows where the wind speed is outside the normal operation range (below cut-in or above cut-off)\n", - " - Remove rows where the power is zero or near zero (e.g. $P < 0.01$)." - ], - "metadata": { - "collapsed": false - }, - "id": "5b4cf2cd5b2f9516" + " - Remove rows where the power is zero or near zero (e.g. $P < 0.01$).\n", + "\n", + "Note: The trained models may not reproduce the exact results reported in the paper due to random initialization, hardware differences, and random seeds. In practice, it is advisable to train each model 5–10 times and select the best-performing run." + ] }, { "cell_type": "markdown", + "id": "8feb0d8f0e917072", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "# CARE Score usage on other datasets\n", "\n", @@ -309,11 +324,7 @@ "- Calculate the CARE score `CAREScore.get_final_score`\n", "\n", "For each of these events, you need to be able to train a proper model (for example one large model or a model for each event). For the CARE2Compare dataset we assumed 1 year of training data with >=70% normal operation is enough to create a normal behavior model.\n" - ], - "metadata": { - "collapsed": false - }, - "id": "8feb0d8f0e917072" + ] } ], "metadata": { @@ -332,7 +343,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.11" + "version": "3.12.0" } }, "nbformat": 4, diff --git a/notebooks/PreDist/PreDist.ipynb b/notebooks/PreDist/PreDist.ipynb index f6b46dd..34ccd88 100644 --- a/notebooks/PreDist/PreDist.ipynb +++ b/notebooks/PreDist/PreDist.ipynb @@ -1,158 +1,61 @@ { "cells": [ { - "metadata": {}, "cell_type": "markdown", + "id": "b3569887686796a6", + "metadata": {}, "source": [ "# EnergyFaultDetector @ District Heating\n", "\n", "This notebook shows how to apply the EnergyFaultDetector on the PreDist dataset (available on [zenodo](https://doi.org/10.5281/zenodo.17522254)) and how to reproduce results from the accompanying paper (preprint available on [arXiv](https://doi.org/10.48550/arXiv.2511.14791))." - ], - "id": "b3569887686796a6" + ] }, { + "cell_type": "code", + "execution_count": 1, + "id": "a149ecfec1850ff7", "metadata": { "ExecuteTime": { "end_time": "2026-01-13T10:50:14.641401100Z", "start_time": "2026-01-13T10:50:07.635583200Z" } }, - "cell_type": "code", + "outputs": [], "source": [ "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "from sklearn.metrics import fbeta_score, precision_score, recall_score, ConfusionMatrixDisplay\n", "\n", + "from predist_utils import train_or_get_model, find_optimal_threshold, get_arcana_importances, calculate_earliness\n", + "\n", "from energy_fault_detector.evaluation import PreDistDataset\n", "from energy_fault_detector import Config\n", "from energy_fault_detector.utils.visualisation import plot_reconstruction\n", - "from energy_fault_detector.utils.analysis import create_events\n", - "\n", - "from predist_utils import train_or_get_model, find_optimal_threshold, get_arcana_importances, calculate_earliness" - ], - "id": "a149ecfec1850ff7", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WARNING:tensorflow:From C:\\Users\\croelofs\\PycharmProjects\\EnergyFaultDetector\\.venv\\Lib\\site-packages\\keras\\src\\losses.py:2976: The name tf.losses.sparse_softmax_cross_entropy is deprecated. Please use tf.compat.v1.losses.sparse_softmax_cross_entropy instead.\n", - "\n" - ] - } - ], - "execution_count": 1 + "from energy_fault_detector.utils.analysis import create_events" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "### Load the PreDist dataset", - "id": "5cab669e1b0c15d" + "id": "5cab669e1b0c15d", + "metadata": {}, + "source": [ + "### Load the PreDist dataset" + ] }, { + "cell_type": "code", + "execution_count": 2, + "id": "b3f587b734b87ccc", "metadata": { "ExecuteTime": { "end_time": "2026-01-13T10:50:14.704952800Z", "start_time": "2026-01-13T10:50:14.647830300Z" - } + }, + "scrolled": true }, - "cell_type": "code", - "source": [ - "dataset = PreDistDataset('./predist_data', download_dataset=False)\n", - "# Check events for manufacturer 1\n", - "dataset.events[1]" - ], - "id": "b3f587b734b87ccc", "outputs": [ { "data": { - "text/plain": [ - " substation ID Report date Problem EN \\\n", - "Event ID \n", - "1 10 2014-05-04 14:44:00 no DHW \n", - "3 12 2015-12-01 10:56:00 no heat \n", - "5 11 2018-11-23 08:30:00 no heat \n", - "6 21 2016-12-06 13:12:00 not enough heat \n", - "7 26 2020-06-13 10:38:00 no DHW \n", - "... ... ... ... \n", - "58 5 NaT NaN \n", - "59 22 NaT NaN \n", - "61 14 NaT NaN \n", - "66 19 NaT NaN \n", - "68 13 NaT NaN \n", - "\n", - " Event description EN \\\n", - "Event ID \n", - "1 No hot water. Actuator (DHW system) replaced. \n", - "3 Control parameters updated. \n", - "5 Pump settings updated. \n", - "6 The heaters are not getting warm enough. Suppl... \n", - "7 The needle valve was closed. Readjusted. \n", - "... ... \n", - "58 NaN \n", - "59 NaN \n", - "61 NaN \n", - "66 NaN \n", - "68 NaN \n", - "\n", - " Possible anomaly start Possible anomaly end Training start \\\n", - "Event ID \n", - "1 2014-05-03 16:00:00 2014-05-05 04:00:00 2012-03-28 09:00:00 \n", - "3 2015-11-29 12:00:00 2015-12-02 10:56:00 2015-03-01 00:00:00 \n", - "5 NaT 2018-11-26 09:56:59 2015-02-20 14:00:00 \n", - "6 NaT 2016-12-07 13:12:00 2015-11-30 09:00:00 \n", - "7 2020-06-12 12:00:00 2020-06-14 10:38:00 2018-10-18 13:00:00 \n", - "... ... ... ... \n", - "58 NaT NaT 2016-02-29 00:00:00 \n", - "59 NaT NaT 2018-06-21 10:00:00 \n", - "61 NaT NaT 2017-12-04 00:00:00 \n", - "66 NaT NaT 2015-09-15 09:31:00 \n", - "68 NaT NaT 2017-12-19 00:00:00 \n", - "\n", - " Training end efd_possible \\\n", - "Event ID \n", - "1 2014-04-20 14:44:00 True \n", - "3 2015-11-17 10:56:00 True \n", - "5 2018-11-09 08:30:00 True \n", - "6 2016-11-22 13:12:00 True \n", - "7 2020-05-30 10:38:00 True \n", - "... ... ... \n", - "58 2018-02-28 00:00:00 NaN \n", - "59 2019-01-31 00:00:00 NaN \n", - "61 2019-12-05 00:00:00 NaN \n", - "66 2017-06-14 00:00:00 NaN \n", - "68 2019-12-20 00:00:00 NaN \n", - "\n", - " Fault label \\\n", - "Event ID \n", - "1 Motorised control valve (primary side): Actuat... \n", - "3 Control unit: Incorrect parameterisation \n", - "5 Failure of the heating circuit pump \n", - "6 Control unit: Incorrect parameterisation \n", - "7 Incorrect setting of the differential pressure... \n", - "... ... \n", - "58 NaN \n", - "59 NaN \n", - "61 NaN \n", - "66 NaN \n", - "68 NaN \n", - "\n", - " Monitoring potential Event type Event end Event start \n", - "Event ID \n", - "1 3.4 anomaly 2014-05-04 14:44:00 NaT \n", - "3 4 anomaly 2015-12-01 10:56:00 NaT \n", - "5 3.8 anomaly 2018-11-23 08:30:00 NaT \n", - "6 4 anomaly 2016-12-06 13:12:00 NaT \n", - "7 3.1 anomaly 2020-06-13 10:38:00 NaT \n", - "... ... ... ... ... \n", - "58 NaN normal 2018-03-07 00:00:00 2018-02-28 \n", - "59 NaN normal 2019-02-07 00:00:00 2019-01-31 \n", - "61 NaN normal 2019-12-12 00:00:00 2019-12-05 \n", - "66 NaN normal 2017-06-21 00:00:00 2017-06-14 \n", - "68 NaN normal 2019-12-27 00:00:00 2019-12-20 \n", - "\n", - "[64 rows x 14 columns]" - ], "text/html": [ "
\n", "