Fast Deep Autoencoder for Federated learning

This paper presents a novel, fast and privacy preserving implementation of deep autoencoders. DAEF (Deep Autoencoder for Federated learning), unlike traditional neural networks, trains a deep autoencoder network in a non-iterative way, which drastically reduces its training time. Its training can be carried out in a distributed way (several partitions of the dataset in parallel) and incrementally (aggregation of partial models), and due to its mathematical formulation, the data that is exchanged does not endanger the privacy of the users. This makes DAEF a valid method for edge computing and federated learning scenarios. The method has been evaluated and compared to traditional (iterative) deep autoencoders using seven real anomaly detection datasets, and their performance have been shown to be similar despite DAEF's faster training.

AS HAPPENED at the time with the massive adoption of personal computers, the technological development of recent years has caused a substantial increase in the number of small computing machines such as smartphones or Internet of Things (IoT) devices, for both industrial and personal use. Despite their size, these devices have enough computing power to perform tasks that until a few years ago were considered unapproachable, such as the training of small machine learning models, real-time inference or the exchange of large amounts of information at high speeds.
Due to the abundance of these devices and the inefficiencies of traditional cloud computing for applications that demand low latencies, a new computing paradigm called edge computing has emerged [1]. Edge computing moves computing away from data centers to the edge of the network, bringing cloud computing services and utilities closer to the end user and their devices. This allows faster information processing and response time, as well as freeing up the network bandwidth.
From a machine learning point of view, this new technological scenario is very suitable for the application of federated learning [2]. Federated learning is a collaborative machine learning scheme that allows heterogeneous devices with different private data sets to work together to train a global model. In addition to this collaborative learning, this work scheme emphasizes the preservation of the privacy of local data collected on each device by implementing mechanisms that prevent possible direct and indirect leaks of their data.
On the other hand, in machine learning, anomaly detection is the branch that builds mod-els capable of differentiating between normal and anomalous data [3]. A priori, this turns anomaly detection into a classification problem with only two classes. However, since anomalies tend to occur sporadically, normal data are the ones that prevail in these scenarios, so it is common that models must be trained with only normal data. The objective is to learn to represent the normal class with high precision in order to be able to classify new data as either normal or abnormal. In many real systems, the response time to a detection of an anomaly (failure) can be critical, as is the case with autonomous vehicles [4] or industrial systems [5]. The development of anomaly detection techniques based on edge computing and federated learning may be the solution to reduce these response times.
In this paper we introduce DAEF (Deep Autoencoder for Federated learning), a fast and privacy-preserving deep autoencoder for edge computing and federated learning scenarios. Unlike traditional deep neural networks, its learning method is non-iterative, which drastically reduces training time. Its training can be carried out in a distributed way (several partitions of the dataset in parallel) and incrementally (aggregation of partial models), and due to its mathematical formulation the data that is exchanged does not endanger the privacy of the users. All of this makes DAEF a valid method for edge computing and federated training scenarios, capable of performing tasks as anomaly detection on large datasets while maintaining the performance of traditional (iterative) autoencoders.
This document is structured as follows. Section 2 contains a brief review of the main anomaly detection techniques for edge computing, providing an overview of this field. Section 3 describes the ideas taken as the basis for the development of the proposed DAEF method and Section 4 describes its operation. Section 5 discusses DAEF's privacy-preserving capabilities. Section 6 illustrates the performance of DAEF through a comparative study with traditional autoencoders. Finally, conclusions are drawn in Section 7.

