{'fraction_non_alphanumeric': 0.028953805158390838, 'fraction_numerical': 0.010340644699425298, 'mean_word_length': 4.712216731981599, 'pattern_counts': {'":': 0, '<': 2, '<?xml version=': 0, '>': 3, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 12, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
An overview and comparative analysis of Recurrent Neural Networks for Short Term Load Forecasting

The key component in forecasting demand and consumption of resources in a supply network is an accurate prediction of real-valued time series. Indeed, both service interruptions and resource waste can be reduced with the implementation of an effective forecasting system. Significant research has thus been devoted to the design and development of methodologies for short term load forecasting over the past decades. A class of mathematical models, called Recurrent Neural Networks, are nowadays gaining renewed interest among researchers and they are replacing many practical implementation of the forecasting systems, previously based on static methods. Despite the undeniable expressive power of these architectures, their recurrent nature complicates their understanding and poses challenges in the training procedures. Recently, new important families of recurrent architectures have emerged and their applicability in the context of load forecasting has not been investigated completely yet. In this paper we perform a comparative study on the problem of Short-Term Load Forecast, by using different classes of state-of-the-art Recurrent Neural Networks. We test the reviewed models first on controlled synthetic tasks and then on different real datasets, covering important practical cases of study. We provide a general overview of the most important architectures and we define guidelines for configuring the recurrent networks to predict real-valued time series.


Introduction
Forecasting the demand of resources within a distribution network of energy, telecommunication or transportation is of fundamental importance for managing the limited availability of the assets. An accurate Short Term Load Forecast (STLF) system [1] can reduce high cost of over-and under-contracts on balancing markets due to load prediction errors. Moreover, it keeps power markets efficient and provides a better understanding of the dynamics of the monitored system [2]. On the other hand, a wrong prediction could cause either a load overestimation, which leads to the excess of supply and consequently more costs and contract curtailments for market participants, or a load underestimation, resulting in failures in gathering enough provisions, thereby more costly supplementary services [3,4]. These reasons motivated the research of forecasting models capable of reducing this financial distress, by increasing the load forecasting accuracy even by a small percent [5,6,7,8,9].
The load profile generally follows cyclic and seasonal patterns related to human activities and can be represented by a real-valued time series. The dynamics of the system generating the load time series can vary significantly during the observation period, depending on the nature of the system and on latent, external influences. For this reason, the forecasting accuracy can change considerably among different samples even when using the same prediction model [10]. Over the past years, the STLF problem has been tackled in several research areas [11] by means of many different model-based approaches, each one characterized by different advantages and drawbacks in terms of prediction accuracy, complexity in training, sensitivity to the parameters and limitations in the tractable forecasting horizon [12].
Autoregressive and exponential smoothing models represented for many years the baseline among systems for time series prediction [13]. Such models require to properly select the lagged inputs to identify the correct model orders, a procedure which demands a certain amount of skill and expertise [14]. Moreover, autoregressive models make explicit assumptions about the nature of system under exam. Therefore, their use is limited to those settings in which such assumptions hold and where a-priori knowledge on the system is available [15]. Taylor [16] showed that for long forecasting horizons a very basic averaging model, like AutoRegressive Integrated Moving Average or Triple Exponential Smoothing, can outperform more sophisticated alternatives. However, in many complicated systems the properties of linearity and even stationarity of the analyzed time series are not guaranteed. Nonetheless, given their simplicity, autoregressive models have been largely employed as practical implementations of forecast systems.
The problem of time series prediction has been approached within a function approximation framework, by relying on the embedding procedure proposed by Takens [17]. Takens' theorem transforms the prediction problem from time extrapolation to phase space interpolation. In particular, by properly sampling a time dependent quantity s(t), it is possible to predict the value of the k-th sample from the previous samples, given an appropriate choice of the sampling frequency τ and the number of samples m: s[k] = f (s[k − τ ], . . . , s[k − m · τ ]). Through the application of phase-space embedding, regression methods, such as Support Vector Regression (an extension of Support Vector Machines in the continuum) have been applied in time series prediction [18], either by representing the sequential input as a static domain, described by frequency and phase, or by embedding sequential input values in time windows of fixed length. The approach can only succeed if there are no critical temporal dependencies exceeding the windows length, making the SVM unable to learn an internal state representation for sequence learning tasks involving time lags of arbitrary length. Other universal function approximators such as Feed-Forward Artificial Neural Networks [19] and ANFIS (Adaptive Network-Based Fuzzy Inference System) [20] have been employed in time series prediction tasks by selecting a suitable interval of past values from the time series as the inputs and by training the network to forecast one or a fixed number of future values [21,22,23,24,25,26,27]. The operation is repeated to forecast next values by translating the time window of the considered inputs [28]. While this approach proved to be effective in many circumstances [29,30,31,32], it does not treat temporal ordering as an explicit feature of the time series and, in general, is not suitable in cases where the time series have significantly different lengths. On this account, a Recurrent Neural Network (RNN) is a more flexible model, since it encodes the temporal context in its feedback connections, which are capable of capturing the time varying dynamics of the underlying system [33,34].
RNNs are a special class of Neural Networks characterized by internal self-connections, which can, in principle, any nonlinear dynamical system, up to a given degree of accuracy [35]. RNNs and their variants have been used in many contexts where the temporal dependency in the data is an important implicit feature in the model design. Noteworthy applications of RNNs include sequence transduction [36], language modeling [37,38,39,40], speech recognition [41], learning word embeddings [42], audio modeling [43], handwriting recognition [44,45], and image generation [46]. In many of these works a popular variant of RNN was used, called Long-Short Term Memory [47]. This latter has recently earned significant attention due to its capability of storing information for very long periods of time.
As an RNN processes sequential information, it performs the same operations on every element of the input sequence. Its output, at each time step, depends on previous inputs and past computations. This allows the network to develop a memory of previous events, which is implicitly encoded in its hidden state variables. This is certainly different from traditional feedforward neural networks, where it is assumed that all inputs (and outputs) are independent of each other. Theoretically, RNNs can remember arbitrarily long sequences. However, their memory is in practice limited by their finite size and, more critically, by the suboptimal training of their parameters. To overcome memory limitations, recent research efforts have led to the design of novel RNN architectures, which are equipped with an external, permanent memory capable of storing information for indefinitely long amount of time [48,49].
Contrarily to other linear models adopted for prediction, RNNs can learn functions of arbitrary complexity and they can deal with time series data possessing properties such as saturation or exponential effects and nonlinear interactions between latent variables. However, if the temporal dependencies of data are prevalently contained in a finite and small time interval, the use of RNNs can be unnecessary. In these cases performances, both in terms of computational resources required and accuracy, are generally lower than the ones of timewindow approaches, like ARIMA, SVM, Multi-Layer Perceptron and ANFIS. On the other hand, in many load forecasting problems the time series to be predicted are characterized by long temporal dependencies, whose extent may vary in time or be unknown in advance. In all these situations, the use of RNNs may turn out to be the best solution.
Despite the STLF problem has been one of the most important applications for both early RNNs models [50] and most recent ones [51], an up-to-date and comprehensive analysis of the modern RNN architectures applied to the STLF problem is still lacking. In several recent works on STFL, NARX networks (see Sec. 4.1) or Echo State Networks (see Sec. 4.2) are adopted for time series prediction and their performance is usually compared with standard static models, rather than with other RNN architectures. With this paper, we aim to fill these gaps by performing a comparative study on the problem of STLF using different classes of state-of-the-art RNNs. We provide an introduction to the RNN framework, presenting the most important architectures and their properties. We also furnish the guidelines for configuring and training the different RNN models to predict real-valued time series. In practice, we formulate the STLF problem as the prediction of a real-valued univariate time series, given its past values as input. In some cases, beside the time series of past target values, additional "context" time series are fed to the network in order to provide exogenous information related to the environment in which the system to be modeled operates.
The paper is structured as follows.
In Sec. 2 we provide a general overview of a standard RNN architecture and we discuss its general properties. We also discuss the main issues encountered in the training phase, the most common methodologies for learning the model parameters and common ways of defining the loss function to be optimized during the training.
In Sec. 3, we present the most basic architecture, called Elman RNN, and then we analyze two important variants, namely the Long-Short Term Memory and Gated Recurrent Units networks. Despite the recent popularity of these architectures [52], their application to prediction of real-valued time series has been limited so far [53]. For each RNN, we provide a brief review, explaining its main features, the approaches followed in the training stage and a short list of the main works concerning time series prediction in which the specific network has been applied.
Successively, in Sec. 4 we illustrate two particular RNN architectures, which differ from the previous ones, mainly due to their training procedure. In particular, we analyze the Nonlinear AutoRegressive with eXogenous inputs (NARX) neural network and the Echo State Network (ESN). These architectures have been successfully applied in the literature of time series prediction and they provide important advantages with respect to traditional models, due to their easy applicability and fast training procedures.
In Sec. 5 we describe three synthetic datasets, used to test and to compare the computational capabilities of the five RNN architectures in a controlled environment.
In Sec. 6, we present three real-world datasets of time series relative to the load profile in energy distribution and telecommunication networks. For each dataset, we perform a series of analysis with the purpose of choosing a suitable preprocessing for the data. Sec. 7 is dedicated to the experiments and to the discussion of the performance of the RNN models. The first part of the experimental section focuses on the benchmark tests, while in the second part we employ the RNNs to solve STLF tasks on real-world time series.
Finally, in Sec. 8 we discuss our conclusions.

Properties and Training in Recurrent Neural Networks
RNNs are learning machines that recursively compute new states by applying transfer functions to previous states and inputs. Typical transfer functions are composed by an affine transformation followed by a nonlinear function, which are chosen depending on the nature of the particular problem at hand. It has been shown by Maass et al. [54] that RNNs possess the so-called universal approximation property, that is, they are capable of approximating arbitrary nonlinear dynamical systems (under loose regularity conditions) with arbitrary precision, by realizing complex mappings from input sequences to output sequences [55]. However, the particular architecture of an RNN determines how information flows between different neurons and its correct design is crucial in the realization of a robust learning system. In the context of prediction, an RNN is trained on input temporal data x(t) in order to reproduce a desired temporal output y(t). y(t) can be any time series related to the input and even a temporal shift of x(t) itself. The most common training procedures are gradient-based, but other techniques have been proposed, based on derivative-free approaches or convex optimization [56,57]. The objective function to be minimized is a loss function, which depends on the error between the estimated outputŷ(t) and the actual output of the network y(t). An interesting aspect of RNNs is that, upon suitable training, they can also be executed in generative mode, as they are capable of reproducing temporal patterns similar to those they have been trained on [46].
The architecture of a simple RNN is depicted in Fig. 1. In its most general form an RNN can be seen as

Input layer
Hidden layer Output layer Figure 1: a weighted, directed and cyclic graph that contains three different kinds of nodes, namely the input, hidden and output nodes [58]. Input nodes do not have incoming connections, output nodes do not have outgoing connections, hidden nodes have both. An edge can connect two different nodes which are at the same or at different time instants. In this paper, we adopt the time-shift operator z n to represent a time delay of n time steps between a source and a destination node. Usually n = −1, but also lower values are admitted and they represent the so called skip connections [59]. Self-connecting edges always implement a lag operator with |n| ≥ 1. In some particular cases, the argument of the time-shift operator is positive and it represents a forward-shift in time [60]. This means that a node receives as input the content of a source node in a future time interval. Networks with those kind of connections are called bidirectional RNNs and are based on the idea that the output at a given time may not only depend on the previous elements in the sequence, but also on future ones [61]. These architectures, however, are not reviewed in this work as we only focus on RNNs with n = −1.
While, in theory, an RNN architecture can model any given dynamical system, practical problems arise during the training procedure, when model parameters must be learned from data in order to solve a target task. Part of the difficulty is due to a lack of well established methodologies for training different types of models. This is also because a general theory that might guide designer decisions has lagged behind the feverish pace of novel architecture designs [62,63]. A large variety of novel strategies and heuristics have arisen from the literature in the past the years [64,65] and, in many cases, they may require a considerable amount of expertise from the user to be correctly applied. While the standard learning procedure is based on gradient optimization, in some RNN architectures the weights are trained following different approaches [66,67], such as real-time recurrent learning [68], extended Kalman filters [69] or evolutionary algorithms [70], and in some cases they are not learned at all [71].

Backpropagation Through Time
Gradient-based learning requires a closed-form relation between the model parameters and the loss function. This relation allows to propagate the gradient information calculated on the loss function back to the model parameters, in order to modify them accordingly. While this operation is straightforward in models represented by a directed acyclic graph, such as a FeedForward Neural Network (FFNN), some caution must be taken when this reasoning is applied to RNNs, whose corresponding graph is cyclic. Indeed, in order to find a direct relation between the loss function and the network weights, the RNN has to be represented as an equivalent infinite, acyclic and directed graph. The procedure is called unfolding and consists in replicating the network's hidden layer structure for each time interval, obtaining a particular kind of FFNN. The key difference of an unfolded RNN with respect to a standard FFNN is that the weight matrices are constrained to assume the same values in all replicas of the layers, since they represent the recursive application of the same operation. Fig. 2 depicts the unfolding of the RNN, previously reported in Fig. 1. Through this transformation the network can be trained with standard learning algorithms, originally conceived for feedforward architectures. This learning procedure is called Back Propagation Through Time (BPTT) [72] and is one of the most successful techniques adopted for training RNNs. However, while the network structure could in principle be replicated an infinite number of times, in practice the unfolding is always truncated after a finite number of time instants. This maintains the complexity (depth) of the network treatable and limits the issue of the vanishing gradient (as discussed later). In this learning procedure called Truncated BPPT [73], the folded architecture is repeated up to a given number of steps τ b , with τ b upperbounded by the time series length T . The size of the truncation depends on the available computational resources, as the network grows deeper by repeating the unfolding, and on the expected maximum extent of time dependencies in data. For example, in a periodic time series with period t it may be unnecessary, or even detrimental, to set τ b > t.
Another variable we consider is the frequency τ f at which the BPTT calculates the backpropagated gradients. In particular, let us define with BPTT(τ b , τ f ) the truncated backpropagation that processes the sequence one time step at a time, and every τ f time steps, it runs BPTT for τ b time steps [74]. Very often the term τ f is omitted in the literature, as it is assumed equal to 1, and only the value for τ b is specified. We refer to the case τ f = 1 and τ b = n as true BPTT, or BPTT(n, 1).
In order to improve the computational efficiency of the BPTT, the ratio τ b /τ f can be decremented, effectively reducing the frequency of gradients evaluation. An example, is the so-called epochwise BPTT or BPTT(n, n), where τ b = τ f [75]. In this case, the ratio τ b /τ f = 1. However, the learning procedure is in general much less accurate than BPTT(n, 1), since the gradient is truncated too early for many values on the boundary of the backpropagation window.
A better approximation of the true BPTT is reached by taking a large difference τ b − τ f , since no error in the gradient is injected for the earliest τ b − τ f time steps in the buffer. A good trade-off between accuracy and performance is BPTT(2n, n), which keeps the ratio τ b /τ f = 2 sufficiently close to 1 and the difference τ b − τ f = n is large as in the true BPTT [73]. Through preliminary experiments, we observed that BPTT(2n, n) achieves comparable performance to BPTT(n, 1), in a significantly reduced training time. Therefore, we followed this procedure in all our experiments.

Gradient descent and loss function
Training a neural network commonly consists in modifying its parameters through a gradient descent optimization, which minimizes a given loss function that quantifies the accuracy of the network in performing the desired task. The gradient descent procedure consists in repeating two basic steps until convergence is reached. First, the loss function L k is evaluated on the RNN configured with weights W k , when a set of input data X k are processed (forward pass). Note that with W k we refer to all network parameters, while the index k identifies their values at epoch k, as they are updated during the optimization procedure. In the second step, the gradient ∂L k /∂W k is back-propagated through the network in order to update its parameters (backward pass).
In a time series prediction problem, the loss function evaluates the dissimilarity between the predicted values and the actual future values of the time series, which is the ground truth. The loss function can be defined as where E is a function that evaluates the prediction error of the network when it is fed with inputs in X k , in respect to a desired response Y * k . R λ is a regularization function that depends on a hyperparameter λ, which weights the contribution of the regularization in the total loss.
The error function E that we adopt in this work is Mean Square Error (MSE). It is defined as where y x ∈ Y k is the output of the RNN (configured with parameters W k ) when the input x ∈ X k is processed and y * x ∈ Y * k is the ground-truth value that the network must learn to reproduce. The regularization term R λ introduces a bias that improves the generalization capabilities of the RNN, by reducing overfitting on the training data. In this work, we consider four types of regularization: 1. L 1 : the regularization term in Eq. 1 has the form R λ (W k ) = λ 1 W k 1 . L 1 regularization enforces sparsity in the network parameters, is robust to noisy outliers and it can possibly deliver multiple optimal solutions. However, this regularization can produce unstable results, in the sense that a small variation in the training data can yield very different outcomes. 2. L 2 : in this case, R λ (W k ) = λ 2 W k 2 . This function penalizes large magnitudes in the parameters, favouring dense weight matrices with low values. This procedure is more sensitive to outliers, but is more stable than L 1 . Usually, if one is not concerned with explicit features selection, the use of L 2 is preferred. 3. Elastic net penalty: combines the two regularizations above, by joining both L 1 and L 2 terms as R λ (W k ) = λ 1 W k 1 + λ 2 W k 2 . This regularization method overcomes the shortcomings of the L 1 regularization, which selects a limited number of variables before it saturates and, in case of highly correlated variables, tends to pick only one and ignore the others. Elastic net penalty generalizes the L 1 and L 2 regularization, which can be obtained by setting λ 2 = 0 and λ 1 = 0, respectively. 4. Dropout: rather than defining an explicit regularization function R λ (·), dropout is implemented by keeping a neuron active during each forward pass in the training phase with some probability. Specifically, one applies a randomly generated mask to the output of the neurons in the hidden layer. The probability of each mask element to be 0 or 1 is defined by a hyperparameter p drop . Once the training is over, the activations are scaled by p drop in order to maintain the same expected output. Contrarily to feedforward architectures, a naive dropout in recurrent layers generally produces bad performance and, therefore, it has usually been applied only to input and output layers of the RNN [76]. However, in a recent work, Gal and Ghahramani [77] shown that this shortcoming can be circumvented by dropping the same network units in each epoch of the gradient descent. Even if this formulation yields a slightly reduced regularization, nowadays this approach is becoming popular [78,79] and is the one followed in this paper.
Beside the ones discussed above, several other kinds of regularization procedures have been proposed in the literature. Examples are the stochastic noise injection [80] and the max-norm constraint [81], which, however, are not considered in our experiments.

Parameters update strategies
Rather than evaluating the loss function over the entire training set to perform a single update of the network parameters, a very common approach consists in computing the gradient over mini-batches X k of the training data. The size of the batch is usually set by following rules of thumb [82].
This gradient-update method is called Stochastic Gradient Descent (SGD) and, in presence of a nonconvex function, its convergence to a local minimum is guaranteed (under some mild assumptions) if the learning rate is sufficiently small [83]. The update equation reads where η is the learning rate, an important hyperparameter that must be carefully tuned to achieve an effective training [84]. In fact, a large learning rate provides a high amount of kinetic energy in the gradient descent, which causes the parameter vector to bounce, preventing the access to narrow area of the search space, where the loss function is lower. On the other hand, a strong decay can excessively slow the training procedure, resulting in a waste of computational time. Several solutions have been proposed over the years, to improve the convergence to the optimal solution [85]. During the training phase it is usually helpful to anneal η over time or when the performance stops increasing. A method called step decay reduces the learning rate by a factor α, if after a given number of epochs the loss has not decreased. The exponential decay and the fractional decay instead, have mathematical forms η = η 0 e −αk and η = η0 (1+αk) , respectively. Here α and η 0 are hyperparameters, while k is the current optimization epoch. In our experiments, we opted for the step decay annealing, when we train the networks with SGD.
Even if SGD usually represents a safe optimization procedure, its rate of convergence is slow and the gradient descent is likely to get stuck in a saddle point of the loss function landscape [86]. Those issues have been addressed by several alternative strategies proposed in the literature for updating the network parameters. In the following we describe the most commonly used ones.
Momentum. In this first-order method, the weights W k are updated according to a linear combination of the current gradient ∇L k (W k ) and the previous update V k−1 , which is scaled by a hyperparameter µ: With this approach, the updates will build up velocity toward a direction that shows a consistent gradient [74]. A common choice is to set µ = 0.9. A variant of the original formulation is the Nesterov momentum, which often achieves a better convergence rate, especially for smoother loss functions [87]. Contrarily to the original momentum, the gradient is evaluated at an approximated future location, rather than at the current position. The update equations are Adaptive learning rate. The first adaptive learning rate method, proposed by Duchi et al. [88], is Adagrad. Unlike the previously discussed approaches, Adagrad maintains a different learning rate for each parameter. Given the update information from all previous iterations ∇L k (W j ), with j ∈ {0, 1, · · · , k}, a different update is specified for each parameter i of the weight matrix: where is a small term used to avoid division by 0. A major drawback with Adagrad is the unconstrained growth of the accumulated gradients over time. This can cause diminishing learning rates that may stop the gradient descent prematurely.
A procedure called RMSprop [89] attempts to solve this issue by using an exponential decaying average of square gradients, which discourages an excessive shrinkage of the learning rates: According to the update formula, if there are oscillation in gradient updates, the learning rate is reduced by 1 − δ, otherwise it is increased by δ. Usually the decay rate is set to δ = 0.01.
Another approach called Adam and proposed by Kingma and Ba [90], combines the principles of Adagrad and momentum update strategies. Usually, Adam is the adaptive learning method that yields better results and, therefore, is the gradient descent strategy most used in practice. Like RMSprop, Adam stores an exponentially decaying average of gradients squared, but it also keeps an exponentially decaying average of the moments of the gradients. The update difference equations of Adam are m corresponds to the first moment and v is the second moment. However, since both m and v are initialized as zero-vectors, they are biased towards 0 during the first epochs. To avoid this effect, the two terms are corrected asm t andv t . Default values of the hyperparameters are β 1 = 0.9, β 2 = 0.999 and ε = 10 −8 .
Second-order methods. The methods discussed so far only consider first-order derivatives of the loss function. Due to this approximation, the landscape of the loss function locally looks and behaves like a plane. Ignoring the curvature of the surface may lead the optimization astray and it could cause the training to progress very slowly. However, second-order methods involve the computation of the Hessian, which is expensive and usually untreatable even in networks of medium size. A Hessian-Free (HF) method that considers derivatives of the second order, without explicitly computing the Hessian, has been proposed by Martens [91]. This latter, unlike other existing HF methods, makes use of the positive semi-definite Gauss-Newton curvature matrix and it introduces a damping factor based on the Levenberg-Marquardt heuristic, which permits to train networks more effectively. However, Sutskever et al. [92] showed that HF obtains similar performance to SGD with Nesterov momentum. Despite being a first-order approach, Nestrov momentum is capable of accelerating directions of low-curvature just like a HF method and, therefore, is preferred due to its lower computational complexity.

Vanishing and exploding gradient
Increasing the depth in an RNN, in general, improves the memory capacity of the network and its modeling capabilities [93]. For example, stacked RNNs do outperform shallow ones with the same hidden size on problems where it is necessary to store more information throughout the hidden states between the input and output layer [94]. One of the principal drawback of early RNN architectures was their limited memory capacity, caused by the vanishing or exploding gradient problem [95], which becomes evident when the information contained in past inputs must be retrieved after a long time interval [96]. To illustrate the issue of vanishing gradient, one can consider the influence of the loss function L t (that depends on the network inputs and on its parameters) on the network parameters W t , when its gradient is backpropagated through the unfolded The network Jacobian reads as In the previous equation, the partial derivatives of the states with respect to their previous values can be factorized as To ensure local stability, the network must operate in a ordered regime [97], a property ensured by the condition |f t | < 1. However, in this case the product expanded Eq. 10 rapidly (exponentially) converges to 0, when t − τ increases. Consequently, the sum in Eq. 9 becomes dominated by terms corresponding to short-term dependencies and the vanishing gradient effect occurs. As principal side effect, the weights are less and less updated as the gradient flows backward through the layers of the network. On the other hand, the phenomenon of exploding gradient appears when |f t | > 1 and the network becomes locally unstable. Even if global stability can still be obtained under certain conditions, in general the network enters into a chaotic regime, where its computational capability is hindered [98].
Models with large recurrent depths exacerbate these gradient-related issues, since they posses more nonlinearities and the gradients are more likely to explode or vanish. A common way to handle the exploding gradient problem, is to clip the norm of the gradient if it grows above a certain threshold. This procedure relies on the assumption that exploding gradients only occur in contained regions of the parameters space. Therefore, clipping avoids extreme parameter changes without overturning the general descent direction [99].
On the other hand, different solutions have been proposed to tackle the vanishing gradient issue. A simple, yet effective approach consists in initializing the weights to maintain the same variance withing the activations and back-propagated gradients, as one moves along the network depth. This is obtained with a random initialization that guarantees the variance of the components of the weight matrix in layer l to be Var(W l ) = 2/(N l−1 + N l+1 ), N l−1 and N l+1 being the number of units in the previous and the next layer respectively [100]. He et al. [101] proposed to initialize the network weights by sampling them from an uniform distribution in [0, 1] and then rescaling their values by 1/ √ N h , N h being the total number of hidden neurons in the network. Another option, popular in deep FFNN, consists in using ReLU [102] as activation function, whose derivative is 0 or 1, and it does not cause the gradient to vanish or explode. Regularization, besides preventing unwanted overfitting in the training phase, proved to be useful in dealing with exploding gradients. In particular, L 1 and L 2 regularizations constrain the growth of the components of the weight matrices and consequently limit the values assumed by the propagated gradient [38]. Another popular solution is adopting gated architectures, like Long Short-Term Memory (LSTM) or Gated Recurrent Unit (GRU), which have been specifically designed to deal with vanishing gradients and allow the network to learn much longer-range dependencies. Srivastava et al. [103] proposed an architecture called Highway Network, which allows information to flow across several layers without attenuation. Each layer can smoothly vary its behavior between that of a plain layer, implementing an affine transform followed by a non-linear activation, and that of a layer which simply passes its input through. Optimization in highway networks is virtually independent of depth, as information can be routed (unchanged) through the layers. The Highway architecture, initially applied to deep FFNN [104], has recently been extended to RNN where it dealt with several modeling and optimization issues [78].
Finally, gradient-related problems can be avoided by repeatedly selecting new weight parameters using random guess or evolutionary approaches [70,105]; in this way the network is less likely to get stuck in local minima. However, convergence time of these procedures is time-consuming and can be impractical in many real-world applications. A solution proposed by Schmidhuber et al. [56], consists in evolving only the weights of non-linear hidden units, while linear mappings from hidden to output units are tuned using fast algorithms for convex problem optimization.

Recurrent Neural Networks Architectures
In this section, we present three different RNN architectures trainable through the BPPT procedure, which we employ to predict real-valued time series. First, in Sec. 3.1 we present the most basic version of RNN, called Elman RNN. In Sec. 3.2 and 3.3 we discuss two gated architectures, which are LSTM and GRU. For each RNN model, we provide a quick overview of the main applications in time series forecasting and we discuss its principal features.

Elman Recurrent Neural Network
The Elman Recurrent Neural Network (ERNN), also known as Simple RNN or Vanillan RNN, is depicted in Fig. 1 and is usually considered to be the most basic version of RNN. Most of the more complex RNN architectures, such as LSTM and GRU, can be interpreted as a variation or as an extension of ERNNs.
ERNN have been applied in many different contexts. In natural language processing applications, ERNN demonstrated to be capable of learning grammar using a training set of unannotated sentences to predict successive words in the sentence [106,107]. Mori and Ogasawara [108] studied ERNN performance in shortterm load forecasting and proposed a learning method, called "diffusion learning" (a sort of momentumbased gradient descent), to avoid local minima during the optimization procedure. Cai et al. [109] trained a ERNN with a hybrid algorithm that combines particle swarm optimization and evolutionary computation to overcome the local minima issues of gradient-based methods. Furthermore, ERNNs have been employed by Cho [110] in tourist arrival forecasting and by Mandal et al. [111] to predict electric load time series. Due to the critical dependence of electric power usage on the day of the week or month of the year, a preprocessing step is performed to cluster similar days according to their load profile characteristics. Chitsaz et al. [112] proposes a variant of ERNN called Self-Recurrent Wavelet Neural Network, where the ordinary nonlinear activation functions of the hidden layer are replaced with wavelet functions. This leads to a sparser representation of the load profile, which demonstrated to be helpful for tackling the forecast task through smaller and more easily trainable networks.
The layers in a RNN can be divided in input layers, hidden layers and the output layers (see Fig. 1). While input and output layers are characterized by feedforward connections, the hidden layers contain recurrent ones. At each time step t, the input layer process the component x[t] ∈ R Ni of a serial input x. The time series x has length T and it can contain real values, discrete values, one-hot vectors, and so on. In the input layer, each component x[t] is summed with a bias vector b i ∈ R N h (N h is the number of nodes in the hidden layer) and then is multiplied with the input weight matrix W h i ∈ R Ni×N h . Analogously, the internal state of the network h[t − 1] ∈ R N h from the previous time interval is first summed with a bias vector b h ∈ R N h and then multiplied by the weight matrix W h h ∈ R N h ×N h of the recurrent connections. The transformed current input and past network state are then combined and processed by the neurons in the hidden layers, which apply a non-linear transformation. The difference equations for the update of the internal state and the output of the network at a time step t are: where f (·) is the activation function of the neurons, usually implemented by a sigmoid or by a hyperbolic tangent. The hidden state h[t] conveys the content of the memory of the network at time step t, is typically initialized with a vector of zeros and it depends on past inputs and network states. The output y[t] ∈ R No is computed through a transformation g(·), usually linear, on the matrix of the output weights W o h ∈ R Nr×No applied to the sum of the current state h[t] and the bias vector b o ∈ R No . All the weight matrices and biases can be trained through gradient descent, according to the BPPT procedure. Unless differently specified, in the following to compact the notation we omit the bias terms by assuming

Long Short-Term Memory
The Long Short-Term Memory (LSTM) architecture was originally proposed by Hochreiter and Schmidhuber [47] and is widely used nowadays due to its superior performance in accurately modeling both short and long term dependencies in data. LSTM tries to solve the vanishing gradient problem by not imposing any bias towards recent observations, but it keeps constant error flowing back through time. LSTM works essentially in the same way as the ERNN architecture, with the difference that it implements a more elaborated internal processing unit called cell.
LSTM has been employed in numerous sequence learning applications, especially in the field of natural language processing. Outstanding results with LSTM have been reached by Graves and Schmidhuber [44] in unsegmented connected handwriting recognition, by Graves et al. [113] in automatic speech recognition, by Eck and Schmidhuber [114] in music composition and by Gers and Schmidhuber [115] in grammar learning. Further successful results have been achieved in the context of image tagging, where LSTM have been paired with convolutional neural network, to provide annotations on images automatically [116].
However, few works exist where LSTM has been applied to prediction of real-valued time series. Ma et al. [117] evaluated the performances of several kinds of RNNs in short-term traffic speed prediction and compared them with other common methods like SVMs, ARIMA, and Kalman filters, finding that LSTM networks are nearly always the best approach. Pawlowski and Kurach [118] utilized ensembles of LSTM and feedforward architectures to classify the danger from concentration level of methane in a coal mine, by predicting future concentration values. By following a hybrid approach, Felder et al. [119] trains a LSTM network to output the parameter of a Gaussian mixture model that best fits a wind power temporal profile.
While an ERNN neuron implements a single nonlinearity f (·) (see Eq. 11), a LSTM cell is composed of 5 different nonlinear components, interacting with each other in a particular way. The internal state of a cell is modified by the LSTM only through linear interactions. This permits information to backpropagate smoothly across time, with a consequent enhancement of the memory capacity of the cell. LSTM protects and controls the information in the cell through three gates, which are implemented by a sigmoid and a pointwise multiplication. To control the behavior of each gate, a set of parameters are trained with gradient descent, in order to solve a target task.
Since its initial definition [47], several variants of the original LSTM unit have been proposed in the literature. In the following, we refer to the commonly used architecture proposed by Graves and Schmidhuber [120]. A schema of the LSTM cell is depicted in Fig. 3.
The difference equations that define the forward pass to update the cell state and to compute the output Figure 3: Illustration of a cell in the LSTM architecture. Dark gray circles with a solid line are the variables whose content is exchanged with the input and output of the cell. Dark gray circles with a dashed line represent the internal state variables, whose content is exchanged between the cells of the hidden layer. Operators g 1 and g 2 are the non-linear transformation, usually implemented as a hyperbolic tangent. White circles with + and × represent linear operations, while σ f , σu and σo are the sigmoids used in the forget, update and output gates respectively.
are listed below.
forget gate : To produce the output y[t], first the cell filters its current state with a nonlinearity g 2 (·). Then, the output gate σ o selects the part of the state to be returned as output. Each gate depends on the current external input x[t] and the previous cells output y[t − 1].
As we can see from the Fig. 3 and from the forward-step equations, when σ f = 1 and σ u = 0, the current state of a cell is transferred to the next time interval exactly as it is. By referring back to Eq. 10, it is possible to observe that in LSTM the issue of vanishing gradient does not occur, due to the absence of nonlinear transfer functions applied to the cell state. Since in this case the transfer function f (·) in Eq. 10 applied to the internal states is an identity function, the contribution from past states remains unchanged over time. However, in practice, the update and forget gates are never completely open or closed due to the functional form of the sigmoid, which saturates only for infinitely large values. As a result, even if long term memory in LSTM is greatly enhanced with respect to ERNN architectures, the content of the cell cannot be kept completely unchanged over time. Figure 4: Illustration of a recurrent unit in the GRU architecture. Dark gray circles with a solid line are the variables whose content is exchanged with the input and output of the network. Dark gray circles with a dashed line represent the internal state variables, whose content is exchanged within the cells of the hidden layer. The operator g is a non-linear transformation, usually implemented as a hyperbolic tangent. White circles with '+', '−1' and '×' represent linear operations, while σr and σu are the sigmoids used in the reset and update gates respectively.

Gated Recurrent Unit
The Gated Recurrent Unit (GRU) is another notorious gated architecture, originally proposed by Cho et al. [121], which adaptively captures dependencies at different time scales. In GRU, forget and input gates are combined into a single update gate, which adaptively controls how much each hidden unit can remember or forget. The internal state in GRU is always fully exposed in output, due to the lack of a control mechanism, like the output gate in LSTM.
GRU were firstly tested by Cho et al. [121] on a statistical machine translation task and reported mixed results. In an empirical comparison of GRU and LSTM, configured with the same amount of parameters, Chung et al. [122] concluded that on some datasets GRU can outperform LSTM, both in terms of generalization capabilities and in terms of time required to reach convergence and to update parameters. In an extended experimental evaluation, Zaremba [123] employed GRU to (i) compute the digits of the sum or difference of two input numbers, (ii) predict the next character in a synthetic XML dataset and in the large words dataset Penn TreeBank, (iii) predict polyphonic music. The results showed that the GRU outperformed the LSTM on nearly all tasks except language modeling when using a naive initialization. Bianchi et al. [34] compared GRU with other recurrent networks on the prediction of superimposed oscillators. However, to the best of author's knowledge, at the moment there are no researches where the standard GRU architecture has been applied in STLF problems.
A schematic depiction of the GRU cell is reported in Fig. 4. GRU makes use of two gates. The first is the update gate, which controls how much the current content of the cell should be updated with the new candidate state. The second is the reset gate that, if closed (value near to 0), can effectively reset the memory of the cell and make the unit act as if the next processed input was the first in the sequence. The state equations of the GRU are the following: Here, g(·) is a non-linear function usually implemented by a hyperbolic tangent.
In a GRU cell, the number of parameters is larger than in the an ERNN unit, but smaller than in a LSTM cell. The parameters to be learned are the rectangular matrices W r , W z , W u , the square matrices R r , R z , R u , and the bias vectors b r , b z , b u .

Other Recurrent Neural Networks Models
In this section we describe two different types of RNNs, which are the Nonlinear AutoRegressive eXogenous inputs neural network (NARX) and the Echo State Network (ESN). Both of them have been largely employed in STLF. These two RNNs differ from the models described in Sec. 3, both in terms of their architecture and in the training procedure, which is not implemented as a BPPT. Therefore, some of the properties and training approaches discussed in Sec. 2 do not hold for these models.

NARX Network
NARX networks are recurrent dynamic architectures with several hidden layers and they are inspired by discrete-time nonlinear models called Nonlinear AutoRegressive with eXogenous inputs [124]. Differently from other RNNs, the recurrence in the NARX network is given only by the feedback on the output, rather than from the whole internal state.
NARX networks have been employed in many different applicative contexts, to forecast future values of the input signal [125,126]. Menezes and Barreto [127] showed that NARX networks perform better on predictions involving long-term dependencies. Xie et al. [128] used NARX in conjunction with an input embedded according to Takens method, to predict highly non-linear time series. NARX are also employed as a nonlinear filter, whose target output is trained by using the noise-free version of the input signal [129]. NARX networks have also been adopted by Plett [130] in a gray-box approach for nonlinear system identification.
A NARX network can be implemented with a MultiLayer Perceptron (MLP), where the next value of the output signal y[t] ∈ R Ny is regressed on d y previous values of the output signal and on d x previous values of an independent, exogenous input signal x[t] ∈ R Nx [131]. The output equation reads where φ(·) is the nonlinear mapping function performed by the MLP, Θ are the trainable network parameters, d x and d y are the input and the output time delays. Even if the numbers of delays d x and d y is a finite (often small) number, it has been proven that NARX networks are at least as powerful as Turing machines, and thus they are universal computation devices [132]. The input i[t] of the NARX network has d x N x + d y N y components, which correspond to a set of two Tapped-Delay Lines (TDLs), and it reads The structure of a MLP network consists of a set of source nodes forming the input layer, N l ≥ 1 layers of hidden nodes, and an output layer of nodes. The output of the network is governed by the following difference equations where h l [t] ∈ R N h l is the output of the l th hidden layer at time t, g(·) is a linear function and f (·) is the transfer function of the neuron, usually implemented as a sigmoid or tanh function. The weights of the neurons connections are defined by the parameters Θ = θ i , θ o , θ h1 , . . . , θ h N l . In l are the parameters of the l th hidden layer. A schematic depiction of a NARX network is reported in Fig. 5.
Due to the architecture of the network, it is possible to exploit a particular strategy to learn the parameters Θ. Specifically, during the training phase the time series relative to the desired output y * is fed into the network along with the input time series x. At this stage, the output feedback is disconnected and the network has a purely feed-forward architecture, whose parameters can be trained with one of the several, well-established standard backpropagation techniques. Notice that this operation is not possible in other recurrent networks such as ERNN, since the state of the hidden layer depends on the previous hidden state, whose ideal value is not retrievable from the training set. Once the training stage is over, the teacher signal of the desired output is disconnected and is replaced with the feedback of the predicted output y computed by the network. The procedure is depicted in Fig. 6.  Similar to what discussed in Sec. 2.2 for the previous RNN architectures, the loss function employed in the gradient descent is defined as where MSE is the error term defined in Eq. 2 and λ 2 is the hyperparameter that weights the importance of the L 2 regularization term in the loss function. Due to the initial transient phase of the network, when the estimated output y is initially fed back as network input, the first initial outputs are discarded.
Even if it reduces to a feed-forward network in the training phase, NARX network is not immune to the problem of vanishing and exploding gradients. This can be seen by looking at the Jacobian J h (t, n) of the state-space map at time t expanded for n time step. In order to guarantee network stability, the Jacobian must have all of its eigenvalues inside the unit circle at each time step. However, this results in lim n→∞ J h (t, n) = 0, which implies that NARX networks suffer from vanishing gradients, like the other RNNs [133].

Echo State Network
While most hard computing approaches and ANNs demand long training procedures to tune the parameters through an optimization algorithm [134], recently proposed architectures such as Extreme Learning Machines [135,136] and ESNs are characterized by a very fast learning procedure, which usually consists in solving a convex optimization problem. ESNs, along with Liquid State Machines [137], belong to the class of computational dynamical systems implemented according to the so-called reservoir computing framework [71].
ESNs have been extensively employed to forecast real valued time series. Niu et al. [145] trained an ESN to perform multivariate time series prediction by applying a Bayesian regularization technique to the reservoir and by pruning redundant connections from the reservoir to avoid overfitting. Superior prediction capabilities have been achieved by projecting the high-dimensional output of the ESN recurrent layer into a suitable subspace of reduced dimension [146]. An important context of application with real valued time series is the prediction of telephonic or electricity load, usually performed 1-hour and a 24-hours ahead [5,10,9,147,8]. Deihimi et al. [10] and Peng et al. [6] decomposed the time series in wavelet components, which are predicted separately using distinct ESN and ARIMA models, whose outputs are combined to produce the final result. Important results have been achieved in the prediction of chaotic time series by Li et al. [148]. They proposed an alternative to the Bayesian regression for estimating the regularization parameter and a Laplacian likelihood function, more robust to noise and outliers than a Gaussian likelihood. Jaeger and Haas [149] applied an ESN-based predictor on both benchmark and real dataset, highlighting the capability of these networks to learn amazingly accurate models to forecast a chaotic process from almost noise-free training data.
An ESN consists of a large, sparsely connected, untrained recurrent layer of nonlinear units and a linear, memory-less read-out layer, which is trained according to the task that the ESN is demanded to solve. A visual representation of an ESN is shown in Fig. 7  The difference equations describing the ESN state-update and output are, respectively, defined as follows: where is a small noise term. The reservoir contains N h neurons whose transfer/activation function f (·) is typically implemented by a hyperbolic tangent. The readout instead, is implemented usually by a linear function g(·). At time instant t, the network is driven by the input signal x[t] ∈ R Ni and produces the output y[k] ∈ R No , N i and N o being the dimensionality of input and output, respectively. The vector h[t] has N h components and it describes the ESN (instantaneous) state. The weight matrices W r r ∈ R Nr×Nr (reservoir connections), W r i ∈ R Ni×Nr (input-to-reservoir), and W r o ∈ R No×Nr (output-to-reservoir feedback) contain real values in the [−1, 1] interval drawn from a uniform distribution and are left untrained. Alternative options have been explored recently by Rodan and Tiňo [150] and Appeltant et al. [151] to generate the connection weights. The sparsity of the reservoir is controlled by a hyperparameter R c , which determines the number of nonzero elements in W r r . According to the ESN theory, the reservoir W r r must satisfy the so-called "echo state property" (ESP) [71]. This means that the effect of a given input on the state of the reservoir must vanish in a finite number of time-instants. A widely used rule-of-thumb to obtain this property suggests to rescale the matrix W r r in order to have ρ(W r r ) < 1, where ρ(·) denotes the spectral radius. However, several theoretical approaches have been proposed in the literature to tune ρ more accurately, depending on the problem at hand [152,97,153,154].
On the other hand, the weight matrices W o i and W o r are optimized for the target task. To determine them, let us consider the training sequence of T tr desired input-outputs pairs given by: where T tr is the length of the training sequence. In the initial phase of training, called state harvesting, the inputs are fed to the reservoir, producing a sequence of internal states h [1], . . . , h[T tr ], as defined in Eq. (20). The states are stacked in a matrix S ∈ R Ttr×Ni+Nr and the desired outputs in a vector y * ∈ R Ttr : The initial rows in S (and y * ) are discarded, since they refer to a transient phase in the ESN's behavior. The training of the readout consists in learning the weights in W o i and W o r so that the output of the ESN matches the desired output y * . This procedure is termed teacher forcing and can be accomplished by solving a convex optimization problem, for which several closed form solution exist in the literature. The standard approach, originally proposed by Jaeger [57], consists in applying a least-square regression, defined by the following regularized least-square problem: T and λ 2 ∈ R + is the L 2 regularization factor. A solution to problem (25) can be expressed in closed form as which can be solved by computing the Moore-Penrose pseudo-inverse. Whenever N h + N i > T tr , Eq. (26) can be computed more efficiently by rewriting it as

Synthetic time series
We consider three different synthetically generated time series in order to provide controlled and easily replicable benchmarks for the architectures under analysis. The three forecasting exercises that we study have a different level of difficulty, given by the nature of the signal and the complexity of the task to be solved by the RNN. In order to obtain a prediction problem that is not too simple, it is reasonable to select as forecast horizon a time interval t f that guarantees the measurements in the time series to become decorrelated. Hence, we consider the first zero of the autocorrelation function of the time series. Alternatively, the first minimum of the average mutual information [155] or of the correlation sum [156] could be chosen to select a t f where the signal shows a more-general form of independence. All the time series introduced in the following consist of 15.000 time steps. We use the first 60% of the time series as training set, to learn the parameters of the RNN models. The next 20% of the data are used as validation set and the prediction accuracy achieved by the RNNs on this second dataset is used to tune the hyperparameters of the models. The final model performance is evaluated on a test set, corresponding to the last 20% of the values in the time series.
Mackey-Glass time series. The Mackey-Glass (MG) system is commonly used as benchmark for prediction of chaotic time series. The input signal is generated from the MG time-delay differential system, described by the following equation: For this prediction task, we set τ MG = 17, α = 0.2, β = 0.1, initial condition x(0) = 1.2, 0.1 as integration step for (28) and the forecast horizon t f = 12.
NARMA signal. The Non-Linear Auto-Regressive Moving Average (NARMA) task, originally proposed by Jaeger [157], consists in modeling the output of the following r-order system: The input to the system x(t) is uniform random noise in [0, 1], and the model is trained to reproduce y(t+1). The NARMA task is known to require a memory of at least r past time-steps, since the output is determined by input and outputs from the last r time-steps. For this prediction task we set r = 10 and the forecast step t f = 1 in our experiments.
Multiple superimposed oscillator. The prediction of a sinusoidal signal is a relatively simple task, which demands a minimum amount of memory to determine the next network output. However, superimposed sine waves with incommensurable frequencies are extremely difficult to predict, since the periodicity of the resulting signal is extremely long. The time series we consider is the Multiple Superimposed Oscillator (MSO) introduced by Jaeger and Haas [149], and it is defined as This academic, yet important task, is particularly useful to test the memory capacity of a recurrent neural network and has been studied in detail by Xue et al. [158] in a dedicated work. Indeed, to accurately predict the unseen values of the time series, the network requires a large amount of memory to simultaneously implement multiple decoupled internal dynamics [159]. For this last prediction task, we chose a forecast step t f = 10.

Real-world load time series
In this section, we present three different real-world dataset, where the time series to be predicted contain measurements of electricity and telephonic activity load. Two of the dataset contain exogenous variables, which are used to provide additional context information to support the prediction task. For each dataset, we perform a pre-analysis to study the nature of the time series and to find the most suitable data preprocessing. In fact, forecast accuracy in several prediction models, among which neural networks, can be considerably improved by applying a meaningful preprocessing [160].

Orange dataset -telephonic activity load
The first real-world dataset that we analyze is relative to the load of phone calls registered over a mobile network. Data come from the Orange telephone dataset [161], published in the Data for Development (D4D) challenge [162]. D4D is a collection of call data records, containing anonymized events of Orange's mobile phone users in Ivory Coast, in a period spanning from December 1, 2011 to April 28, 2012. More detailed information on the data are available in Ref. [163]. The time series we consider are relative to antenna-toantenna traffic. In particular, we selected a specific antenna, retrieved all the records in the dataset relative to the telephone activity issued each hour in the area covered by the antenna and generated 6 time series: • ts1: number of incoming calls in the area covered by the antenna; • ts2: volume in minutes of the incoming calls in the area covered by the antenna; • ts3: number of outgoing calls in the area covered by the antenna; • ts4: volume in minutes of the outgoing calls in the area covered by the antenna; • ts5: hour when the telephonic activity is registered; • ts6: day when the telephonic activity is registered.
In this work, we focus on predicting the volume (in minutes) of the incoming calls in ts1 of the next day. Due to the hourly resolution of the data, the STFL problem consists of a 24 step-ahead prediction. The profile of ts1 for 300 hours is depicted in Fig. 8(a). The remaining time series are treated as exogenous  variables and, according to a common practice in time series forecasting [164], they are fed into the network to provide the model with additional information for improving the prediction of the target time series. Each time series contain 3336 measurements, hourly sampled. We used the first 70% as training set, the successive 15% as validation set and the remaining 15% as test set. The accuracy of each RNN model is evaluated on this last set. In each time series there is a (small) fraction of missing values. In fact, if in a given hour no activities are registered in the area covered by the considered antenna, the relative entries do not appear in the database. As we require the target time series and the exogenous ones to have same lengths and to contain a value in each time interval, we inserted an entry with value "0" in the dataset to fill the missing values. Another issue is the presence of corrupted data, marked by a "-1" in the dataset, which are relative to periods when the telephone activity is not registered correctly. To address this problem, we followed the procedure described by Shen and Huang [165] and we replaced the corrupted entries with the average value of the corresponding periods (same weekday and hour) from the two adjacent weeks. Contrarily to some other works on STLF [166,7,167], we decided to not discard outliers, such as holidays or days with an anomalous number of calls, nor we modeled them as separate variables.
As next step in our pre-analysis, we identify the main seasonality in the data. We analyze ts1, but similar considerations hold also for the remaining time series. Through frequency analysis and by inspecting the autocorrelation function, depicted as a gray line in Fig. 8(b), it emerges a strong seasonal pattern every 24 hours. As expected, data experience regular and predictable daily changes, due to the nature of the telephonic traffic. This cycle represents the main seasonality and we filter it out by applying a seasonal differencing with lag 24. In this way, the RNNs focus on learning to predict the series of changes in each seasonal cycle. The practice of removing the seasonal effect from the time series, demonstrated to improve the prediction accuracy of models based on neural networks [168,169]. The black line in Fig. 8(b) depicts the autocorrelation of the time series after seasonal differentiation. Except from the high anticorrelation at lag 24, introduced by the differentiation, the time series appears to be uncorrelated elsewhere and, therefore, we can exclude the presence of a second, less obvious seasonality.
Due to the nature of the seasonality in the data, we expect a strong relationship between the time series of the loads (ts1 -ts4) and ts5, which is relative to the hour of the day. On the other hand, we envisage a lower dependency of the loads with ts6, the time series of the week days, since we did not notice the presence of a second seasonal cycle after the differentiation at lag 24. To confirm our hypothesis, we computed the mutual information between the time series, which are reported in the Hinton diagram in Fig. 9. The size of the blocks is proportional to the degree of mutual information among the time series. Due to absence of strong relationships, we decided to discard ts6 to reduce the complexity of the model by excluding a variable with potentially low impact in the prediction task. We also discarded ts5 because the presence of the cyclic daily pattern is already accounted by doing the seasonal differencing at lag 24. Therefore, there is not need to provide daily hours as an additional exogenous input. Beside differentiation, a common practice in STLF is to apply some form of normalization to the data. We applied a standardization (z-score), but rescaling into the interval [−1, 1] or [0, 1] are other viable options. Additionally, a nonlinear transformation of the data by means of a non-linear function (e.g., square-root or logarithm) can remove some kinds of trend and stabilize the variance in the data, without altering too much their underlying structure [170,7,166]. In particular, a log-transform is suitable for a set of random variables characterized by a high variability in their statistical dispersion (heteroscedasticity), or for a process whose fluctuation of the variance is larger than the fluctuation of the mean (overdispersion). To check those properties, we analyze the mean and the variance of the telephonic traffic within the main seasonal cycle across the whole dataset. The solid black line in Fig. 10(a), represents the mean load of ts1, while the shaded gray area illustrates the variance. As we can see, the data are not characterized by overdispersion, since the fluctuations of the mean are greater than the ones of the variance. However, we notice the presence of heteroscedasticity, since the amount of variance changes in different hours of the day. In fact, the central hours where the amount of telephonic activity is higher, are characterized by a greater standard deviation in the load. In Fig. 10(b), we observe that by applying a log-transform we significantly reduce the amount of variance in the periods characterized by a larger traffic load. However, after the log-transformation the mean value of the load become more flattened and the variance relative to periods with lower telephonic activity is enhanced. This could cause issues during the training of the RNN, hence in the experiments we evaluate the prediction accuracy both with and without applying the log-transformation to the data. Preprocessing transformations are applied in this order: (i) log-transform, (ii) seasonal differencing at lag 24, (iii) standardization. Each preprocessing operation is successively reversed to evaluate the forecast produced by each RNN.

ACEA dataset -electricity load
The second time series we analyze is relative to the electricity consumption registered by ACEA (Azienda Comunale Energia e Ambiente), the company which provides the electricity to Rome and some neighbouring regions. The ACEA power grid in Rome consists of 10.490 km of medium voltage lines, while the low voltage section covers 11.120 km. The distribution network is constituted of backbones of uniform section, exerting radially and with the possibility of counter-supply if a branch is out of order. Each backbone is fed by two distinct primary stations and each half-line is protected against faults through the breakers. Additional details can be found in Ref. [171]. The time series we consider concerns the amount of supplied electricity, measured on a medium voltage feeder from the distribution network of Rome. Data are collected every 10 minutes for 954 days of activity (almost 3 years), spanning from 2009 to 2011, for a total of 137444 measurements. Also in this case, we train the RNNs to predict the electricity load 24h ahead, which corresponds to 144 time step ahead prediction. For this forecast task we do not provide any exogenous time series to the RNNs. In the hyperparameter optimization, we use the load relative to the first 3 months as training set and the load of the 4 th month as validation set. Once the best hyperparameter configuration is identified, we fine-tune each RNN on the first 4 months and we use the 5 th month as test set to evaluate and to compare the accuracy of each network.  A profile of the electric consumption over one week (1008 measurements), is depicted in Fig. 11(a). In the ACEA time series there are no missing values, but 742 measurements (which represent 0.54% of the whole dataset) are corrupted. The consumption profile is more irregular in this time series, with respect to the telephonic data from the Orange dataset. Therefore, rather than replacing the corrupted values with an average load, we used a form of imputation with a less strong bias. Specifically, we first fit a cubic spline to the whole dataset and then we replaced the corrupted entries with the corresponding values from the fitted spline. In this way, the imputation better accounts for the local variations of the load.
Also in this case, we perform a preemptive analysis in order to understand the nature of the seasonality, to detect the presence of hidden cyclic patterns, and to evaluate the amount of variance in the time series. By computing the autocorrelation function up to a sufficient number of lags, depicted as a gray line in Fig. 11(b), it emerges a strong seasonality pattern every 144 time intervals. As expected, this corresponds exactly to the number of measurements in one day. By differencing the time series at lag 144, we remove the main seasonal pattern and the trend. Also in this case, the negative peak at lag 144 is introduced by the differentiation. If we observe the autocorrelation plot of the time series after seasonal differencing (black line in 11(b)), a second strong correlation appears each 1008 lags. This second seasonal pattern represents a weekly cycle, that was not clearly visible before the differentiation. Due to the long periodicity of the time cycle, to account this second seasonality a predictive model would require a large amount of memory to store information for a longer time interval. While a second differentiation can remove this second seasonal pattern, we would have to discard the values relative to the last week of measurements. Most importantly, the models we train could not learn the similarities in consecutive days at a particular time, since they would be trained on the residuals of the load at the same time and day in two consecutive weeks. Therefore, we decided to apply only the seasonal differentiation at lag 144.
To study the variance in the time series, we consider the average daily load over the main seasonal cycle of 144 time intervals. As we can see from Fig. 12(a), data appear to be affected by overdispersion, as the standard deviation (gray shaded areas) fluctuates more than the mean. Furthermore, the mean load value (black solid line) seems to not change much across the different hours, while it is reasonable to expect significant differences in the load between night and day. However, we remind that the Acea time series spans a long time lapse (almost 3 years) and that the electric consumption is highly related to external factors such as temperature, daylight saving time, holidays and other seasonal events that change over time. Therefore, in different periods the load profile may vary significantly. For example, in Fig. 12(b) we report the load profile relative to the month of January, when temperatures are lower and there is a high consumption of electricity, also in the evening, due to the usage of heating. In June instead (Fig. 12(c)), the overall electricity consumption is lower and mainly concentrated on the central hours of the day. Also, it is possible to notice that the load profile is shifted due to the daylight saving time. As we can see, the daily averages within a single month are characterized by a much lower standard deviation (especially in the summer months, with lower overall load consumption) and the mean consumption is less flat. Henceforth, a non-linear transformation for stabilizing the variance is not required and, also in this case, standardization is suitable for normalizing the values in the time series. Since we focus on a short term forecast, having a high variance in loads relative to very distant periods is not an issue, since the model prediction will depends mostly on the most recently seen values.
To summarize, as preprocessing operation we apply: (i) seasonal differencing at lag 144, (ii) standardization. As before, the transformations are reverted to estimate the forecast.

GEFCom2012 dataset -electricity load
The last real world dataset that we study is the time series of electricity consumption from the Global Energy Forecasting Competition 2012 (GEF-Com2012) [172]. The GEFCom 2012 dataset consists of 4 years (2004 -2007) of hourly electricity load collected from a US energy supplier. The dataset comprehends time series of consumption measurements, from 20 different feeders in the same geographical area. The values in each time series represent the average hourly load, which varies from 10.000kWh to 200.000kWh. The dataset also includes time series of the temperatures registered in the area where the electricity consumption is measured.
The forecast task that we tackle is the 24 hours ahead prediction of the aggregated electricity consumption, which is the sum of the 20 different load time series in year 2006. The measurements relative to the to first 10 months of the 2006 are used as training set, while the 11 th month is used as validation set for guiding the hyperparameters optimization. The time series of the temperature in the area is also provided to the RNNs as an exogenous input. The prediction accuracy of the optimized RNNs is then evaluated on the last month of the 2006. A depiction of the load profile of the aggregated load time series is reported in Fig. 13(a). We can observe a trend in the time series, which indicates a decrement in the energy demand over time. This can be related to climate conditions since, as the temperature becomes warmer during the year, the electricity consumption for the heating decreases.
To study the seasonality in the aggregated time series, we evaluate the autocorrelation function, which is depicted as the gray line in Fig. 13(b). From the small subplot in top-right part of the figure, relative to a small segment of the time series, it emerges a strong seasonal pattern every 24 hours. By applying a seasonal differentiation with lag 24 the main seasonal pattern is removed, as we can see from the autocorrelation function of the differentiated time series, depicted as a black line in the figure. After differentiation, the autocorrelation becomes close to zero after the first lags and, therefore, we can exclude the presence of a second, strong seasonal pattern (e.g. a weekly pattern).
Similarly to what we did previously, we analyze the average load of the electricity consumption during one week. As for the ACEA dataset, rather than considering the whole dataset, we analyze separately the  load in one month of winter and one month in summer. In Fig. 14(a), we report the mean load (black line) and standard deviation (gray area) in January. Fig. 14(b) instead, depicts the measurements for May. It is possible to notice a decrement of the load during the spring period, due to the reduced usage of heating. It is also possible to observe a shift in the consumption profile to later hours in the day, due to the time change.
By analyzing the amount of variance and the fluctuations of the mean load, we can exclude the presence of overdispersion and heteroscedasticity phenomena in the data.
To improve the forecasting accuracy of the electricity consumption, a common practice is to provide to the prediction system the time series of the temperature as an exogenous variable. In general, the load and the temperature are highly related, since both in the coldest and in the warmest months electricity demand increases, due to the usage of heating and air conditioning, respectively. However, the relationship between temperature and load cannot be captured by the linear correlation, since the consumption increases both when temperatures are too low or too high. Indeed, the estimated correlation between the aggregated load time series of interest and the time series of the temperature in the area yields only a value of 0.2. However, their relationship is evidenced by computing a 2-dimensional histogram of the two variables, proportional to their estimated joint distribution, which is reported in Fig 15. The V-shape, denotes an increment of the electricity consumption for low and high temperatures with respect to a mean value of about 22 • C.
The preprocessing operations we apply on the GEFCom dataset are: (i) seasonal differencing at lag 24, (ii) standardization. Also in this case, these transformations are reverted to estimate the forecast.

Experiments
In this section we compare the prediction performance achieved by the network architectures presented in Sec. 3 and 4 on different time series. For each architecture, we describe the validation procedure we follow to tune the hyperparameters and to find an optimal learning strategy for training the weights. During the validation phase, different configurations are randomly selected from admissible intervals and, once the training is over, their optimality is evaluated as the prediction accuracy achieved on the validation set. We opted for a random search as it can find more accurate results than a grid search, when the same number of configurations are evaluated [173]. Once the (sub)optimal configuration is identified, we train each model 10 times on the training and validation data, using random and independent initializations of the network parameters, and we report the highest prediction accuracy obtained on the unseen values of the test set.
To compare the forecast capability of each model, we evaluate the prediction accuracy ψ as ψ = 1 − NRMSE. NRMSE is the Normalized Root Mean Squared Error that reads where · computes the mean, Y are the RNN outputs and Y * are the ground-truth values.
In the following, we present two types of experiments. The first experiment consists in the prediction of the synthetic time series presented in Sec. 5, commonly considered as benchmarks in forecast applications, and the results are discussed in Sec. 7.2. In the second experiment we forecast the real-world telephonic and electricity load time series, presented in Sec. 6. The results of this second experiment are discussed in Sec. 7.3.

Experimental settings
ERNN, LSTM and GRU. The three RNNs described in Sec. 3 have been implemented in Python, using Keras library with Theano [174] as backend 3 .
To identify an optimal configuration for the specific task at hand, we evaluate for each RNN different values of the hyperparameters and training procedures. The configurations are selected randomly and their performances are evaluated on the validation set, after having trained the network for 400 epochs. To get rid of the initial transient phase, we drop the first 50 outputs of the network. A total of 500 random configurations for each RNN are evaluated and, once the optimal configuration is found, we compute the prediction accuracy on the test set. In the test phase, each network is trained for 2000 epochs.
The optimization is performed by assigning to each hyperparameter a value uniformly sampled from a given interval, which can be continuous or discrete. The gradient descent strategies are selected from a set of possible alternatives, which are SGD, Nesterov momentum and Adam. For SGD and Nesterov, we anneal the learning rate with a step decay of 10 −6 in each epoch. The learning rate η is sampled from different intervals, depending on the strategy selected. Specifically, for SGD we set η = 10 c , with c uniformly sampled in [−3, , an interval containing values commonly assigned to these hyperparameters in RNNs [175]. We apply the same regularization to input, recurrent and output weights. As suggested by Gal and Ghahramani [77], we drop the same input and recurrent connections at each time step in the BPTT, with a dropout probability p drop drawn from {0, 0.1, 0.2, 0.3, 0.5}, which are commonly used values [176]. If p drop = 0, we also apply a L 2 regularization. This combination usually yields a lowest generalization error than dropout alone [177]. Note that another possible approach combines dropout with the max-norm constraint, where the L 2 norm of the weights is clipped whenever it grows beyond a given constant, which, however, introduces another hyperparameter.
For the training we consider the backpropagation through time procedure BPTT(τ b , τ f ) with τ b = 2τ f . The parameter τ f is randomly selected from the set {10, 15, 20, 25, 30}. As we discussed in Sec. 2.1, this procedure differs from both the true BPTT and the epochwise BPTT [75], which is implemented as default by popular deep learning libraries such as TensorFlow [178].
NARX. This RNN is implemented using the Matlab Neural Network toolbox 4 . We configured NARX network with an equal number of input and output lags on the TDLs (d x = d y ) and with the same number of neurons N h in each one of the N l hidden layers. Parameters relative to weight matrices and bias values Θ = θ , θ o , θ h1 , . . . , θ h N l are trained with a variant of the quasi Newton search, called Levenberg-Marquardt optimization algorithm. This is an algorithm for error backpropagation that provides a good tradeoff between the speed of the Newton algorithm and the stability of the steepest descent method [179]. The loss function to be minimized is defined in Eq. 19.
A total of 500 random configurations for NARX are evaluated and, for each hyperparameters setting, the network is trained for 1000 epochs in the validation. In the test phase, the network configured with the optimal hyperparameters is trained for 2000 epochs. Also in this case, we discard the first 50 network outputs to get rid of the initial transient phase of the network.
ESN. For the ESN, we used a modified version of the Python implementation 5 , provided by Løkse et al. [146]. Learning in ESN is fast, as the readout is trained by means of a linear regression. However, the training does not influence the internal dynamics of the random reservoir, which can be controlled only through the ESN hyperparameters. This means that a more accurate (and computationally intensive) search of the optimal hyperparametyers is required with respect to the other RNN architectures. In RNNs, the precise, yet slow gradient-based training procedure is mainly responsible for learning the necessary dynamics and it can compensate a suboptimal choice of the hyperparameters.
Therefore, in the ESN validation phase we evaluate a larger number of configurations (5000), by uniformly drawing 8 different hyperparameters from specific intervals. In particular, the number of neurons in the reservoir, N h , is drawn from {400, 450, . . . , 900}; the reservoir spectral radius, ρ, is drawn in the interval

Results on synthetic dataset
In Fig. 16 we report the prediction accuracy obtained by the RNNs on the test set of the three synthetic problems. The best configurations of the architectures identified for each task through random search are reported in Tab First of all, we observe that the best performing RNN is different in each task. In the MG task, ESN outperforms the other networks. This result confirms the excellent and well-known capability of the ESN in predicting chaotic time series [180,149]. In particular, ESN demonstrated to be the most accurate architecture for the prediction of the MG system [181]. The ESN achieves the best results also in the MSO task, immediately followed by ERNN. On the NARMA task instead, ESN performs poorly, while the LSTM is the RNN that predicts the target signal with the highest accuracy. In each test, NARX struggles in reaching performance comparable with the other architectures. In particular, in NARMA and MSO task the NRMSE prediction error of NARX is 0.53 and 1.99, respectively (note that we cut the y-axis to better show the remaining bars). Note that, since the NRMSE is normalized by the variance of the target signal, an error greater than 1 means that the performance is worse than a constant predictor, with value equal to the mean of the target signal.
It is also interesting to notice that in MSO, ERNN achieves a prediction accuracy higher than GRU and LSTM. Despite the fact that the MSO task demands a large amount of memory, due to the extremely long periodicity of the target signal, the two gated architectures (LSTM and GRU) are not able to outperform the ERNN. We can also notice that for MSO the optimal number of hidden nodes (N h ) is lower than in the other tasks. A network with a limited complexity is less prone to overfit on the training data, but it is also characterized by an inferior modeling capability. Such a high modeling capability is not needed to solve the MSO task, given that the network manages to learn correctly the frequencies of the superimposed sinusoidal signals.
Finally, we observe that LSTM and GRU performs similarly on the each task, but there is not a clear winner. This finding is in agreement with previous studies, which, after several empirical evaluations, concluded that it is difficult to choose in advance the most suitable gated RNN to solve a specific problem [122].
Regarding the gradient descent strategies used to train the parameters in RNN, LSTM and GRU, we observe in Tab. 1 that Adam is often identified as the optimal strategy. The standard SGD is selected only for GRU in the MG task. This is probably a consequence of the lower convergence rate of the SGD minimization, which struggles to discover a configuration that achieves a good prediction accuracy on the validation set in the limited amount (400) of training epochs. Also, the Nesterov approach seldom results to be as the optimal strategy and a possible explanation is its high sensitivity to the (randomly selected) learning rate. In fact, if the latter is too high, the gradient may build up too much momentum and bring the weights into a configuration where the loss function is very large. This results in even greater gradient updates, which leads to rough oscillations of the weights that can reach very large values.
From the optimal configurations in Tab. 1, another striking behavior about the optimal regularization procedures emerges. In fact, we observe that in each RNN and for each task, only the L 2 norm of the weights is the optimal regularizer. On the other hand, the parameters λ 1 and p drop relative to the L 1 norm and the dropout are always zero. This indicates that, to successfully solve the synthetic prediction tasks, it is sufficient to train the networks with small weights in order to prevent the overfitting.
Finally, we notice that the best results are often found using network with a high level of complexity, in terms of number of neurons and long windows in BPTT or TDL, for Narx. In fact, in most cases the validation procedure identifies the optimal values for these variables to be close to the upper limit of their admissible intervals. This is somehow expected, since a more complex model can achieve higher modeling capabilities, if equipped with a suitable regularization procedure to prevent overfitting during training. However, the tradeoff in terms of computational resources for training more complex models is often very high and small increments in the performance are obtained at the cost of much longer training times.

Results on real-world dataset
The highest prediction accuracies obtained by the RNNs on the test set (unseen data) of the real-world load time series, are reported in Fig. 17. As before, in Tab. 2 we report the optimal configuration of each RNN for the different tasks. Orange. All the RNNs achieve very similar prediction accuracy on this dataset, as it is possible to see from the first bar plot in Fig. 17. In Fig. 18 we report the residuals, depicted as black areas, between the target time series and the forecasts of each RNN. The figure gives immediately a visual quantification of the accuracy, as the larger the black areas, the greater the prediction error in that parts of the time series.
In particular, we observe that the values which the RNNs fail to predict are often relative to the same interval. Those values represent fluctuations that are particularly hard to forecast, since they correspond to unusual increments (or decrements) of load, which differ significantly from the trend observed in the past. For example, the error increases when the load suddenly grows in the last seasonal cycle in Fig. 18.
In the Orange experiment we evaluate the results with or without applying a log transform to the data. We observed sometime log-transform yields slightly worse result (∼ 0.1%), but in most cases the results are equal.
For ERNN SGD is found as optimal, which is a slower yet more precise update strategy and is more suitable for gradient descent if the problem is difficult. ERNN takes into account a limited amount of past information, as the window in the BPTT procedure is set to a relatively small value.
Like ERNN, also for GRU the validation procedure identified SGD as the optimal gradient descent strategy. Interestingly, L 1 regularization is used, while in all the other cases it is not considered. On the other hand, the L 2 regularization parameter is much smaller.
In the optimal NARX configuration, TDL is set to a very small value. In particular, since the regression is performed only on the last 2 time intervals, the current output depends only on the most recent inputs and estimated outputs. From the number of hidden nodes and layers, we observe that the optimal size of the network is relatively small.
Relatively to the ESN configuration, we notice a very small spectral radius. This means that, also in this case, the network is configured with a small amount of memory. This results in reservoir dynamics that are more responsive and, consequently, in outputs that mostly depend on the recent inputs. As a consequence, the value of input scaling is small, since there is no necessity of quickly saturating the neurons activation.
ACEA. The time series of the electricity load is quite regular except for few, erratic fluctuations. As for the Orange dataset, RNN predictions are inaccurate mainly in correspondence of such fluctuations, while they output a correct prediction elsewhere. This behavior is outlined by the plots in Fig. 19, where we observe that the residuals are small and, in each RNN prediction, they are mostly localized in common time intervals. From the NRMSE values in Fig. 17, we see that ESN performs better than the other networks. The worst performance is obtained by NARX, while the gradient-based RNNs yield better results, which are very similar to each other. In ERNN and GRU, the optimal regularization found is the L 2 norm, whose coefficient assumes a small value. In LSTM instead, beside the L 2 regularization term, the optimal configuration includes also a dropout regularization with a small probability. The BPTT windows have comparable size in all the gradient-based networks.
The optimal NARX configuration for ACEA is very similar to the one identified for Orange and is characterized by a low complexity in terms of number of hidden nodes and layers. Also in this case the TDLs are very short.
Similarly to the optimal configuration for Orange, the ESN spectral radius assumes a small value, meaning that the network is equipped with a short-term memory and it captures only short temporal correlations in the data. The reservoir is configured with a high connectivity, which yields more homogeneous internal dynamics. GEFCom. This time series is more irregular than the previous ones, as it shows a more noisy behavior that is harder to be predicted. From Fig. 20 we see that the extent of the black areas of the residual is much larger than in the other datasets, denoting a higher prediction error. From the third panel in Fig. 17 we observe larger differences in the results with respect to the previous cases. In this dataset, the exogenous time series of temperature plays a key role in the prediction, as it conveys information that are particularly helpful to yield a high accuracy. The main reason of the discrepancy in the results for the different networks may be in their capability of correctly leveraging this exogenous information for building an accurate forecast model.
From the results, we observe that the gradient-based RNNs yield the best prediction accuracy. In particular, ERNN and GRU generate a prediction with the lowest NRMSE with respect to the target signal. ESN, instead, obtains considerably lower performance. Like for the syntethic datasets NARMA and MSO, NARX produces a very inaccurate prediction, scoring a NRMSE which is above 1.
The optimal ERNN configuration consists of only 60 nodes.
For LSTM, the optimal configuration includes only 20 hidden units, which is the lowest amount admitted in the validation search and SGD is the best as optimizer.
The optimal configuration for GRU is characterized by a large BPTT window, which assumes the maximum value allowed. This means that the network benefits from considering a large amount of past values to compute the prediction. As in LSTM, the number of processing units is very low. The best optimizer is Adam initialized with a particularly small learning rate, which yields a slower but more precise gradient update.
The optimal configuration of NARX network is characterized by a quite large number of hidden nodes and layers, which denote a network of higher complexity with respect to the ones identified in the other tasks. This can be related to the TDL larger values, which require to be processed by a network with greater modeling capabilities.
For ESN, we notice an extremely large spectral radius, close to the maximum value admitted in the random search. Consequently, also the value of the input scaling is set to a high number, to increase the amount of nonlinerarity in the processing units. The output scaling is set close to 1, meaning that the teacher signal is almost unchanged when fed into the training procedure. A feedback scaling close to zero means that the feedback is almost disabled and it is not used by the ESN to update its internal state.

Conclusions
In this paper we studied the application of recurrent neural networks to time series prediction, focusing on the problem of short term load forecasting. We reviewed five different architectures, ERNN, LSTM, GRU, NARX, and ESN, explaining their internal mechanisms, discussing their properties and the procedures for the training. We performed a comparative analysis of the prediction performance obtained by the different networks on several time series, considering both synthetic benchmarks and real-world short term forecast problems. For each network, we outlined the scheme we followed for the optimization of its hyperparameters. Relative to the real-world problems, we discussed how to preprocess the data according to a detailed analysis of the time series. We completed our analysis by comparing the performance of the RNNs on each task and discussing their optimal configurations.
From our experiments we can draw the following important conclusions. There is not a specific RNN model that outperforms the others in every prediction problem. The choice of the most suitable architecture depends on the specific task at hand and it is important to consider more training strategies and configurations for each RNN. On average, the NARX network achieved the lowest performance, especially on synthetic problems NARMA and MSO, and on the GEFCom dataset.
The training of gradient-based networks (ERNN, LSTM and GRU) is slower and in general more complex, due to the unfolding and backpropagation through time procedure. However, while some precautions need to be taken in the design of these networks, satisfactory results can be obtained with minimal fine-tuning and by selecting default hyperparameters. This implies that a strong expertise on the data domain is not always necessary.
The results obtained by the ESN are competitive in most tasks and the simplicity of its implementation makes it an appealing instrument for time series prediction. ESN is characterized by a faster training procedure, but the performance heavily depends on the hyperparameters. Therefore, to identify the optimal configuration in the validation phase, ESN requires a search procedure of the hyperparameters that is more accurate than in gradient-based models.
Another important aspect highlighted by our results is that the gated RNNs (LSTM and GRU) did not perform particularly better than an ERNN, whose architecture is much simpler, as well as its training. While LSTM and GRU achieve outstanding results in many sequence learning problems, the additional complexity of the complicated gated mechanisms seems to be unnecessary in many time series predictions tasks.
We hypothesize as a possible explanation that in sequence learning problems, such as the ones of Natural Language Processing [182], the temporal dependencies are more irregular than in the dynamical systems underlying the load time series. In natural language for example, the dependency from a past word can persist for a long time period and then terminate abruptly when a sentence ends. Moreover, there could exist relations between very localized chunks of the sequence. In this case, the RNN should focus on a specific temporal segment.
LSTM and GRU can efficiently model these highly nonlinear statistical dependencies, since their gating mechanisms allow to quickly modify the memory content of the cells and the internal dynamics. On the other hand, traditional RNNs implement smoother transfer functions and they would require a much larger complexity (number of units) to approximate such nonlinearities. However, in dynamical systems with dependencies that decay smoothly over time, the features of the gates may not be necessary and a simple RNN could be more suitable for the task. Therefore, we conclude by arguing that ERNN and ESN may represent the most convenient choice in time series prediction problems, both in terms of performance and simplicity of their implementation and training.