# Online real-time robust framework for non-intrusive load monitoring in constrained edge devices

L.E. Garcia-Marrero, Eric Monmasson, G. Petrone

► To cite this version:

L.E. Garcia-Marrero, Eric Monmasson, G. Petrone. Online real-time robust framework for non-intrusive load monitoring in constrained edge devices. Applied Energy, 2025, 378, pp.124814. 10.1016/j.apenergy.2024.124814. hal-04850856

HAL Id: hal-04850856

https://cnrs.hal.science/hal-04850856v1

Submitted on 13 Dec 2025

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>
<figure><img src="image_2.png" /></figure>

<figure><img src="image_3.png" /></figure>

# Online real-time robust framework for non-intrusive load monitoring in constrained edge devices

L.E. Garcia-Marrero<sup>a,b,*</sup>, E. Monmasson<sup>b</sup>, G. Petrone<sup>a</sup>

## ARTICLE INFO

**Keywords:**

Non-intrusive load Monitoring (NILM)

Online energy disaggregation

Real-time energy disaggregation

Population-Based Incremental Learning (PBIL)

Constrained edge devices

## ABSTRACT

Real-time information on detailed power consumption can motivate users to make informed decisions to reduce their energy bills. In that sense, Non-Intrusive Load Monitoring (NILM) emerges as a cost-effective technique to achieve the previously mentioned benefits. This paper presents an online real-time robust NILM framework that only requires the aggregated active power, operates by updating the appliance's state probabilities sequentially, and uses this information to predict the power consumption of each monitored appliance. The framework primarily focuses on the seamless integration and practical deployment of a real-time NILM algorithm, operating at frequencies around 1 Hz, on constrained edge devices. Starting with detecting edges and the base load in real-time, the appliance's state probabilities are updated considering the possible presence of unknown loads. The power consumption of each appliance is then estimated by employing a modified Population-Based Incremental Learning algorithm (PBIL). Experiments on two publicly available datasets against state-of-the-art methods demonstrated its accuracy and robustness in the presence of unknown appliances. The real-time capabilities of the framework were verified through integration in a Home Automation framework running in a constrained edge device.

## 1. Introduction

The utilization of data collected from smart meters has shown substantial benefits in various aspects of grid operation and maintenance [1], including fault detection [2], load forecasting [3], and demand response [4]. In this sense, the analysis of detailed data on power consumption of loads and appliances is expected to enhance previously mentioned benefits and will play a critical role in the success of smart grid implementations [5].

Real-time, appliance-level feedback on energy consumption improves energy efficiency by allowing users to monitor individual devices and make immediate adjustments. This feedback helps users identify inefficient devices and optimize usage strategies, which can lead to significant energy savings [6]. Appliance-specific data not only enables more effective load scheduling but also increases user engagement, as users find this level of feedback more relevant and actionable compared to household-level data [7]. Additionally, this feedback enhances grid operations by providing granular data that improves load forecasting and demand-side management [8].

Non-Intrusive Load Monitoring (NILM) allows end-users and building owners to monitor the power consumption of a group of appliances

without the need to install individual smart meters/sensors for each appliance. Analyzing the aggregated consumption coming from only one smart meter, NILM aims to accurately estimate the power consumption at the appliance level. This approach was first described by Hart [9] and it is also referred to as load disaggregation or energy disaggregation.

Several approaches have been proposed to solve the NILM problem, with training-based algorithms being popular. Hidden Markov Models (HMM) and their extensions are training-based algorithms that build a probabilistic model of appliance states over time and then use this model to infer the operating states of the appliances [10–13]. A practical limitation of this approach is its high computational complexity. To overcome to some extent this, researchers have introduced procedures exploiting sparsity [10], employing Factorial Hidden Markov Model (FHMM) [11], additive FHMM (AFHMM) [12], Adaptive Density Peak Clustering FHMM [13], event-based classification combined with AFHMM [14]. However, these HMM techniques require either abundant submetered data from the test domain or long periods of unsupervised training to build the probabilistic models, thus, limiting a seamless practical integration.

<footnote><sup>a</sup> Dipartimento di Ingegneria dell'Informazione ed Elettrica e Matematica Applicata/DIEM, University of Salerno, Fisciano, 84084, Italy</footnote>

<footnote><sup>b</sup> Systèmes et Applications des Technologies de l'Information et de l'Energie laboratory, CY Cergy Paris University, Cergy-Pontoise, 95031, France</footnote>

<footnote>* Corresponding author at: Dipartimento di Ingegneria dell'Informazione ed Elettrica e Matematica Applicata/DIEM, University of Salerno, Fisciano, 84084, Italy.</footnote>

<footnote>E-mail address: lgarciamarrero@unisa.it (L.E. Garcia-Marrero).</footnote>
In recent years, Deep Learning techniques have become a common training-based choice among researchers, and approaches based on Convolutional Neural Networks (CNNs) [15], Recurrent Neural Networks (RNNs) [16], Long Short Time Memory (LSTM) [17] have been proposed in the literature. However, three main drawbacks limit the seamless practical applicability of these methods for real-time predictions. The first limitation concerns generalizability. It is reasonable to assume that submetered data may not be available in real-world test environments. Therefore, improving their ability to generalize is crucial for successful deployment. Recent studies [6,18] have highlighted that generalization to unseen sites remains a significant hurdle for state-of-the-art deep learning-based NILM models. This challenge arises from the diverse load characteristics and operating patterns across different locations, making it difficult for these models to adapt and perform accurately in new environments.

The second limitation is related to the explainability of NILM models [18]. Deep learning algorithms are inherently complex, often making their operations and decision-making processes difficult to interpret or replicate. Enhancing the transparency of NILM approaches could lead to a better understanding of their functionality, thus aiding in the refinement of models and identifying significant data features that influence decisions [18].

The last drawback is associated with specific resource constraints. As the variety of IoT services grows, multiple services running on the same hardware through a common software framework may become usual. Hence, there is a need to create lightweight and accurate models that can be seamlessly integrated into edge-constrained devices. Although several studies propose reduced models by compression or reduced architectures of neural networks [19–22], without significantly impacting accuracy, the achieved model size can still be prohibitive for constrained edge devices. Furthermore, the impact on the generalization capabilities of these lightweight models has not yet been thoroughly analyzed and validated.

In this context, a training-less solution holds practical significance for deploying NILM algorithms on edge devices. Another important factor to consider when designing NILM algorithms is the sampling frequency. High-frequency measurements capture features such as signal transients, harmonics, and V-I trajectories, which can enhance the accuracy of NILM methods [6,18]. However, advanced hardware is required, which leads to increased costs [6]. Given that low sampling frequencies (less than 100 Hz) are commonly found in standard smart meters, we deem a sampling frequency of no more than a few seconds appropriate to provide near-real-time feedback to users. In this regard, and adopting widely accepted guidelines for the development of NILM algorithms [23], we base the design of our NILM framework on the following assumptions:

1. The feature to be monitored is the active power with a sampling rate ranging from 0.125 to 1 Hz

2. The method should not involve significant occupant efforts for algorithm training (unsupervised or semi-supervised)

3. The algorithm needs to be computationally efficient and robust. The feedback to the user should be reported as near as possible to the real events in the building (near real-time capabilities)

4. The algorithm should be simple and efficient enough to implement in an edge device with limited resources (processing power and memory capacity). In this sense, we process only one power measurement at a time (online design)

5. The performance of the method must not deteriorate drastically as the subset of monitored appliances or the subset of not monitored appliances changes in the building (robustness)

## 1.1. Related research

Several approaches have been proposed for real-time NILM, with some focusing on high-frequency sampling [8,24–26], while others consider low-frequency sampling [10,22,27–30]. High-frequency sampling methods typically require an offline training phase, needing transient responses for each target appliance [8,24]. Similarly, many low-frequency approaches necessitate extensive training data and a pre-deployment training phase [10,22,27,28]. In contrast, some low-frequency, training-less methods assume prior knowledge of the average active power associated with each appliance state [29,30].

Training-Less NILM approaches are commonly divided into two main groups: state-based algorithms and event-based algorithms [18]. State-based methods represent each appliance operation using a finite state machine (FSM) with distinct state transitions. Inside this group, optimization-based algorithms, search for the global optimal state combination of appliances, either considering a time window or a unique time step.

Window-based optimization methods are often more accurate at the cost of increasing the computational complexity. In this category, integer programming (IP) solvers are a popular choice, and studies based on Aided Linear Integer Programming (AILP) [31,32], Mixed Integer Linear Programming (MILP) [33] and Mixed-Integer Nonlinear Programming [34,35] have been proposed in the literature. These approaches formulate NILM as a constrained optimization problem where the temporal linkage is preserved by imposing state transition constraints [34,35] or by a correction phase of the output of the IP solver [31]. The main practical limitation of these methods is their high computational complexity, especially if a resolution in the order of a few seconds is required, making its deployment difficult in an embedded system with low capabilities. Regarding unknown appliance's presence, a couple of papers [31,34] in this research group attempt to consider this issue by minimizing the number of active appliances in each time step. Although useful, this heuristic does not always hold [31], and a complement with an event detection phase could improve its effectiveness in the presence of unknown loads.