RELATED WORK
Anomaly detection is a field that has a large number of algorithms that solve the problem of distinguishing between normal and anomalous instances in a wide variety of ways [6], [7]. Depending on the assumptions and processes they employ, in traditional anomaly detection we can distinguish between five main types of methods : probabilistic, distance-based, information theorybased, boundary-based, and reconstruction-based methods. In general, these algorithms are characterized by their high performance when classifying new data, however they do not focus on other aspects which from a centralized perspective may seem less important, such as data privacy and incremental learning. This makes it difficult to apply many of these classical methods in decentralized environments. For this reason, the strong expansion of edge computing has brought with it a new line of research in the field of anomaly detection in charge of designing new algorithms capable of learning in a distributed and, in some cases, incremental way, while preserving data privacy. Due to their good performance, it is common for these methods to be based on reconstruction (neural networks). In this section we will distinguish between reconstruction based methods that use autoencoders [8] and those that do not.
Among those that do not use autoencoders is DÏOT [9], a self-learning distributed system for security monitoring of IoT devices which utilizes a novel anomaly detection approach based on representing network packets as symbols, allowing to use a language analysis technique to detect anomalies. B. Hussain et al. [10] presented a deep learning framework to monitor user activities of multiple cells and thus detect anomalies using feedforward deep neural networks. R. Abdel et al. [11] introduced a federated stacked long shorttime memory model to solve multi-task problems using IoT sensors in smart buildings. Y. Zhao et al. [12] propose a multi-task deep neural network in federated learning to perform simultaneously network anomaly detection, VPN traffic recognition, and traffic classification. Other authors like D. Preuveneers et al. [13] propose the use of blockchain technology to carry out a decentralized registry of federated model updates. This guarantees the integrity of incrementally-learned machine learning models by cryptographically chaining one machine learning model to the next. These solutions obtain good results, however they do not emphasize privacy preservation and their iterative learning can lead to long training times.
On the other hand, if we focus on autoencoders [8], it is also possible to find works oriented towards edge computing and/or federated learning scenarios. Autoencoders (AE) are a type of self-associative neural network whose output layer seeks to reproduce the data presented to the input layer after having gone through a dimensional compression phase. In this way, they manage to obtain a representation of the input data in a space with a dimension smaller than the original, learning a compact representation of the data, retaining the important information and compressing the redundant one. For this reason, they are widely used for the elaboration of models that are robust to noise, an important quality in anomaly detection and regression problems. Figure 1 represents the traditional architecture of an autoencoder network.
T. Luo et al. [14] propose to use autoencoders for anomaly detection in wireless sensor networks, however each edge device does not train a local model with its own data. These devices send their local data to a central cloud node from which the training of the global model is carried out. In the approach presented by M. Ngo et al. [15], an adaptive hierarchical edge computing system composed by three autoencoder models of increasing complexity is used for IoT anomaly detection.
In the two previous works, as well as in the majority that use this type of networks, the autoencoders are trained during several iterations to adjust their parameters (weights, bias) using techniques such as the gradient descent and backpropagation. This greatly increases training time, specially when dealing with large datasets or complex networks architectures, which in edge computing scenarios can be critical.
However, there is a line of work that allows training autoencoders in a non-iterative way. This is based on Extreme Learning Machines (ELM) [16], an alternative learning algorithm originally formulated for single-hidden layer feedforward neural networks (SLFNs). This algorithm tends to provide good generalization performance and an extremely fast learning speed. Over time, more advanced versions such as MLELM [17], a multilayer version of ELM, or DELM [18], a deep version of ELM, have been developed.
For anomaly detection in edge computing and federated learning scenarios, R. Ito et al. [19] propose to combine OS-ELM (Online Sequential Extreme Learning Machine) [20] with autoencoders. This allows each edge device to train its own local model and incrementally update it with the results obtained by the other devices. Nevertheless, a possible limitation of this solution is its autoencoder architecture with only one hidden layer, which in some cases may not be sufficient.
In this work we present DAEF, a deep autoencoder with the following characteristics: • The architecture is deep and asymmetrical.
• The training process is non-iterative.
• It can be trained in a distributed and incremental way. • It is a privacy-preserving method.

BACKGROUND
This section introduces the theoretical foundations of the three methods taken as the basis for the development of DAEF: (a) DSVDautoencoder [21], a Distributed and privacypreserving autoencoder for anomaly detection using Singular Value Descomposition; (b) MLELM [17], a Multilayer Extreme Learning Machine implementation with a layer-by-layer training process; (c) ROLANN [22], a novel Regularized training method for One-Layer Neural Networks.

Distributed Singular Value Decomposition Autoencoder
DSVD-autoencoder (Distributed Singular Value Decomposition-Autoencoder) [21] is a hidden single-layer autoencoder network for anomaly detection. The aim in the encoder is to learn a vector space embedding of the input data extracting a meaningful but lower dimensional representation. To achieve this dimensionality reduction, the Singular Value Decomposition (SVD) of matrices is used. In the decoder, the goal is to reconstruct the input from the low-dimensional representation, in this case using LANN-SVD [23]. The privacy-preserving properties, parallelization, and non-iterative training of this method make it a suitable alternative for anomaly detection in edge computing scenarios and a good basis for out work, although it has the limitation of only allowing the use of one hidden layer.