Those optimization methods considering a unique time step are often better suited for real-time applications because of the lower-size optimization problem. In [29], the authors propose a modified cross-entropy method to solve a penalty-based optimization problem that considers dependency between measurements. In [30] a multiobjective formulation is proposed and solved with the NSGA-II algorithm that penalizes changes between consecutive events. Although these algorithms are simple, online, and can be used in real-time, not relying on an event detection phase makes them susceptible to unknown appliances. Moreover, the optimization problem at hand is dynamic by nature. However, existing algorithms typically restart the search from scratch for each timestep or time window, which may not be optimal for real-time predictions. To the best of the authors' knowledge, no optimization-based algorithm has yet proposed a method to effectively address the intrinsic dynamics of the problem by leveraging previous solutions. This approach would allow the search to begin from a partially converged population, potentially enhancing computational efficiency.

On the other hand, event-based methods work by detecting edges on the aggregated power consumption and assigning each extracted feature to one appliance state transition. In this research group, several methods have been proposed, including those based on Graph Signal Processing (GSP) [36,37], subtractive clustering [38], non-negative tensor factorization [39], and the balanced window technique (BW) [40]. Unlike optimization-based methods, event-based approaches are less susceptible to the presence of unknown appliances. However, these methods are vulnerable to measurement noise and outliers. Typically, these approaches disaggregate appliances one at a time and often fail to verify whether the sum of the disaggregated loads approaches the actual measured total [38,41]. This oversight can lead to significant load over/underestimation [39]. To overcome this, paper [41] proposes
a general post-processing optimization phase based on a regularization term. However, the regularization term, used as a weight for the confidence in the original output, relies heuristically on the mean power consumption of each appliance [41]. This heuristically-based regularization term has the drawback that for high consumption loads that are easy to disaggregate for an event-based method (ex. Kettle), the algorithm will put more weight in the optimization-based term, which can result in a wrong final prediction. In this sense, event-based algorithms that provide insights into the confidence of their output, are of interest, especially for real-time applications.

## 1.2. Our contribution

This work introduces the O2RE framework: a novel Online, Real-time, Robust, and Edge driven NILM framework. The framework's main focus is the practical deployment of a real-time NILM algorithm at frequencies around 1 Hz in a constrained edge device. In this sense, we also consider the possible contribution of unknown loads given in the form of FSM or constantly-on appliances.

The proposed framework evolves a dynamic structure $S_p$, where $S_{p,j}$ denotes the probability that appliance $i$ is in state $j$. $S_p$ is sequentially updated upon detecting a significant edge (event-based) by a novel dynamic programming algorithm. This way, $S_p$ efficiently preserves historical information and temporal linkages in a compact storage format. Unlike existing algorithms [29,30], which assume the previous sample state is precisely known, our method does not rely on this assumption, providing more accurate handling of temporal dependencies.

In addition, this architecture benefits from $S_p$ functioning as a discrete probability distribution, which, when sampled, is likely to yield high-quality solutions with high probability. This characteristic enhances NILM state-based optimization algorithms by initiating the search process from a partially converged population, instead of restarting the search for each time step. Furthermore, as $S_p$ is the result of evolving an event-based NILM method over time, by initiating the search in $S_p$, the drawback of state-based algorithms associated with the possible presence of unknown appliances is expected to be eliminated.

To determine the operating state of each appliance, $S_p$ is integrated into a state-based optimization algorithm, specifically the Population-Based Incremental Learning (PBIL) algorithm. This algorithm improves the efficiency of the optimization process compared to traditional metaheuristics because it evolves a single probability vector. The probability vector is updated depending on the performance of the sampled solutions, thus, eliminating the computational burden associated with managing multiple individual solutions usually found in other metaheuristics like Genetic Algorithms.

To summarize, the specific contributions of this work are detailed in the following:

1. A training-less probabilistic model for power state transitions in FSM appliances is proposed. The model only depends on the average power of each appliance state, and two setting parameters ($\sigma_{\Delta P}^2$ and $\delta$) common to all the appliances. Parameter $\sigma_{\Delta P}^2$ is related to the variance of state transitions and $\delta$ is a robust parameter to account for the presence of unknown appliances

2. Building on the probabilistic model, we have developed a dynamic programming algorithm that updates the state probability of each appliance sequentially. This algorithm is designed to be lightweight, running only when a significant edge is detected, enhancing efficiency in both storage and computation time

3. A lightweight online algorithm is proposed to estimate the total consumption of always-on appliances (base load). By accurately characterizing the base load, algorithms can effectively differentiate it from monitored appliance-specific states, improving the overall performance of NILM systems. Moreover, the user must be aware of the global consumption of these constantly-on devices

4. State probabilities and base load are integrated into a Population-Based Incremental Learning algorithm to determine the most likely state of each appliance at each time step. The idea is to profit from the advantages of combinatorial optimization-based approaches while accounting for the output of event-based algorithms (in the form of state probabilities). Moreover, this architecture enhances optimization algorithms by improving performance when initiating searches from a partially converged population

5. The framework's accuracy and robustness are demonstrated by comparison with state-of-the-art training-less algorithms and its real-time capabilities are revealed through integration in a Home Automation framework running in a constrained edge device

To the best of our knowledge, no solution exists in NILM literature integrating into a unique framework the advantages of event-based and optimization-based approaches in a storage, time-efficient, and robust solution capable of handling real-time frequencies of the order of 1 Hz in constrained edge devices. The rest of the paper is organized as follows. In Section 2 important definitions are established. Section 3 presents the high-level architecture of the O2RE framework following a modular structure. Section 4 outlines the theory, methods, and implementation details for each framework module. Section 5 shows the performance evaluation, comparison with other state-of-the-art algorithms, and real-time capabilities verification, and Section 6 concludes the paper.

## 2. Preliminaries

The objective of the NILM problem is to generate accurate estimates [$\hat{p}_i(t), ..., \hat{p}_N(t)$] of the real power consumption [$p_1(t), ..., p_N(t)$] of N monitored appliances at time $t$ with the only information of the aggregated power consumption $P(t)$. The aggregated power consumption in this work is defined as follows:

$$P(t) = \sum_{i=1}^{N} p_i(t) + B(t) + \eta(t) \quad (1)$$

The value of $P(t)$ is composed of N appliance-level signals $p_i(t)$, the base load $B(t)$ (consistent power consumption contributed by unknown appliances operating in a steady state), and a residual term $\eta(t)$. The residual term comprises (measurement) noise and other loads that are not considered in the N monitored appliances. Here, we are going to consider appliances represented with a Finite State Machine (FSM) model (Fig. 1). In this formulation, each appliance is modeled based on a set of discrete states, and a set of allowed state transitions. Obtaining a complete FSM model (including statistical information) often requires a previous training phase, but the minimum necessary information, that is the average active power of each appliance state, only requires a few full operation cycles of each appliance or information in the appliance user manual when available.

If we define $P_{i,j}$ as the nominal power of appliance $i$ when it is working in the state $j$ ($0 \le j \le M_i$) ($M_i$ is the number of “On” states in appliance $i$), then the estimated power $\hat{p}_i(t)$ of appliance $i$ at any moment takes one of the discrete values {$P_{i,0}, P_{i,1}, ..., P_{i,M_i}$}. In this way, the problem can be defined as finding the value of the operating state indicator vector $S$ that better represents the real behavior of the appliances. Here $S_{i,j}$ is defined as follows:

$$S_{i,j} = \begin{cases} 1 & \text{if appliance } i \text{ is operating in state } j \\ 0 & \text{otherwise} \end{cases} \quad (2)$$

S.T:

$$\sum_{j=0}^{M_i} S_{i,j} = 1 \quad \text{for each appliance } i \quad (3)$$
<figure><img src="image_4.png" /><figcaption>Fig. 1. Finite State Machine Model. The diagram shows the power consumption for each state (P) and the probability ($S_p$) of being in that state at a given time t. Transitions between states are labeled with power differences ($\Delta P$).</figcaption></figure>

Constraint (3) implies that any appliance always operates exactly in one of the given states. Eq. (1) can now be rewritten in terms of $S_{i,j}$ as follows:

$$P(t) = \sum_{i=1}^{N} \sum_{j=0}^{M_i} S_{i,j}(t)P_{i,j} + B(t) + e(t) \quad (4)$$

Here $e(t)$ is the error term that includes $\eta(t)$ (Eq. (1)) plus an additional error due to the estimation of $p_i(t)$. A direct criterion for estimating $S_{i,j}$ is the minimization of the absolute value of the error term $|e(t)|$:

$$|e(t)| = |P(t) - B(t)| - \sum_{i=1}^{N} \sum_{j=0}^{M_i} S_{i,j} P_{i,j} \quad (5)$$

As stated in [9], this criterion for estimating $S_{i,j}$ has several difficulties. The first drawback is associated with the fact that if (5) is used in the presence of unknown loads, it would attempt to describe their behavior as a combination of the known appliance loads. Another problem is that the solution that (5) provides can be very inappropriate since a small change in the measured $P(t)$ would often be associated with the change of state of many appliances at the same time [9]. This behavior is against the Switch Continuity Principle [9], which states that in a very small time interval, we expect the number of appliances that change state to be usually zero or one, and very rarely more than one in a typical load. Researchers commonly use minimization of (5) in combination with the Switch Continuity principle to design their state-based algorithms [29,30].

An important discrimination feature for NILM algorithms using sampling frequencies around 1 Hz is the power difference between continuous steady states. Let $\bar{P}_{\text{curr}}$ represents the power value of the current steady state and $\bar{P}_{\text{prev}}$ represents the previous steady-state value. Then we define the edge E as:

$$E = \bar{P}_{\text{curr}} - \bar{P}_{\text{prev}} \quad (6)$$

The frequency considered allows us to reasonably assume that the edge E is caused by the change in the state of exactly one appliance. Based on this assumption, E can be used as a discrimination feature. Due to transient spikes and signal fluctuations, the reliability of this feature depends heavily on the steady-state detection method employed.

### 3. Proposed framework: High-level architecture

The proposed framework evolves a dynamic structure $S_p$, where $S_{p,i,j}$ denotes the probability that appliance i is in state j. Unlike a fixed-dimension matrix, $S_p$ supports a variable number of states per appliance. $S_p$ is sequentially updated upon detecting a significant edge (event-based) or inconsistencies with the total aggregated power. After updating $S_p$ an appliance might still be associated with multiple states with varying probabilities. To define a unique state for each appliance, $S_p$ is integrated into a state-based optimization algorithm by employing the total matching criterion and possibly other additional criteria.

$S_p$ efficiently preserves historical information and temporal linkages in a compact storage format. This also represents an advantage over existing algorithms [29,30], where the temporal linkage is based on the assumption that the previous sample state is exactly known, and an incorrect prediction impact negatively the future predictions. In addition, this architecture benefits from $S_p$ functioning as a discrete probability distribution, which, when sampled, is likely to yield high-quality solutions with high probability. This characteristic enhances NILM state-based optimization algorithms by initiating the search process from a partially converged population, instead of restarting the search for each time step.

The framework optionally leverages information about the transition probabilities. Transition probability is the probability of observing a transition from state j to state k in appliance i at a given time t. Although the availability of transition probabilities is not required for the algorithm's functioning, it is expected to enhance its accuracy, especially for appliances with similar power levels. However, this information requires a training phase or a general model of the monitored appliances. In addition, the framework is robust to the presence of unknown appliances. Each time an edge is detected it is considered the possibility of an unknown load causing the edge. Based on its characteristics, Online, Real-time, Robust, and Edge driven, we will refer to it as the O2RE framework. The proposed O2RE framework (Alg. 1) comprises four principal modules:

**Module 1: Edge Detection and Base Load Detection.** This module detects events and steady states from the aggregated power profile. It also includes a base load detection procedure that identifies consistent power consumption from appliances operating in a steady state. The detection of steady states isolates periods with minimal power variation. Edge detection identifies significant changes (edges) in the aggregated power profile, potentially indicating appliance state changes (Section 4.1).

**Module 2: State Probabilities Update.** If a significant edge is detected, the state probabilities $S_p$ are updated based on the edge's value, and, if available, additional information such as transition probabilities. However, it is also important to consider that the detected edge could be caused by an unknown load, which refers to a non-monitored appliance included in the aggregated power (Section 4.2).

**Module 3: State Probabilities Tuning.** In the tuning phase, the framework ensures that the state probabilities are coherent with additional criteria like the current aggregated power in a steady state. In this phase, the state probabilities $S_p$ are updated to fulfill some constraints while minimizing the distance between the initial and updated state probabilities (Section 4.3).

**Module 4: States Prediction.** In this phase, the framework combines information on the state probabilities $S_p$ with the total matching criterion and possibly other additional criteria, to predict the most likely state for each appliance. This step involves a state-based optimization algorithm (Section 4.4).
**Algorithm 1 O2RE Framework**

1: //Initialization
2: $S_p \leftarrow InitializeStateProb()
3: $S \leftarrow None \quad \triangleright$ Operating state indicator vector (Eq. (2))
4: $B \leftarrow \infty \quad \triangleright$ B represents the base load
5: for each $t$ do
6:     //Edge and Base load detection (Module 1)
7:     $\bar{P}_{\text{curr}} \leftarrow \bar{P}_{\text{prev}} \leftarrow UpdateSteadyStates() \quad \triangleright$ Eq. (7) and (8)
8:     $E \leftarrow \bar{P}_{\text{curr}} - \bar{P}_{\text{prev}}$
9:     $B \leftarrow UpdateBaseLoad()
10:    //State Probabilities Update (Module 2)
11:    state \_prob \_updated \leftarrow False
12:    if $|E| > \theta$ then
13:        $S_p \leftarrow UpdateStateProb()
14:        state \_prob \_updated \leftarrow True
15:    end if
16:    $\mathbb{E}[P] \leftarrow \sum_{i=1}^{N} \sum_{j=0}^{M_i} S_{P_{i,j}} \cdot P_{i,j} \quad \triangleright$ Expected Value of predicted power
17:    $P_{\text{fluc}} \leftarrow \max(\bar{P}_{\text{curr}} - B, 0)$
18:    //State Probabilities Tune (Module 3)
19:    if $\mathbb{E}[P] > P_{\text{fluc}}$ then
20:        $S_p \leftarrow TuneStateProb()
21:        state \_prob \_updated \leftarrow True
22:    end if
23:    //States Prediction (Module 4)
24:    if state \_prob \_updated == True or S is None then
25:        $S \leftarrow PredictStates()
26:    end if
27:    output S as the prediction for time $t$
28: end for
$\leftarrow$: Assignment, //: Section comments, \triangleright: Line Comments

## 4. Low level design

In this section, the architecture exposed above is explained in detail through the framework modules.

### 4.1. Module 1: Edge detection and base load detection

#### 4.1.1. Edge detection

In practical scenarios, load meter measurements are prone to the presence of sensor noise, transient spikes, and signal fluctuations around the mean operating power of an appliance. The edge detection algorithm starts by identifying if the system is likely to be in a steady state considering the power grid noise $\sigma_g^2$ variance. For this task, we use the three-point method [38] which is simple and effective. Consider the current aggregated sample $P(t)$. The three-point method calculates the local average power $\mu_P(t)$, and the local deviation $\sigma_P^2(t)$ around $\mu_P(t)$.

$$ \mu_P(t) = \frac{1}{3} \sum_{i=1}^{3} P(t - i\Delta t) \qquad (7) $$

$$ \sigma_P^2(t) = \frac{1}{3} \sum_{i=1}^{3} (P(t - i\Delta t) - \mu_P(t))^2. \qquad (8) $$

If $\sigma_P(t) < \sigma_g$, then the power is likely to be in a steady state, and we update the current and previous steady states: $\bar{P}_{\text{prev}} = \bar{P}_{\text{curr}}; \bar{P}_{\text{curr}} = \mu_P(t)$. This is the basis of the function **UpdateSteadyStates** in Algorithm 1. Then, we identify significant edges when Eq. (6) provides $|E| > \theta$, where $\theta$ is a significance threshold holding the condition $\theta \ge \sigma_g$.

#### 4.1.2. Base load detection

Accurate estimation of the base load is also important for enhancing the accuracy of NILM algorithms, particularly those employing state-based approaches. The base load represents the consistent electrical

consumption of appliances operating in a steady state. By accurately characterizing the base load, algorithms can effectively differentiate it from monitored appliance-specific states, improving the overall performance of NILM systems. In this work, the base load is estimated sequentially as shown in Algorithm 2.

**Algorithm 2 UpdateBaseLoad() function in Alg. 1**

1: $\alpha \leftarrow \text{User-defined value}$ \quad \triangleright$ Set a value in the range [0, 1]
2: if $P(t) \le B$ then
3:     $B \leftarrow P(t)$
4: else
5:     $\lambda \leftarrow \alpha \cdot \left(\frac{B}{P(t)}\right)^{(1-\alpha)}$
6:     $B \leftarrow B \cdot (1 - \lambda) + P(t) \cdot \lambda$
7: end if
8: return B

Algorithm 2 estimates the minimum value in a sliding window by using only the current measurement and stored past information. Classical algorithms for calculating exactly the minimum in a sliding window require space complexity proportional to the window size in the worst case. We propose an $O(1)$ space complexity approximation algorithm. The algorithm receives a tunable parameter $\alpha$, which could be interpreted as $\alpha = \frac{1}{\text{window size}}$, it lies in the range [0,1]. By iteratively updating the base load estimation, the algorithm implicitly tracks the minimum power consumption within the sliding window. The estimated base load adapts to the fluctuations in power consumption and provides a dynamic estimate of the minimum value observed within the recent history of measurements.

In each step, the algorithm updates the value of the base load depending on the current power measurement $P(t)$. When $P(t)$ is less than or equal to the base load it is trivial to equal it to the current value of $P(t)$. Otherwise, the value of the base load is increased taking into account how far is the current measurement from the base load, and the adjustable parameter $\alpha$. Intuitively, if $P(t)$ is much larger than the base load, it is less probable that it becomes the minimum value in a window. On the other hand, when the window size is approaching 1 ($\alpha$ approaching 1) the probability of $P(t)$ becoming the next minimum increases. On the contrary, if the window size is approaching infinity ($\alpha$ approaching 0), the algorithm provides the minimum value found in all previous measurements. Setting the tunable parameter $\alpha$ involves balancing responsiveness to recent data against the smoothness of the estimation over a longer period. Assuming that the constantly-on devices remain the same for a long time and based on the experience of experimental tests, we consider a good tradeoff the interval, $1 \times 10^{-6} \le \alpha \le 1 \times 10^{-5}$, for sampling frequencies around 1 Hz.

### 4.2. Module 2: State probabilities update

In this section we present the basis of the function **UpdateStateProb** in algorithm 1.

#### 4.2.1. Probabilistic model for power state transitions in FSM appliances