Multilayer Extreme Learning Machine
MLELM (Multilayer Extreme Learning Machine) [17] is a multilayer neural network that makes use of unsupervised learning to train the parameters in each layer, eliminating the need to fine-tuning the network. The novelty of this work is that it trains each layer by using an ELM-AE (Extreme Learning Machine-Autoencoder) [17], which is an unsupervised single hidden layer neural network that, like any autoencoder, tries to reproduce the input signal at the output. As a result, the authors obtain a mechanism to train deep networks in a non-iterative, fast, and mathematically simple way. This mechanism has served as an inspiration for the work presented here.

Regularized One-Layer Neural Network
ROLANN (Regularized One-Layer Neural Networks) [22] is a training regularized by the L2 norm that allows to train single layer neural networks (without hidden layers) in a noniterative, incremental, and distributed way while also preserving privacy. To do this, the method minimizes the mean squared error (MSE) mea-sured before the activation function of the output neurons, as described in [24]. The algorithm can be used incrementally and distributed, making it a perfect fit for federated learning environments.

THE PROPOSED METHOD
The main objective of the proposed method (Deep Autoencoder for Federated learning) is to learn a compressed representation of the normal data and to reconstruct the inputs to the output of the autoencoder from this reduced space. These tasks should be carried out in a distributed way, and incrementally where possible, in order to apply the algorithm in edge computing and federated learning environments. To achieve this, DAEF employs an asymmetric autoencoder architecture as shown in Figure 2. A first single-layer encoder reduces the dimensionality of the input data and it is adjusted using a distributed SVD process. It is followed by a multi-layer decoder to reconstruct the input signal at the output which is trained in layer-by-layer basis through a noniterative process. This section presents in detail the steps followed by the method and its theoretical foundations.

The encoder
In the encoder, the goal is to learn a vector space embedding of the input data extracting a useful but lower-dimensional representation, known as the latent space. This can be accomplished by a low-rank matrix approximation, which is a minimization problem that tries to approximate a given matrix of data by another one subject to the constraint that the approximating matrix has reduced rank [25]. Given that the dimension of this new space is determined by the number of neurons m 1 of the first hidden layer, the rank-m 1 SVD of the input matrix X is used to obtain the weights W 1 of this first layer.
The full SVD of X ∈ R m0×n , where m 0 is the number of input variables and n the number of data samples, is a factorization of the form: where S ∈ R m0×n is a diagonal matrix with descending ordered non-negative values on the diagonal that are the singular values of X, while U ∈ R m0×m0 and V ∈ R n×n are orthogonal matrices containing the left and right singular vectors of X. In a low-rank approximation, the optimal rank-m 1 approximation of X can be computed by taking the first m 1 columns of U and rows of V T and truncating S to the first m 1 diagonal elements. The new truncated matrices U m1 ∈ R m0×m1 and V T m1 ∈ R m1×n are, respectively, m 1 -dimensional representations of rows (features) and columns (samples) of the input data X. Therefore, U m1 is used as the weights for the first layer W 1 ∈ R m0×m1 as it contains the In a distributed scenario, the data matrix X is partitioned into P several blocks, that is X = X 1 |X 2 | · · · |X P . In this case, the SVD of the entire X can be also computed distributively (DSVD) by calculating at each site p the local SVD (U p and S p ), corresponding to X p , and then arbitrarily computing the following operation at 2022 any of the nodes [26]: Therefore, the weights of the first layer W 1 = U m1 are obtained collaboratively across all nodes locations. Finally, the outputs of the first hidden layer of the network can be calculated, at each location, as: where f 1 is the activation function of the first hidden layer.
This dimensionality reduction method has been used, despite the existence of other techniques such as PCA (Principal Component Analysis), because, as has been demonstrated [26] [21], the distributed implementation of SVD performs well and preserves data privacy, which is very suitable for edge computing environments. It has been decided to use a single-layer encoder, that is, a single dimensionality reduction process using SVD, because chaining several SVD processes sequentially and progressively (one per layer) did not show better performance.

The decoder
In the decoder, the goal is to reconstruct the input from the low-dimensional representation provided by the output of the first hidden layer (see Equation (3)). In order to be able to work with large datasets in a fast and efficient way, we propose to apply a non-iterative learning method to obtain the decoder parameters.
Similar to ELM-AE [17], DAEF employs an auxiliary network to determine the parameters of each layer of the decoder in an unsupervised way, layer by layer. In the DAEF decoder, the weights and bias of the (l + 1)-th hidden layers will be calculated with an auxiliary network, which will use f l+1 as activation function. The output matrix of (l + 1)-th layer (H l+1 ) is obtained as follows: being H l the output matrix of the l-th layer, W l+1 ∈ R m l ×m l+1 and b l+1 ∈ R m l+1 ×1 the estimated weight matrix and bias vector of the layer, respectively, and 1 a column vector of n ones.
The use of this auxiliary network is shown in Figure 2, where W l+1 represents the output weights of the auxiliary network and m l the number of neurons in a layer l. As can be seen, the auxiliary network is a single-hidden layer sparse autoencoder. To calculate the parameters between the l-th and the (l + 1) hidden layers, the number of neurons in the input and the output layers of the auxiliar network will be identical to m l , and the number of neurons of his hidden layer will be m l+1 .
The training of this auxiliary network can be divided into two stages: the training of the first half of the network (layers c 0 -c 1 ) in which the input received by the first layer (c 0 ) is transformed; and a second stage (layers c 1 -c 2 ) in which, using the data coming from c 1 (H c1 ), the original input is reconstructed at the output of the network (H c2 ).
The weights of the first stage (W c1 ) are fixed and obtained using the Xavier Glorot initialization scheme, while the bias vector (b c1 ) is randomly established using a normal distribution with zero mean and standard deviation equal to 1. Given this, the H c1 output of the hidden layer can be calculated as: where f c1 is the activation function, W c1 are the fixed weights, b c1 the random bias, and H c0 the already known output of the DAEF's l-th layer.
In the second stage, the weights W c2 are computed in a supervised way using the regularized ROLANN method [22] as: whered p and f p are the inverse and derivative of the neural function, respectively, at each data point, and F p is the diagonal matrix of f p . M p , U p and S p correspond to the knowledge obtained in the p partition, while M k , U k and S k correspond to the knowledge accumulated after several iterations of incremental learning.
Considering that each output of the neural network depends solely on a set of independent weights, this second stage can be computed in parallel if the device has several cores. Once this is calculated, the weights between the DAEF's lth and (l + 1) layers can be obtained as W l+1 = W T c2 , and the output H l+1 can be calculated using Equation (4). This process will be repeated for each of the hidden layers of the decoder, layer by layer, using the outputs of each one to calculate the weights of the next one, until reaching the last DAEF's layer.
Finally, the output target values for the DAEF's last layer are known (the same as in the DAEF's input layer), therefore the weights of the last layer can be calculated directly in a supervised and distributed way using ROLANN. The activation function for the last layer will be linear as we want to reconstruct the input data of the network (any real value) at the output.
We can summarize the DAEF training as follows: 1) Dimensionality reduction in the first layer using distributed SVD (encoder). 2) Unsupervised/supervised training, layer by layer, using an auxiliary network in which ROLANN is used (decoder). 3) Supervised training of the last layer using ROLANN method (decoder).

Incremental and distributed learning
DAEF performs various operations that can be computed in a distributed way if the node (device) on which it is executed has several cores. These operations are the SVD computation of the encoder (the dataset can be divided and the partial SVDs concatenated and recalculated) and the ROLANN regularization processes in the decoder (the weights with respect to the output layer can be calculated in parallel).
In addition to this, the trained DAEF models can be updated when new data arrives thanks to their incremental learning capacity. A node can add knowledge to its model without having to retrain from scratch, incorporating the new knowledge quickly and inexpensively. A DAEF network trained with a data partition can incorporate the knowledge obtained by a second DAEF network trained with a different partition if the latter shares the U m1 matrices of its encoder [21], and the M k , U k , and S k matrices of each layer of its decoder [22]. By adding this information, the first DAEF network can recalculate its weights and will have learned incrementally.
If we are faced with an environment in which there are several nodes, such as an IoT scenario, where each node has a partition of the global dataset, we can take advantage of the incremental and distributed learning capacity of the DAEF network. Each node (device) would train a DAEF autoencoder network with its local data, and using a protocol such as MQTT, these nodes can publish their local model information through a broker to share their particular knowledge with the rest of the devices. The broker will be in charge of sending this information to the nodes that are subscribed to the updates, which will be able to aggregate the information received to their model.
We consider the local dataset of each node as a partition of a global dataset, so all the nodes must use a DAEF autoencoder network with a similar architecture. In order for the model information shared between nodes to be compatible with each other, the nodes must also use the same weights generated by the Xavier Glorot initialization scheme and the same bias. Before starting the training, one of the nodes must define the architecture, generate the weights and bias and publish them through the broker. Figure 3 shows this scenario using the MQTT protocol.
The private data of each node will be protected since the information that is sent through the broker to carry out the incremental learning is another. The data shared by each model will be the U m1 matrices of the encoder, and the M k , U k , and S k matrices of each layer of the decoder, from which the original data are not recoverable [21] [22]. The DAEF network matrices mentioned above are the only information needed to perform the federated learning, so if desired, the original dataset of each node can be removed to save space. Storing these matrices is not a problem since their size is independent of the number of instances of the original dataset.
Note that DAEF could also be used in a centralized scenario in which the information from the local models would be sent to a central node, which would be in charge of aggregating the information, obtaining the global model and sharing it with the network nodes.