The active power in each state of FSM appliances cannot be considered constant. Active power can fluctuate due to changes in supply voltage and variations in load impedance [42]. Due to the large number of uncertainties, and provided that the sources of uncertainty are independent with finite variance it is reasonable to assume a Gaussian distribution for samples with large statistics. In [42], by assuming a Gaussian distribution for the grid voltage and conductance, is found a dependency of the active power variance with its expected value, and it is proposed a log-transformation in order to represent the transformed active power with a Gaussian distribution and remove this dependency. In this paper, we will consider this transformation as follows. If the random fluctuations of the power transition in load $i$ from state $j$ to state $k$ is represented with the random variable $\Delta P_{i,j,k}$, we define the transformed random variable $\Delta \bar{P}_{i,j,k}$ as:
<figure><img src="image_5.png" /><figcaption>Fig. 2. Example of the likelihood for four possible state transitions. For the edge $E = 250$ W, the highest likelihood is associated with the appliance transition from 0 to 230 W that, among the other possible state transitions and the unknown transition reported in the figure, is the more likely to represent the power variation $E$.</figcaption></figure>

$$ \Delta \tilde{P}_{i,j,k} = \operatorname{sgn}(\Delta P_{i,j,k}) \cdot \ln(|\Delta P_{i,j,k}|) \quad (9) $$

$$ \mu_{\Delta \tilde{P}_{i,j,k}} = \operatorname{sgn}(P_{i,k} - P_{i,j}) \cdot \ln(|P_{i,k} - P_{i,j}|) \quad (10) $$

$$ \Delta \tilde{P}_{i,j,k} \sim \mathcal{N}(\mu_{\Delta \tilde{P}_{i,j,k}}, \sigma_{\Delta \tilde{P}}^2) \quad (11) $$

Where sgn(.) is the sign of the given argument. Here we are assuming $\Delta \tilde{P}_{i,j,k}$ to be normal distributed with mean $\mu_{\Delta \tilde{P}_{i,j,k}}$ and variance $\sigma_{\Delta \tilde{P}}^2$. Please note that the value of $\mu_{\Delta \tilde{P}_{i,j,k}}$ only depends on the average power of the appliance states. On the other hand, we consider a fixed value of the variance $\sigma_{\Delta \tilde{P}}^2$ and this is a tunable parameter of the algorithm. Is important to note that a variance depending on the appliance may increase the accuracy of the method, but in order to retain the simplicity of the algorithm we consider using a single fixed value in our model. Details concerning the value of this parameter are provided in the experimental section of this paper. Eqs. (9)–(11) are important to estimate the likelihood of observing a detected edge $E$ given a power transition in load $i$ from state $j$ to state $k$.

### 4.2.2. Likelihood calculation given an appliance state transition

Once an edge $E$ is detected, we are interested in assigning a likelihood value $L(E|T_{ijk})$ to each appliance state transition $T_{ijk}$. Considering the model explained before (9)–(11) and normalizing each distribution to the standard normal distribution $N(0, 1)$ ($\tilde{\chi} = \frac{x-\mu}{\sigma}$) we obtain:

$$ x_{ijk} = \frac{\tilde{E} - \mu_{\Delta \tilde{P}_{ijk}}}{\sigma_{\Delta \tilde{P}}} \quad (12) $$

Where:

$$ \tilde{E} = \operatorname{sgn}(E) \ln(|E|) \quad (13) $$

In this way, by evaluating $x_{ijk}$ in the pdf function of the standard normal distribution, we calculate the likelihoods:

$$ L(E|T_{ijk}) = \frac{1}{\sqrt{2\pi}} e^{-\frac{x_{ijk}^2}{2}} \quad (14) $$

### 4.2.3. Likelihood of unknown state transition

To be realistic, it is considered that unknown loads could exist in measured aggregated power, and therefore, it could be the case that the change $E$ is due to an unknown state transition and not due to a transition in the state of any of the $N$ monitored appliances. To assign a likelihood of the unknown transition, this work exploits the idea of an improper constant density over the whole Euclidean (Eq. (15)) which is often used in outliers clustering [43,44].

$$ L(E|\text{UnkTrans}) = \delta \quad (15) $$

The constant $\delta > 0$ is the improper constant density, and it is one of the settable parameters of the algorithm. The idea of the method is that transitions that lie in low-density areas ($L(E|T_{ijk}) < \delta$) are unlikely to explain the edge $E$. In other words, if $L(E|T_{ijk}) < \delta$, is more likely that edge $E$ be due to a different transition. The reader is referred to Fig. 2 for a visual example of the likelihood calculation.

### 4.2.4. Conditional probability calculation

Once the likelihoods are calculated, we assign a probability to each possible event conditioned on the value of the edge $E$. The events here are all the possible state transitions plus the unknown transition event. Defining then, $Pr(T_{ijk}|E)$ as the probability that the state transition in the appliance $i$ from the state $j$ to the state $k$ is causing the edge $E$, $Pr(\text{UnkTrans}|E)$ as the probability that an unknown load causes the change $E$, and employing Bayes' theorem we can write:

$$ Pr(T_{ijk}|E) = \frac{L(E|T_{ijk})Pr(T_{ijk})}{\sum_{\substack{\forall i' j' k' \\ j' \neq k'}} L(E|T_{i' j' k'})Pr(T_{i' j' k'}) + UTT} \quad (16) $$

Where $UTT = L(E|\text{UnkTrans}) \cdot Pr(\text{UnkTrans})$ is the unknown transition term and $Pr(T_{ijk})$ and $Pr(\text{UnkTrans})$ are the prior probability terms. In (16) the subscripts $i'$, $j'$, $k'$ move on all appliances, and for all the states transitions. It can be noted that the denominator in (16) is a direct application of the Law of Total Probability, since the state transitions and the unknown transition events are jointly exhaustive and mutually exclusive. In Sections 4.2.2 and 4.2.3 it is explained how to calculate the likelihoods, Eqs. (14) and (15), the terms $L(E|T_{ijk})$ and $L(E|\text{UnkTrans})$ in (16) respectively. The prior probability terms $Pr(T_{ijk})$ and $Pr(\text{UnkTrans})$, which represent the unconditioned probabilities for each state transition and the unknown state transition respectively, are important to distinguish similar loads. In general, accurately estimating these terms requires a prior training phase. Information about these terms is important to enhance the accuracy of the algorithm for similar loads, but in case this information is not available, the terms $Pr(T_{ijk})$ and $Pr(\text{UnkTrans})$ can be fixed to the central probability vector. As a consequence, the starting values for $Pr(T_{ijk})$ and $Pr(\text{UnkTrans})$ can be set to $\frac{1}{M+1}$, where $M$ is the number of possible state transitions in all the appliances. That means that initially, all the events are equally probable. From now we will refer to this as the minimum information setting.

### 4.2.5. Updating sequentially the appliance state probabilities

We propose a recursive algorithm to update the probability of one appliance being in one certain state. Before, we defined $S_{P_{i,j}}$ as the probability of appliance $i$ operating in state $j$, then, after an edge is detected, these probabilities are updated by using the conditional probabilities $Pr(T_{ijk}|E)$ previously calculated, assuming that the edge $E$ can only be caused by exactly one change in the appliance state transition (Switch Continuity Principle) or it is caused by other unknown transition. The last cause implies that the appliance does not change state in the current time step. In (17) is shown the equation to calculate the updated state probabilities.

$$ S'_{P_{i,j}} = \left[ \sum_{j \neq k} Pr(T_{ijk}|E) \cdot S_{P_{i,k}} \right] + \left[ (1 - \sum_{j \neq k} Pr(T_{ijk}|E)) \cdot S_{P_{i,j}} \right] \quad (17) $$

The first addend in Eq. (17) calculates the probability of a state change in the appliance $i$ to the state $j$ from all possible state $k$. The second addend of (17) calculates the probability of no change in the appliance $i$ from the state $j$. Then by simply setting $S_{P_{i,j}}$ to $S'_{P_{i,j}}$ we store in $S_{P_{i,j}}$ the updated state probabilities.
### 4.3. Module 3: State probabilities tuning

Up to now, the state probabilities variable relies only on the edge detection phase, thus, a considerable difference in a detected edge from its expected value can negatively impact the accuracy of the method. As an example, consider that the rising edge of an appliance is detected correctly but the corresponding falling edge is detected with a significantly different value than expected. In that case, the edge could be treated as coming from an unknown load, and the appliance would wrongly remain in an on-state.

The tuning phase aims to maintain $S_p$ robust to anomalous cases as previously exposed. In this paper, we consider that $S_p$ needs to be tuned when the expected value of power $\mathbb{E}[P]$ is greater than the fluctuating power $P_{fluc}$. Here, we define $P_{fluc}$, as the maximum between zero and the difference between the current steady state $\vec{P}_{cur}$ and the base load $B$. In other words, $P_{fluc}$ is the part of the total power that is not constant (fluctuating) and is expected to integrate all FSM appliances.

As we are assuming that the appliances are independent, the expected value of power can be defined as

$$ \mathbb{E}[P] = \sum_{i=1}^{N} \sum_{j=0}^{M_i} S_{P_{i,j}} \cdot P_{i,j} \quad (18) $$

In that sense, if $\mathbb{E}[P] > P_{fluc}$, is an indication that we are over-estimating the power and some appliances can result wrongly in an on-state. Then we adjust $S_p$ to ensure that $\mathbb{E}[P] \le P_{fluc}$ while minimizing the distance to the original $S_p$. As a measure of distance, we consider the relative entropy [45] between the original and updated $S_p$. To solve the resultant convex-constrained optimization problem, the CVXPY package is used [46,47]. Analyzing the opposite case, if a rising edge is not correctly detected, the appliance would remain in an incorrect off state and we may underestimate the power consumption. It could be reasonable to set a minimum power $P_{min}$ and impose another constraint in the way $\mathbb{E}[P] > P_{min}$. Considering that the on-time of most consuming FSM appliances is rather short, and setting a meaningful $P_{min}$ could be difficult, we decided not to use a constraint of this type in this work. Another constraint considering a maximum on-time for each appliance can also be used as a complement.

### 4.4. Module 4: States prediction

After updating the probabilities of different appliance states, uncertainty often persists, indicating that an appliance could still be associated with multiple states, each with varying probabilities. This results in a higher entropy scenario, where an exact operating state for some appliances remains less predictable. This step aims to converge toward lower entropy state probabilities where each appliance adopts a singular state with a probability near 1. It is also an opportunity to use criteria not employed in the steps before, like the Total Matching Criterion. We propose a modified Population-Based Incremental Learning algorithm (PBIL) [48] for this step.

#### 4.4.1. PBIL algorithm

PBIL algorithms, first introduced by Baluja [48] as an abstraction of genetic algorithms (GAs), explicitly maintain the statistics contained in the population [49]. Traditional GAs mimic natural evolution through selection, crossover, and mutation operators applied to individual candidates. In contrast, PBIL evolves a probability vector $\vec{Pr} = [Pr_1, ..., Pr_N]$ ($N$ is the length of the vector) to represent the likelihood of different traits contributing to high-quality solutions. The standard PBIL algorithm was designed for binary vector encoding but can be extended to consider integer vector encoding. In this case, the probability vector is defined as: $\vec{Pr} = [\vec{Pr}_1, ..., \vec{Pr}_N]$, where $\vec{Pr}_i =$

$[p_1, ..., p_{M_i}]$ ($M_i$ is the length of the vector $\vec{Pr}_i$), and $\sum_{j=1}^{M_i} p_j = 1$. PBIL is an iterative algorithm in which a set pop of $S_z$ solutions is sampled from the probability vector $\vec{Pr}$ each iteration. Then, the probability vector $\vec{Pr}$ is learned toward the best sample $\vec{B}$ in pop, according to the problem-specific fitness function. To maintain diversity, a mutation process is carried out, learning the vector $\vec{Pr}_i$ towards a neutral vector $\vec{M}_i$ with a certain probability $\vec{p}_m$, and the cycle is repeated. As the iterations increase, each element in $\vec{Pr}_i$ moves from their initial values towards either 0.0 or 1.0 (vector $\vec{Pr}_i$ and as a consequence $\vec{Pr}$ converge to a lower entropy vector). The search process concludes when the fulfillment of a certain condition, such as reaching the predefined maximum iteration count or achieving convergence of the probability vector is reached.

#### 4.4.2. PBIL for appliance states prediction

Here we consider the Total Matching Criterion and the state probabilities $S_p$ as the bases for the fitness function. The first criterion considered is the minimization of $|e(t)|$ in (5). The second criterion is the maximization of the probability of a given solution $S$. As we are assuming that appliances are independent, this probability can be defined as $Pr = \prod_{i=1}^{N} [\sum_{j=0}^{M_i} S_{i,j} \cdot S_{P_{i,j}}]$. An equivalent computationally robust formulation of this criterion is the minimization of minus the logarithm of the probability (19):

$$ -\ln(Pr) = -[\sum_{i=1}^{N} \ln(\sum_{j=0}^{M_i} S_{i,j} \cdot S_{P_{i,j}})] \quad (19) $$

To choose the best sample from the population pop, we define two ranking arrays based on separate criteria: rank_e and rank_p. Specifically,

* rank_e[i] denotes the rank of the i-th sample pop[i] when the population is sorted by the first criterion in ascending order.

* rank_p[i] denotes the rank of pop[i] when sorted by the second criterion in ascending order.

The best sample $\vec{B}$ from the population is identified by selecting the sample pop[i] that minimizes the maximum rank value between the two criteria for each sample. Formally, this can be expressed as:

$$ \vec{B} = pop[i] \quad \text{where} \quad i = \arg\min_{j} \max(rank_e[i], rank_p[i]) \quad (20) $$

Algorithm 3 presents the pseudocode for the state prediction module, which represents the base of the function PredictStates in Algorithm 1. One significant advantage of Algorithm 3 is initiating the search process from a partially converged probability vector $S_p$ (Algorithm 3 line 2). This initialization strategy allows the algorithm to bypass the initial exploratory phase required in random initialization. Consequently, this approach reduces the number of generations required to achieve convergence, enhancing the computational efficiency of state-based optimization NILM algorithms. Moreover, as $S_p$ is the result of evolving an event-based NILM method over time, by initiating the search in $S_p$, the drawback of state-based algorithms associated with the possible presence of unknown appliances is expected to be eliminated.

The choice of PBIL improves the efficiency of the optimization process compared to traditional metaheuristics because PBIL evolves a single probability vector. The probability vector is updated depending on the performance of the sampled solutions, thus, eliminating the computational burden associated with managing multiple individual solutions usually found in other metaheuristics like Genetic Algorithms. This makes PBIL particularly advantageous for scenarios requiring efficient computation and scalability.
**Algorithm 3 PBIL for appliance states prediction**

1: **Initialize:** Sample size $S_z$, learning rate $\lambda$, mutation rate $p_m$, maximum generations $G$
2: $\vec{P}_{r_i} \leftarrow [S_{P_i,0}; \dots; S_{P_i,M_i}]$, for each appliance $i$ ▷ Initialization
3: **for** $g \leftarrow 1$ to $G$ **do**
4: &nbsp;&nbsp;&nbsp;&nbsp;Generate a set pop of $S_z$ samples from $\vec{P}_r$
5: &nbsp;&nbsp;&nbsp;&nbsp;Set $\vec{B}$ to the best sample in pop (See section 4.4.2)
6: &nbsp;&nbsp;&nbsp;&nbsp;**for** $i \leftarrow 1$ to $N$ **do** ▷ Learn $\vec{P}_r$ towards $\vec{B}$
7: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$$ \vec{P}_{r_i} \leftarrow (1 - \lambda) \cdot \vec{P}_{r_i} + \lambda \cdot \vec{B}_i $$
8: &nbsp;&nbsp;&nbsp;&nbsp;**end for**
9: &nbsp;&nbsp;&nbsp;&nbsp;**for** $i \leftarrow 1$ to $N$ **do** ▷ Mutate $\vec{P}_r$
10: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**if** rand([0, 1]) < $p_m$ **then**
11: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$$ \vec{P}_{r_i} \leftarrow (1 - \lambda) \cdot \vec{P}_{r_i} + \lambda \cdot \vec{M}_i $$
12: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**end if**
13: &nbsp;&nbsp;&nbsp;&nbsp;**end for**
14: **end for**
15: $S_{i,j} \leftarrow 0$ for each appliance $i$ and state $j$
16: $\text{selected\_state}_i \leftarrow \text{argmax}(\vec{P}_{r_i})$ for each appliance $i$
17: $S_{i,\text{selected\_state}_i} \leftarrow 1$ for each appliance $i$
18: **return** $\vec{S}$

## 5. Experimental results

This section presents the performance evaluation of our method in real-world publicly-available datasets. We compare the proposed framework with state-of-the-art approaches available in the literature and evaluate the robustness of our approach in the presence of unmonitored appliances. We compare our method with NILM algorithms proposed for real-time low-frequency data that only require information on the average power for each appliance state.

### 5.1. Performance metrics

To evaluate the performance of the methods for each considered appliance, we compare them using the Estimation Accuracy (EA) [50] and the F-measure, defined in Eqs. (21) and (22) respectively.

$$ EA_i = 1 - \frac{\sum_{t=1}^{T} |p_i(t) - \hat{p}_i(t)|}{2 \sum_{t=1}^{T} p_i(t)} \qquad (21) $$

$$ FM_i = \frac{2 \cdot P_i \cdot R_i}{P_i + R_i} \qquad (22) $$

Where:

$$ P_i = \frac{TP_i}{TP_i + FP_i}, \quad R_i = \frac{TP_i}{TP_i + FN_i} \qquad (23) $$

Here TP (true positive) is the number of times an appliance is correctly detected as ON; FP (false positive) is the number of times an appliance is wrongly detected as ON; and FN (false negative) is the number of times an appliance is wrongly detected as OFF.

The EA metric measures how closely the real energy consumption matches the energy consumption predicted over $T$ consecutive time steps, whereas the F-measure assesses how accurately algorithms can predict which appliance is ON or OFF over $T$ consecutive time steps. All these metrics reach their optimal value in 1. We also consider the Overall Estimation Accuracy (OEA) for all the $N$ monitored appliances defined as follows:

$$ OEA = 1 - \frac{\sum_{i=1}^{N} \sum_{t=1}^{T} |p_i(t) - \hat{p}_i(t)|}{2 \sum_{i=1}^{N} \sum_{t=1}^{T} p_i(t)} \qquad (24) $$

and the Overall F-measure (OFM) that is obtained by summation over all the appliances for each TP, FP, and FN.

<table><caption>**Table 1**
Appliance states used in simulation.</caption><thead><tr><th>Dataset</th><th>Appliance (Acr.)</th><th>On-States [W]</th></tr></thead><tbody><tr><td rowspan="5">REDD-1</td><td>Fridge (F)</td><td>190, 230</td></tr><tr><td>Dish washer (DW)</td><td>225, 1115</td></tr><tr><td>Microwave (MW)</td><td>1520</td></tr><tr><td>Electric oven (EO)</td><td>3350, 4090</td></tr><tr><td>Washer dryer (WD)</td><td>450, 2700</td></tr><tr><td rowspan="5">UKDALE-2</td><td>Fridge (F)</td><td>90</td></tr><tr><td>Dish washer (DW)</td><td>100, 2000</td></tr><tr><td>Microwave (MW)</td><td>1308</td></tr><tr><td>Kettle (K)</td><td>2940</td></tr><tr><td>Rice cooker (RC)</td><td>400</td></tr><tr><td rowspan="5">UKDALE-5</td><td>Fridge (F)</td><td>108</td></tr><tr><td>Dish washer (DW)</td><td>94, 1665</td></tr><tr><td>Microwave (MW)</td><td>1505</td></tr><tr><td>Electric oven (EO)</td><td>2120</td></tr><tr><td>Kettle (K)</td><td>2900</td></tr></tbody></table>

<table><caption>**Table 2**
Test scenarios description.</caption><thead><tr><th>Scenario</th><th>Dataset</th><th>Test start</th><th>Test hours</th><th>Percent-noisy</th></tr></thead><tbody><tr><td>1</td><td>REDD-1</td><td>2011-05-14</td><td>96</td><td>44</td></tr><tr><td>2</td><td>UKDALE-2</td><td>2013-06-01</td><td>720</td><td>59</td></tr><tr><td>3</td><td>UKDALE-5</td><td>2014-08-20</td><td>72</td><td>72</td></tr></tbody></table>

### 5.2. Experimental setup

The framework with the minimum information setting O2RE-MIN (assuming only information on the average power for each appliance state), is tested on two real-world publicly available datasets: REDD [51] and UK-DALE [52]. We chose house 1 from REDD and houses 2 and 5 from UK-DALE. These datasets are selected because the sampling rate is compatible with the requirements of our method, they are widely adopted by the NILM community and contain both the aggregate and the appliance-specific measurements. Moreover, REDD and UKDALE datasets have been recently used in low-frequency-based NILM studies [53,54], allowing for direct comparison with other methods. Their use also enables assessment of the method's performance across different regions, as REDD originates from the US and UKDALE from the UK [51,52]. From each dataset, we selected five common FSM appliances. Appliances and their average power per on-state can be found in Table 1.

Test scenarios ranging from 72 to 720 h are selected to test the methods on different noise levels. The scenarios were designed to ensure activations across all monitored appliances in the selected intervals. As a measure of noise, we consider the percent-noisy measure [50], calculated as follows:

$$ \% - NM = \frac{\sum_{i=1}^{T} |P_i(t) - \sum_{i=1}^{N} p_i(t)|}{\sum_{i=1}^{T} P_i(t)} \qquad (25) $$

We report the percent-noisy measure and the test period for each scenario. The sampling rate was set to 3s for all considered scenarios. Details of each scenario can be found in Table 2.

For benchmarking we compare with the MCE algorithm [29], NILM [30], and the Hart combinatorial optimization (CO) baseline algorithm [9]. We use two versions of the CO algorithm, the traditional version and a custom version (CO-B) that subtracts the estimated base load (Algorithm 2) from the aggregated power. This custom version is introduced to evaluate the impact of the base load detection on the performance of state-based algorithms. All algorithms are implemented to be compatible with the widely adopted NILMTK toolkit [55]. These algorithms are selected because they are designed to be real-time, can handle frequencies on the order of 1 Hz, use only the active power, disaggregate one reading at a time, and only require the average power in each appliance state. This makes them ideal for comparison with our
<figure><img src="image_6.png" /><figcaption>Fig. 3. Performance results Scenario 1 (REDD-1, 96 h).</figcaption></figure>

<table><caption>**Table 3**
Test scenarios settings (O2RE framework).</caption><thead><tr><th>σ<sub>g</sub>[W]</th><th>θ[W]</th><th>σ<sup>2</sup><sub>dP</sub></th><th>δ</th><th>α</th><th>λ</th><th>p<sub>m</sub></th><th>S<sub>z</sub></th><th>G</th></tr></thead><tbody><tr><td>15</td><td>50</td><td>0.01</td><td>0.058</td><td>1 × 10<sup>-6</sup></td><td>0.025</td><td>0.01</td><td>30</td><td>50</td></tr></tbody></table>

proposed framework in a minimum information setting (O2RE-MIN). All algorithms compared are implemented with the recommended settings as explained in their original papers. For the proposed O2RE framework, we use the same settings for each scenario and each appliance. These settings were chosen according to the number of appliances and by trial and error for calibration of the most noisy scenario. The value of each required parameter is presented in Table 3. Please refer to Sections 4.1 and 4.4 for the definition of them.

### 5.3. Performance results

Performance results for each scenario defined in Table 2 for each monitored appliance are shown in Figs. 3–5. We report the Estimation Accuracy and the F-measure for each appliance, as well as its average value for each scenario. From the figures is visible the superiority of the O2RE framework in all scenarios. When considering the appliance-specific metrics, the dishwasher shows the lowest accuracy. This is due to the fact that we are using only information on the average power consumption and the minimum dishwasher on-state is similar to the fridge on-state, causing some false positives in the dishwasher. For better discrimination in these cases, additional information like the on-probability, transition probability, etc; has to be fed to the framework. Is important to remark, that the low accuracy of the microwave in UKDALE-5 is related to a continuous power consumption near 50 W in this appliance, which only is present in this dataset.

In general, the O2RE framework is stable for each considered scenario, even for the most noisy scenario 4, and reports high reliability for each considered appliance. Consider also, that we are using the main readings, and besides the contribution of unmonitored appliances, data can contain Gaussian noise due to fluctuations in sensor/ADC (analog-to-digital converter) precision [50]. Competitors' algorithms show a lack of robustness, especially for the noisiest scenarios. Also is interesting to note how the CO-B algorithm in some cases outperforms other more sophisticated ones, especially when the base load is significant. This emphasizes the importance of this estimation, especially for state-based approaches.

### 5.4. Robustness to noise

Intending to test how resilient is our approach to the presence of unmonitored appliances, we created artificial aggregates in the REDD-1 dataset. Starting by summing monitored appliances ($P_{A,0}(t) = \sum_{i=1}^{N} p_i(t)$) we add other appliances once at the time, selected in decreasing order

of their energy consumption ($P_{A,r}(t) = P_{A,0}(t) + \sum_{r=1}^{K} p_r(t)$), K is the number of appliances from the same dataset not considered in the monitored appliances. In this way, we created K+1 different scenarios with an increasing level of noise. Then, we compare the Overall Estimation Accuracy (OEA) and the Overall F-measure (OFM) for each considered algorithm.

Results are shown in Figs. 6(a) and 6(b). It can be appreciated how our proposal is resilient to the presence of unmonitored appliances, reporting OEA and OFM greater than 0.7 for all scenarios, even when the noise is greater than 40%. The opposite trend is appreciated for competing algorithms, where there is a tendency to decrease performance as the noise increases. Also is interesting to note how the CO-B algorithm performs better than other more sophisticated algorithms for some noisy scenarios. This is because some always-on-appliances are present in the dataset, and by subtracting the base load from the aggregated signal, the negative effect of these unknown appliances is alleviated.

### 5.5. Computational complexity and real-time capabilities

The dominant parts in the O2RE framework (Algorithm 1) are the complexity associated with the dynamic programming algorithm implemented in UpdateStateProb() function and the complexity associated with the PBIL optimization algorithm. The time and storage complexity of the dynamic programming algorithm is $O(N \times M^2)$ since the function updates the state probabilities for each appliance considering each possible state transition. Here, N represents the number of appliances, and M is the maximum number of states in the appliances.

The time complexity of the PBIL algorithm is $O(G \times N \times S_z \times M)$. This complexity arises from operations across G generations, drawing populations of size $S_z$, evaluating fitness, and updating state probabilities. Instead, the storage complexity of this part is $O(S_z \times N)$, which comes from storing the states of all appliances for each individual in the population.

As an example, if we assume 32-bit floating-point numbers for all calculations and consider a scenario involving 10 appliances (each with 3 states), a population size of 50, and 100 generations in the PBIL algorithm. The RAM usage includes approximately 360 bytes for the dynamic programming method ($10 \times 3^2$ transitions \times 4 bytes each), 2000 bytes for the PBIL algorithm (50 population size \times 10 appliances \times 4 bytes each), and additional 10 KB if we consider this value to account for typical overhead in embedded systems programming. This brings the total RAM requirement to about 12.36 KB, which is well within the memory capacity of constrained devices.

In terms of CPU workload, the dynamic programming method requires 90 operations (10 appliances \times $3^2$ transitions), while the PBIL algorithm involves 150,000 operations (100 generations \times 10 appliances \times 50 population size \times 3 states). These requirements are modest and fall well within the capabilities of constrained edge devices. For
<figure><img src="image_7.png" /><figcaption>Fig. 4. Performance results Scenario 2 (UKDALE-2, 720 h).</figcaption></figure>

<figure><img src="image_8.png" /><figcaption>Fig. 5. Performance results Scenario 3 (UKDALE-5, 72 h).</figcaption></figure>

<figure><img src="image_9.png" /><figcaption>Fig. 6. Robustness as the percent-noisy increases.</figcaption></figure>

instance, the Itron Riva meter [56], equipped with an ARM Cortex-A8 MPU and 128 MB of memory [56], easily meets these demands. Our framework, which requires 12.36 KB of RAM and manageable computational operations, is suitable for deployment on such devices.

To further verify the real-time capabilities of the O2RE framework in a constrained edge device, the algorithm was integrated into an Open-Source Home Automation software named Home Assistant [57] running on a Raspberry Pi 3 Model B. The hardware characteristics are provided in Table 4. Please note that the user can integrate many services to the Home Assistant instance [57], so, a lightweight model is crucial for the success of the deployment. Only the installation of Home Assistant with a few integrated services occupies nearly 1 GB of RAM which makes Raspberry Pi 3 Model B a constrained edge device. We consider more realistic those cases where the NILM algorithm has to be integrated into an existing software platform on shared hardware.

<table><caption>Table 4
Characteristics of the Raspberry Pi 3 Model B.</caption><thead><tr><td>Characteristic</td><td>Specification</td></tr></thead><tbody><tr><td>Processor</td><td>Broadcom BCM2837</td></tr><tr><td>CPU</td><td>Quad-Core ARM Cortex-A53</td></tr><tr><td>RAM</td><td>1 GB LPDDR2</td></tr></tbody></table>

We also believe this is crucial for the wide adoption of the NILM technology.

Table 5 presents the performance analysis of the NILM algorithm across average and critical instances. The algorithm was tested using scenario 3 described in Table 2. This analysis focuses on the algorithm's performance during crucial situations, which can occur when an edge is detected (triggering the most computationally intensive part) or when
<table><caption>**Table 5**
Performance analysis of O2RE framework across average and critical events.</caption><thead><tr><td>Statistic</td><td>Time (s)</td></tr></thead><tbody><tr><td>Mean (All)</td><td>0.01</td></tr><tr><td>Mean (&gt;0.1 s)</td><td>0.42</td></tr><tr><td>Maximum (&gt;0.1 s)</td><td>0.57</td></tr></tbody></table>

there is congestion due to many services running simultaneously. The table summarizes the mean running time overall and during critical events (running time > 0.1 s).

The overall mean running time of approximately 0.01 s indicates that, under average conditions, the method operates extremely fast. Moreover, the critical instances, while less frequent, are critically important as they could reflect the algorithm's response to significant changes in energy consumption patterns. The mean running time for these instances is around 0.42 s, indicating that while the algorithm takes longer, it still reacts quickly and the method can seamlessly manage a frequency in the order of 1 Hz in the tested edge device. These results suggest that our framework is well-suited for real-time monitoring.

## 6. Conclusion

This paper presents an online real-time NILM framework for frequencies in the order of 1 Hz. By sequentially detecting edges and base load from the measured aggregated power, the probability of an appliance being in a given state is updated taking into account the possibility of the presence of unknown loads. Using the information of the state probabilities, a modified PBIL algorithm is proposed to estimate the power consumption of each appliance. Experimentation with real-world publicly available datasets demonstrated its accuracy and robustness in the presence of unknown appliances. Benchmarking with online state-of-the-art algorithms using only information on the average power for each state, results in higher accuracy for overall and appliance-specific metrics. The real-time capabilities of the method were verified through integration in a Home Automation software running on a constrained edge device. The framework can also be enhanced with additional information like the on-probabilities, the expected on-time, tuned algorithm parameters, etc; that are important to increase the accuracy for appliances with very similar power consumption. Investigation into how to obtain this information without involving significant occupant efforts for algorithm training is a research topic for future work.

### CRediT authorship contribution statement

L.E. Garcia-Marrero: Writing – original draft, Validation, Software, Methodology, Investigation, Conceptualization. E. Monmasson: Writing – review & editing, Supervision, Conceptualization. G. Petrone: Writing – review & editing, Supervision, Conceptualization.

### Declaration of competing interest

The authors declare the following financial interests/personal relationships which may be considered as potential competing interests: Luis Enrique Garcia Marrero reports financial support was provided by Marie-Curie grant agreement no. 955614. If there are other authors, they declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.

### Acknowledgments

This project has received funding from the European Union's Horizon 2020 research and innovation program under the Marie Skłodowska-Curie grant agreement No 955614.

## Data availability

No data was used for the research described in the article.

## References

[1] Wang Y, Chen Q, Hong T, Kang C. Review of smart meter data analytics: Applications, methodologies, and challenges. IEEE Trans Smart Grid 2019;10(3):3125-48. http://dx.doi.org/10.1109/TSG.2018.2818167.

[2] Chakraborty S, Das S. Application of smart meters in high impedance fault detection on distribution systems. IEEE Trans Smart Grid 2019;10(3):3465-73. http://dx.doi.org/10.1109/TSG.2018.2828414.

[3] Brucke K, Arens S, Telle J-S, Steens T, Hanke B, von Maydell K, et al. A non-intrusive load monitoring approach for very short-term power predictions in commercial buildings. Appl Energy 2021;292:116860. http://dx.doi.org/10.1016/j.apenergy.2021.116860.

[4] Huang Y, Wang L, Guo W, Kang Q, Wu Q. Chance constrained optimization in a home energy management system. IEEE Trans Smart Grid 2018;9(1):252-60. http://dx.doi.org/10.1109/TSG.2016.2550031.

[5] Froehlich J, Larson E, Gupta S, Cohn G, Reynolds M, Patel S. Disaggregated end-use energy sensing for the smart grid. IEEE Pervasive Comput 2011;10(1):28-39. http://dx.doi.org/10.1109/MPRV.2010.74.

[6] Schirmer PA, Mporas I. Non-intrusive load monitoring: A review. IEEE Trans Smart Grid 2023;14(1):769-84. http://dx.doi.org/10.1109/TSG.2022.3189598.

[7] Nilsson A, Wester M, Lazarevic D, Brandt N. Smart homes, home energy management systems and real-time feedback: Lessons for influencing household energy consumption from a Swedish field study. Energy Build 2018;179:15-25. http://dx.doi.org/10.1016/j.enbuild.2018.08.026.

[8] Athanasiadis C, Doukas D, Papadopoulos T, Chrysopoulos A. A scalable real-time non-intrusive load monitoring system for the estimation of household appliance power consumption. Energies 2021;14(3):767. http://dx.doi.org/10.3390/en14030767.

[9] Hart G. Nonintrusive appliance load monitoring. Proc IEEE 1992;80(12):1870-91. http://dx.doi.org/10.1109/5.192069.

[10] Makonin S, Popowich F, Bajić IV, Gill B, Bartram L. Exploiting HMM sparsity to perform online real-time nonintrusive load monitoring. IEEE Trans Smart Grid 2016;7(6):2575-85. http://dx.doi.org/10.1109/TSG.2015.2494592.

[11] Kumar P, Abhyankar AR. A time efficient factorial hidden Markov model based approach for non-intrusive load monitoring. IEEE Trans Smart Grid 2023;1. http://dx.doi.org/10.1109/TSG.2023.3245019.

[12] Kolter JZ, Jaakkola T. Approximate inference in additive factorial HMMs with application to energy disaggregation. In: Proceedings of the fifteenth international conference on artificial intelligence and statistics, vol. 22. 2012, p. 1472-82.

[13] Wu Z, Wang C, Peng W, Liu W, Zhang H. Non-intrusive load monitoring using factorial hidden markov model based on adaptive density peak clustering. Energy Build 2021;244:111025. http://dx.doi.org/10.1016/j.enbuild.2021.111025.

[14] Mengistu MA, Girmay AA, Camarda C, Acquaviva A, Patti E. A cloud-based online disaggregation algorithm for home appliance loads. IEEE Trans Smart Grid 2019;10(3):3430-9. http://dx.doi.org/10.1109/TSG.2018.2826844.

[15] Zhang C, Zhong M, Wang Z, Goddard N, Sutton C. Sequence-to-point learning with neural networks for non-intrusive load monitoring. In: Proceedings of the AAAI conference on artificial intelligence, vol. 32, (1). Association for the Advancement of Artificial Intelligence (AAAI); 2018, http://dx.doi.org/10.1609/aaai.v32i1.11873.

[16] Cavdar IH, Faryad V. New design of a supervised energy disaggregation model based on the deep neural network for a smart grid. Energies 2019;12(7). http://dx.doi.org/10.3390/en12071217.

[17] Mauch L, Yang B. A new approach for supervised power disaggregation by using a deep recurrent LSTM network. In: 2015 IEEE global conference on signal and information processing. 2015, p. 63-7. http://dx.doi.org/10.1109/GlobalSIP.2015.7418157.

[18] Rafiq H, Manandhar P, Rodriguez-Ubinas E, Ahmed Qureshi O, Palpanas T. A review of current methods and challenges of advanced deep learning-based non-intrusive load monitoring (NILM) in residential context. Energy Build 2024;305:113890. http://dx.doi.org/10.1016/j.enbuild.2024.113890.

[19] Kukunuri R, Aglawe A, Chauhan J, Bhagtani K, Patil R, Walia S, et al. EdgeNILM: Towards NILM on edge devices. In: Proceedings of the 7th ACM international conference on systems for energy-efficient buildings, cities, and transportation. ACM; 2020, http://dx.doi.org/10.1145/3408308.3427977.

[20] Sykiotis S, Athanasoulias S, Kaselimi M, Doulamis A, Doulamis N, Stankovic L, et al. Performance-aware NILM model optimization for edge deployment. IEEE Trans Green Commun Netw 2023;7(3):1434-46.

[21] Lu Z, Cheng Y, Zhong M, Luan W, Ye Y, Wang G. LightNILM: lightweight neural network methods for non-intrusive load monitoring. In: Proceedings of the 9th ACM international conference on systems for energy-efficient buildings, cities, and transportation. ACM; 2022, http://dx.doi.org/10.1145/3563357.3566152.

[22] Luan W, Zhang R, Liu B, Zhao B, Yu Y. Leveraging sequence-to-sequence learning for online non-intrusive load monitoring in edge device. Int J Electr Power Energy Syst 2023;148:108910. http://dx.doi.org/10.1016/j.ijepes.2022.108910.
[23] Zeifman M. Disaggregation of home energy display data using probabilistic approach. IEEE Trans Consum Electron 2012;58(1):23-31. http://dx.doi.org/10.1109/TCE.2012.6170051.

[24] Athanasiadis CL, Papadopoulos TA, Doukas DI. Real-time non-intrusive load monitoring: A light-weight and scalable approach. Energy Build 2021;253:111523. http://dx.doi.org/10.1016/j.enbuild.2021.111523.

[25] Schirmer PA, Mporas I. Double Fourier integral analysis based convolutional neural network regression for high-frequency energy disaggregation. IEEE Trans Emerg Top Comput Intell 2022;6(3):439-49. http://dx.doi.org/10.1109/tetci.2021.3086226.

[26] Luan W, Wei Z, Liu B, Yu Y. Non-intrusive power waveform modeling and identification of air conditioning load. Appl Energy 2022;324:119755. http://dx.doi.org/10.1016/j.apenergy.2022.119755.

[27] Liu Y, Liu W, Shen Y, Zhao X, Gao S. Toward smart energy user: Real time non-intrusive load monitoring with simultaneous switching operations. Appl Energy 2021;287:116616. http://dx.doi.org/10.1016/j.apenergy.2021.116616.

[28] Welikala S, Thelasingha N, Akram M, Ekanayake PB, Godaliyadda RI, Ekanayake JB. Implementation of a robust real-time non-intrusive load monitoring solution. Appl Energy 2019;238:1519-29. http://dx.doi.org/10.1016/j.apenergy.2019.01.167.

[29] Machlev R, Lebron Y, Beck Y. Modified cross-entropy method for classification of events in NILM systems. IEEE Trans Smart Grid 2019;10(5):4962-73. http://dx.doi.org/10.1109/TSG.2018.2871620.

[30] Machlev R, Belikov J, Beck Y, Lebron Y. MO-NILM: A multi-objective evolutionary algorithm for NILM classification. Energy Build 2019;199:134-44. http://dx.doi.org/10.1016/j.enbuild.2019.06.046.

[31] Bhotto MZA, Makonin S, Bajic IV. Load disaggregation based on aided linear integer programming. IEEE Trans Circuits Syst II 2017;64(7):792-6. http://dx.doi.org/10.1109/tcii.2016.2603479.

[32] Dash S, Sodhi R, Sodhi B. An appliance load disaggregation scheme using automatic state detection enabled enhanced integer programming. IEEE Trans Ind Inf 2021;17(2):1176-85. http://dx.doi.org/10.1109/tii.2020.2975810.

[33] Wittmann FM, Lopez JC, Rider MJ. Nonintrusive load monitoring algorithm using mixed-integer linear programming. IEEE Trans Consum Electron 2018;64(2):180-7. http://dx.doi.org/10.1109/TCE.2018.2843292.

[34] Balletti M, Piccialli V, Sudoso AM. Mixed-integer nonlinear programming for state-based non-intrusive load monitoring. IEEE Trans Smart Grid 2022;13(4):3301-14. http://dx.doi.org/10.1109/tsg.2022.3152147.

[35] Zeinal-Kheiri S, Shotorbani AM, Mohammadi-Ivatloo B. Residential load disaggregation considering state transitions. IEEE Trans Ind Inf 2020;16(2):743-53. http://dx.doi.org/10.1109/tii.2019.2925323.

[36] He K, Stankovic L, Liao J, Stankovic V. Non-intrusive load disaggregation using graph signal processing. IEEE Trans Smart Grid 2018;9(3):1739-47. http://dx.doi.org/10.1109/tsg.2016.2598872.

[37] Zhao B, Li X, Luan W, Liu B. Apply graph signal processing on NILM: An unsupervised approach featuring power sequences. Sensors 2023;23(8):3939. http://dx.doi.org/10.3390/s23083939.

[38] Henao N, Agbossou K, Kelouwani S, Dubé Y, Fournier M. Approach in nonintrusive type I load monitoring using subtractive clustering. IEEE Trans Smart Grid 2017;8(2):812-21. http://dx.doi.org/10.1109/TSG.2015.2462719.

[39] Figueiredo M, Ribeiro B, de Almeida A. Electrical signal source separation via nonnegative tensor factorization using on site measurements in a smart home. IEEE Trans Instrum Meas 2014;63(2):364-73. http://dx.doi.org/10.1109/tim.2013.2278596.

[40] Liu B, Luan W, Yang J, Yu Y. The balanced window-based load event optimal matching for NILM. IEEE Trans Smart Grid 2022;13(6):4690-703. http://dx.doi.org/10.1109/tsg.2022.3179440.

[41] He K, Jakovetic D, Zhao B, Stankovic V, Stankovic L, Cheng S. A generic optimisation-based approach for improving non-intrusive load monitoring. IEEE Trans Smart Grid 2019;10(6):6472-80. http://dx.doi.org/10.1109/tsg.2019.2906012.

[42] Henao N, Kelouwani S, Agbossou K, Dubé Y. Active power load modeling based on uncertainties for non intrusive load monitoring. In: 2016 IEEE 25th international symposium on industrial electronics. 2016, p. 684-9. http://dx.doi.org/10.1109/ISIE.2016.7744972.

[43] Coretto P, Hennig C. Robust improper maximum likelihood: Tuning, computation, and a comparison with other methods for robust Gaussian clustering. J Amer Statist Assoc 2016;111(516):1648-59. http://dx.doi.org/10.1080/01621459.2015.1100996, arXiv:1406.0808.

[44] Coretto P, Hennig C. Consistency, breakdown robustness, and algorithms for robust improper maximum likelihood clustering. J Mach Learn Res 2017;18(142):1-39.

[45] MacKay DJC. Information theory, inference and learning algorithms. Cambridge, England: Cambridge University Press; 2003.

[46] Diamond S, Boyd S. CVXPY: A python-embedded modeling language for convex optimization. J Mach Learn Res 2016;17(83):1-5.

[47] Agrawal A, Verschueren R, Diamond S, Boyd S. A rewriting system for convex optimization problems. J Control Decis 2018;5(1):42-60.

[48] Baluja S. Population-based incremental learning: A method for integrating genetic search based function optimization and competitive learning. PA: School of Computer Science, Carnegie Mellon University Pittsburgh; 1994.

[49] Yang S, Yao X. Population-based incremental learning with associative memory for dynamic environments. IEEE Trans Evol Comput 2008;12(5):542-61. http://dx.doi.org/10.1109/TEVC.2007.913070.

[50] Makonin S, Popowich F. Nonintrusive load monitoring (NILM) performance evaluation. Energy Effic 2014;8(4):809-14. http://dx.doi.org/10.1007/s12053-014-9306-2.

[51] Kolter JZ, Johnson MJ. REDD: A public data set for energy disaggregation research. In: Workshop on data mining applications in sustainability, vol. 25, Citeseer; 2011, p. 59-62.

[52] Kelly J, Knottenbelt W. The UK-DALE dataset, domestic appliance-level electricity demand and whole-house demand from five UK homes. Sci Data 2015;2(1). http://dx.doi.org/10.1038/sdata.2015.7.

[53] Zhou K, Zhang Z, Lu X. Non-intrusive load monitoring based on an efficient deep learning model with local feature extraction. IEEE Trans Ind Inf 2024;20(7):9497-507. http://dx.doi.org/10.1109/tii.2024.3383521.

[54] Xiong J, Hong T, Zhao D, Zhang Y. MATnilm: Multi-appliance-task non-intrusive load monitoring with limited labeled data. IEEE Trans Ind Inf 2024;20(3):3177-87. http://dx.doi.org/10.1109/tii.2023.3301026.

[55] Batra N, Kelly J, Parson O, Dutta H, Knottenbelt W, Rogers A, et al. NILMTK: An open source toolkit for non-intrusive load monitoring. In: e-Energy 2014 - Proceedings of the 5th ACM international conference on future energy systems. 2014, p. 265-76. http://dx.doi.org/10.1145/2602044.2602051, arXiv: 1404.3878.

[56] Sonderegger R. The riva meter and platform. 2016. Presented at the 3rd International Workshop on Non-Intrusive Load Monitoring. URL http://nilmworkshop.org/2016/slides/ltron.pdf.

[57] Home assistant. 2024, https://www.home-assistant.io/. [Accessed: 10 April 2024].