Pseudocode
Algorithm 1 contains the pseudocode for the DAEF training phase. The processes carried out in the encoder are described between lines 5 and 12. In line 7 the dimensionality of the data is reduced by means of SVD in a distributed way, obtaining the encoder weights and, in line 9, the encoder output. Between lines 13 and 19, the hidden layers of the decoder are trained one by one. For this, Algorithm 2 is used (line 15). Between lines 20 and 25, the last layer of the decoder is trained directly using ROLANN.
Algorithm 2 contains the pseudocode of the auxiliary function used in algorithm 1 to train the different hidden layers of the decoder in a distributed way using an auxiliary autoencoder. In lines 2 and 3, the weights and bias are generated respectively, while in line 4 the output of the hidden layer is computed. Between lines 5 and 7, the decoder weights and the output are calculated using ROLANN in a distributed way. Since the weights with respect to each neuron of the output layer are calculated independently, the number of processes t should not be higher.
Algorithm 3 contains the pseudocode for the DAEF prediction phase where the trained network will reconstruct a test sample. This algorithm can be useful for tasks such as anomaly detection.

Algorithm 1 DAEF training phase
Input: X ∈ IR m0×n , training dataset (m 0 variables × n samples); a, list of neurons per layer; λ HL and λ LL , regularization hyperparameters of the hidden and last layer; f HL and f LL , activation functions of the hidden and last layers; t, available processes; Output: M , model composed of the weights and bias, the training output H LL , U 1 and S 1 matrices of the encoder, the M k , U k , and S k matrices of each layer of the decoder, and the architecture; Pool of t processes 22: Last layer ROLANN regularization in parallel 23: 24: Append W LL to W list Input: H l ∈ IR m l ×n , training data from layer l (m l variables × n samples); m l+1 , number of neurons of the layer l + 1; λ l+1 , regularization hyperparameter of the hidden layer; f l+1 , activation function of the layer; t, available processes; Output: W l+1 , weights of the layer l + 1; b l+1 bias of the layer; H l+1 , output of the layer l + 1; Initial bias 4: pool =Pool(t) Pool of t processes 6: ROLANN in parallel 7:

Algorithm 3 DAEF prediction phase
Input: X ∈ IR m0×n , test dataset (m 0 variables × n samples); W list , weights of the trained network; b list , bias of the trained network; f HL and f LL , activation functions of the hidden and last layers; a, list of neurons per layer; Output: prediction, reconstruction of the input X after passing through the network; 1: function DAEF PREDICT 2:

PRIVACY TREATMENT
In distributed environments (EC and FL), preserving the privacy of user data (nodes) is a critical aspect, even more so when they contain sensitive information such as personal data. Due to this, in this section we will analyze the privacy preservation capacity of the DAEF method. To do this we are going to consider two main threat scenarios [27].

Preventing direct leakage
In classic environments, it is common for the original data from the nodes to be sent to other nodes or to a central server, for example, for example, to be analyzed, preprocessed or to build a global model. This puts the privacy of the data at risk, which can be used maliciously and not to carry out the original tasks.
In the case of the DAEF method, the data shared to carry out the training of the global model is not the original data (X). In the case of the encoder, each node p computes an SVD using its local data (X p ), and the information shared to carry out the federated learning is the product U p S p . Since the matrix V p is neither calculated nor sent, the original data X p cannot be retrieved through the factorization expression described in Equation 1. In the decoder, the federated learning is carried out using the M p , U p and S p matrices obtained through ROLANN regularization, so the original data is also kept safe.
Once the global model is trained, it is distributed to each of the local nodes p to be used privately, so there is no direct data leakage in the operation phase.

Preventing indirect leakage
Another possible scenario is one in which a malicious node impersonates a real participant of the distributed learning protocol to try to obtain the private data of other nodes. Due to the nature of their training, when we train iterative algorithms in a distributed way (such as traditional autoencoders), it is common for nodes to share their calculations and model parameters. In these cases, using this information and specific methods (inverse methods [28], Generative Adversarial Networks [29]) the original data with which the training was carried out can be obtained, putting the privacy of the nodes at risk.
In the case of DAEF, the method is not iterative, so this type of attack is not a problem. The model parameters are calculated in a single step, so it is not possible to train GAN networks. In addition, as we have seen previously, stochastic gradients are not shared (they are not used) or sensitive information. In the articles taken as reference [22] [21] it has been shown that the original data cannot be recovered from the information sent by the node.

RESULTS
In this section, several experiments are presented to show the behaviour of the proposed algorithm in real scenarios. Although autoencoder networks have several uses, the main task for which the DAEF method has been designed is anomaly detection. Given a trained DAEF network, the classification of new instances can be carried out by comparing their value at the network input and their value at the output. This is known as the reconstruction error, and since anomalies are very rare in these scenarios, instances corresponding to the normal class will have a low reconstruction error, while anomalies will emit a much higher. To do this, after training the network it will be necessary to establish an error threshold that allows classifying new data based on its reconstruction error. In this work we will define the threshold using the interquartile range (IQR) and also manually based on the percentage of anomalies existing in the dataset. To penalize higher errors, we will calculate the reconstruction errors using the MSE.
DAEF emerges as a fast alternative to perform anomaly detection in edge computing and federated learning environments. Iterative approaches achieve a high performance detecting anomalies, but their long training times make them unsuitable for these environments. The aim of this study is to check the performance achieved by DAEF compared to iterative deep autoencoders (AE). Also, although by default DAEF uses Xavier Glorot initialization, other initializations such as totally random and orthogonal will be studied.
The algorithms have been evaluated over seven real datasets available in the UCI Machine Learning Repository and in the Kaggle website. The characteristics of these datasets are summarized in Table 1. The data have been normalized using standard scalers with zero mean and unit variance. To assess the performance of each algorithm, the data has been split using a tenfold cross validation. The algorithms have been trained using only normal data, while the test phase included data from both classes (50% normal and 50% anomalies). The combinations of parameters chosen for each algorithm have been obtained by a grid search and are available in Appendix A.
The metric used to measure the performance of the algorithms was the F1-score, Table 2 summarizes the mean test results. The chosen statistical test was Nemenyi, a non-parametric test which makes a pairwise comparison between models [30]. Using a significance level of 5% (α = 0.05) and the F1-scores obtained for each dataset independently, the best values in Table 2 have been highlighted in bold. As can be seen, the DAEF algorithm presents a robust behavior, achieving good performance for most datasets. The version of DAEF that uses the Xavier Glorot initialization stands out slightly from the others, matching the performance of the autoencoder in five of the seven datasets and surpassing it in another, according to the results of the statistical test.
Another statistical test was carried out to compare the global performance of the algorithms. The chosen test was again Nemenyi. Using a significance level of 5% and the F1-scores of the algorithms for the different datasets, the three versions of DAEF and the autoencoder rank in the same position, represented graphically by Figure 4. As can be seen, the null hypothesis that the algorithms obtain a similar performance is accepted, so we can affirm that in these tests DAEF obtained a similar performance to AE.
Because the execution of DAEF is parallelizable, the tests have been carried out using four cores. This was not possible with the autoencoder, which used a single core. Table 3 shows the mean training time of each algorithm (lower values than 0.05 have been represented as 0.0). Test times have not been included in this work because they are very low for all the algorithms. Due to DAEF's non-iterative training, its times are much shorter than those required by the traditional iterative autoencoder. The training times of DAEF have been between 15 and 68 times shorter in tests. Despite using a higher number of cores, the difference is significant. Table 4 shows an estimation of carbon dioxide emissions (grams of CO 2 emitted per kilowatt-hour) and power consumption (kWh) for the machine on which the tests were run [31]. Since the three versions of DAEF obtained similar values, only the Xavier Glorot initialization has been included. As can be seen, both consumption and emissions are much lower compared to the traditional autoencoder, despite its parallel execution.
To compare the performance of DAEF against the reference method the experiments have been carried out in a traditional environment with a single machine. Despite this, we consider that the low computational cost of DAEF allows its use in an edge computing environment, characterized by large number of devices with less computing power.

CONCLUSION
An alternative method to traditional deep autoencoder networks has been presented, with a robust performance in anomaly detection tests, and whose training time is much shorter than the reference method. Its distributed and incremental learning capacity, its low computational cost and its preservation of privacy make it a valid solution for edge computing and federated learning environments.