title: Auxiliary Network: Scalable and agile online learning for dynamic system with inconsistently available inputs
authors: Rohit Agarwal Arif Ahmed Sekh Krishna Agarwal Dilip K. Prasad
text: 
  
  Adaptive Neural Network-Based Approximation to  Accelerate Eulerian Fluid Simulation
      Dong Li
      Received: date / Accepted: date
  ====================================================================================
  
  
  
  
    Streaming classification methods assume the number of input features is fixed and always received. But in many real-world scenarios demand is some input features are reliable while others are unreliable or inconsistent. In this paper, we propose a novel deep learning-based model called Auxiliary Network (Aux-Net), which is scalable and agile. It employs a weighted ensemble of classifiers to give a final outcome. The Aux-Net model is based on the hedging algorithm and online gradient descent. It employs a model of varying depth in an online setting using single pass learning. Aux-Net is a foundational work towards scalable neural network model for a dynamic complex environment requiring ad hoc or inconsistent input data. The efficacy of Aux-Net is shown on public dataset.
  
  
  
  
  
  
  
  
  
  
  
  § INTRODUCTION
  
  
  
  Machine learning architectures that support varying number of input features can be a game changer in many real life applications which deal with learning in dynamic complex environments. Examples include imparting intelligence to a node in ad hoc communication networks, a device in smart city environment, and an autonomous vehicle in complex driving environment. To model such dynamic environment of inconsistent and scalable nature with assumption some reliable data channels as base channels from on-board sensor array, which we refer to as base input features and denote as {x^B_1, …, x^B_b, …, x^B_B}. In addition, it may receive other information about the environment through auxiliary sensor arrays or communication channels. We call the corresponding input features as auxiliary input features, denote them by {x^A_1, …, x^A_a, …, x^A_A}.
  Here, x denotes input features, B in superscript and subscript denotes base feature and the number of base features respectively. Similarly, A in superscript and subscript denotes auxiliary feature and the number of auxiliary features respectively.
  Due to the intermittent availability, only a subset of auxiliary features arrive along with the base features at any time instance t as shown in Figure <ref>.
  This problem can be approached in either  minimalist or maximalist approach. In the minimalist approach, all uncertain inputs are dropped and a single knowledge model is trained using only the base input features.
  This knowledge model provides certain base accuracy, but does not utilize the additional information from auxiliary inputs.
  The trade-off is the loss of opportunity for better performance.
  In the maximalist approach, an ensemble of 2^A networks can be formed to cater for all possible combinations of availability of auxiliary features. Therefore the network with the smallest dimensionality caters to only the base features and the network with the largest dimensionality caters to all the base and auxiliary features, where we refer to the number of inputs to a network as its dimensionality. However, learning the knowledge model in such ensemble of networks is cumbersome, as explained next. Given A_t inputs features at a time t, 2^A_t subsets of these features can be formed and therefore the network corresponding to each subset needs to be trained. This results into long training durations, further illustrated in supplementary. Another trade-off is that huge number of networks need to be maintained throughout. An ideal solution would be an agile and scalable network architecture that adapts itself to the availability of auxiliary inputs without needing to maintain or train multiple networks.
  
  
  
  
  
  In this paper, we present a new paradigm of learning in the presence of inconsistently available auxiliary inputs, which we call auxiliary network (Aux-Net). The key-stone of Aux-net is the separation of learning corresponding to the auxiliary inputs and the base inputs into separate modules parallel to each other (see Figure <ref>). The base features are processed as a chunk in the base module while the auxiliary module contains one independent layer per auxiliary input in parallel with the other layers. Therefore, the dimensionality of the active network can be varied by simply freezing the portion corresponding to an unavailable auxiliary input. In this manner, the knowledge base of Aux-Net corresponds to the maximalist approach, where as the active knowledge model of suitable dimensionality can be invoked from it in an agile manner. Support for knowledge models of various dimensionalities makes our approach scalable. At the same time, agility of our framework and stability during dynamic operation is attributed to the special output weighing mechanism of the auxiliary block which dynamically spools the relative contribution of the auxiliary data depending on the availability of the auxiliary features and their influence on the final outcome.
  
  We construct the initial framework on the basis of online deep learning (ODL) method <cit.> and show our results on Italy power demand dataset <cit.>. We observe robust, agile, and scalable performance of Aux-Net in situations as challenging as half of inputs being available 50% of the time and when all except one inputs are intermittently available. We show that in the most challenging scenarios, Aux-Net performs quite close to ODL (trained using only the base features) even while supporting agility and in the more favorable scenarios, it performs better than ODL.
  
  The outline of the paper is as follows. Related work is discussed in section <ref>. Aux-Net is presented in section <ref> and diverse numerical experiments and its discussion are presented in section <ref>. The paper is concluded in section <ref> and the broader impact of this work is presented in the last section.
  
  
  
  
  
  
  
  
  
  
  
  § RELATED WORKS
  
  
  
  Many methods based on Bayesian theory <cit.>, k-nearest neighbour <cit.>, support vector machines <cit.>, decision tree <cit.>, fuzzy logic <cit.> are proposed for streaming classification task. A brief study of all these techniques can be found in <cit.>. Furthermore, some incremental learning approaches are also proposed <cit.>. Other deep learning approaches for online learning include <cit.>. A limitation of these techniques are that they assume that the dimension of the incoming data is fixed. Hou et al. <cit.> proposed machine learning approaches for dynamic environments. However, they assumed that the dimensionality of the inputs is constant in batches and therefore batch wise learning can be used.
  Hou et al. <cit.> further assume that there are multiple sets of features, where one entire set is either available or unavailable in a given batch.
  Hou et al. <cit.> assumes that there is an overlapping period between two batches when all the inputs from previous and next batches are available, which allows in supporting soft transition across batches. These methods are indeed more scalable than approaches that assume fixed input dimensionality. Nonetheless, they cannot handle as challenging situations as depicted in Figure <ref> where no assumption is made on availability of auxiliary features in batches or sets. To the best of our knowledge, our work is a foundational work for problems in which the inputs may be inconsistently unavailable at any time instance. The only assumption of our work is that there is at least one base feature consistently available. Our work has a more general premise and the premises of all the above mentioned works can be considered as subsets of our premise. We note that our framework is inspired from the concept of hedge algorithm <cit.> and online gradient descent (OGD) <cit.> used in deep neural network (DNN) as proposed in ODL <cit.>, but ODL also assumes that all the features are consistently available.
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  § AUXILIARY NETWORK (AUX-NET)
  
  
  
  
  
  
  
  
  
   §.§ Problem Setting
  
  Let's denote the streaming classification data by D = {(x_1, y_1), ..., (x_t, y_t), ..., (x_T, y_T)} where x_t = {x^B_t, x^A_t_t} is the input at time instance t. The base features are denoted by x^B_t = {x^B_1,t,...,x^B_b,t,...,x^B_B,t}, where B in superscript and subscript denotes the base features and total number of base features respectively and x^B_b,t denotes the b^th base feature at time instance t.
  The auxiliary features at any time instance t is represented by x^A_t_t = {x^A_j,t}_∀ j ∈ A_t where A_t ⊆{1,...,a,...A} is the subset of auxiliary features received at time instance t. The A in superscript and subscript denotes the auxiliary features and total number of auxiliary features respectively and x^A_a,t denotes the a^th auxiliary feature at time instance t.
  The input x_t ∈ℝ^d_t where d_t is the dimension of x_t varying with time t as shown in Figure <ref>.
  The output y_t ∈ℝ^C is the class label associated with x_t where C is the total number of classes.
  The Aux-Net learns a mapping F:ℝ^d_t→ℝ^C. The prediction of the model is given by ŷ_̂t̂ = F(x_t). The model trains in an online setting where at any time instance t, the input feature x_t arrives, the model predicts an output ŷ_̂t̂, the actual output y_t is revealed and an update is made to the model based on the loss L(ŷ_̂t̂, y_t) incurred. Exhaustive list of all the notations is given in the supplementary.
  
  
  
  
   §.§ Architecture
  
  Consider a DNN with S number of base layers, one middle layer, A number of auxiliary layers and E number of end layers. The base layers, middle layer, auxiliary layers and end layers constitute the base module, middle module, auxiliary module and end module respectively.
  The base, middle and end modules are stacked sequentially and auxiliary module is placed in parallel to the base and middle module with a connection to the end module as shown in the Figure <ref>.
  A softmax classifier is attached to each of the layer.
  The detailed architecture of the model is presented in Figure <ref>.
  The output of the Aux-Net model is given as the weighted combination of all the classifiers by the equation:
  
  
  
  
      F(x) = ∑_Z ∈ U∑_z=1^Zα^Z_zf^Z_z
  
  where U = {S,M,E,A} denotes all the modules, and S,M,E,A in superscript and subscript denotes the module name and the total number of layers in the module respectively. The notation f^Z_z and  α^Z_z  represents the output of the classifier associated with the layer z of the module Z and weight of the classifier respectively.
  
  The architecture of each layer is shown in Figure <ref>(b). Each layer is attached to a classifier f parameterized by θ that gives an output as f^Z_z = softmax (h^Z_z θ^Z_z), where h^Z_z is the hidden feature of the layer. Each layer is parameterized by W and c that takes the hidden feature of the previous layers as an input, and generates its hidden feature as h^Z_z = σ(W^Z_zh^Z_z-1 + c^Z_z),
  where σ is the activation function and θ, W and c are learnt using OGD approach.
  A hedge block is used to compute α based on the loss incurred by the classifier.
  
  Now, we describe the inputs to the different layers. The first base layer receives the complete x^B_t as the input i.e. h^Z_0 = x^B_t. The subsequent base layers receive the hidden feature of its previous layer as its input. The middle layer receive the hidden feature of the last base layer as its input, i.e.  h^M_0 = h^S_S. The a^ th auxiliary layer receives the a^ th auxiliary feature as its input, i.e., h^A_a = x^A_a. All the end layers, except the first end layer receive its previous layer features as the input. The first end layer is special in terms of the input since the input to it needs to support agility arising from only a subset of auxiliary features being available at any time instance t. The input h^E_0,t to the first end layer at time instance t is a vector derived by concatenating weighted hidden features h of the middle and the auxiliary layers corresponding to the currently available auxiliary inputs. It is therefore given by h^E_0,t =[ γ^M_1,th^M_1,t,   {γ^A_j,t h^A_j,t}_∀ j ∈ A_t],
  where γ is the importance of the layers connected to first end layer denoting the fraction of the connected layer's output passed as an input to the first end layer.
  
  
  
   §.§ Parameters Learning
  
  The learning of the model occurs in an online setting through the use of a loss function defined as:
  
  
  
  
      L(F(x),y) = ∑_Z ∈ U∑_z=1^Zα^Z_zL(f^Z_z(x), y)
  
  where L(f^Z_z(x), y) is the loss of the classifier associated with layer z of the module Z. On the basis of the loss incurred at each time step, the values of γ, θ, W, c, α are updated as described next.
  
  Updating γ :
  The highlight of Aux-Net is the update of γ which allows for soft handling of the asynchronous availability of auxiliary features. It depends only on its classifiers weights and are calculated as follows:
  
  
  
  
      γ^P_p,t =
      α^P_p,t/α^M_1,t + ∑_j ∈ A_tα^A_j,t for   C1: (P = M,   p = 1)   or   (P = A,   p ∈ A_t)
  
  
  Updating θ :
  
  The classifiers parameters θ is learned through OGD. The parameter θ^Z_z is associated with only one classifier and does not depend on the other classifiers. Therefore, its update will only be with respect to the loss of its own classifier.  After every time instance t, θ^Z_z of classifier z of the module Z is updated as:
  
      θ^Z_z,t+1 = θ^Z_z,t - ηα^Z_z,tΔ^Z_θ^Z_z,t,z for   C2: (Z ∈ U',   z ∈{1,...,Z})   or   (Z = A,   z ∈ A_t)
  
  
  where, Δ^R_θ^Z_z,t,r = ∂ L(f^R_r(x_t), y_t)/∂θ^Z_z,t, η is the learning rate of the parameters and U' = {S,M,E}.
  
  
  Learning W and c :
  The weights (W) and bias (c) of a layer are learned by back propagation on the final loss similar to OGD. But, since each layer is associated with a classifier unlike the traditional DNN where only last layer gives a prediction, the gradient descent is different. Here, the parameters of a layer depends on the loss of all its successive layers that directly or indirectly influence it. The following equation shows the weight update rule and the same is applicable for bias too.
  
  
  
  
      W^A_a,t+1 = W^A_a,t - η[ α_a,t^AΔ^A_W^A_a,t,a + ∑_e=1^Eα_e,t^EΔ^E_W^A_a,t,e] 
      
          W^Z_z,t+1 = W^Z_z,t - η[ ∑_j=z^Zα_j,t^ZΔ^Z_W^Z_z,t,j + ∑_Q=set∑_q=1^Qα_q,t^QΔ^Q_W^Z_z,t,q]
  
  where set = {M,E}, {E}, ϕ if Z ∈ {S}, {M}, {E} respectively, and z ∈{1,...,Z}.
  
  Learning α :
  We learn the value of α through hedge algorithm. Initially, the value of α is uniformly distributed i.e., α^Z_z = 1/L, where L is the total number of layers, L=S+M+A+E. The loss incurred by the classifier z of module Z at time instance t is L(f^Z_z(x_t), y_t) and its weight is α^Z_z,t. The weights of the classifier are updated on the basis of its loss as:
  
      α^Z_z,t+1 = α^Z_z,tβ^L(f^Z_z(x_t), y_t) for C2,
  
  where β∈ (0,1) is the discount rate parameter. There may come a situation where α^Z_z → 0. To avoid that since we don't want to neglect any layer, a smoothing parameter λ is introduced where λ∈ (0,1). It ensures a minimum weight for each classifier by using the equation α^Z_z,t+1 =  max(α^Z_z,t+1, λ/L).
  
  
  
  
  The value of all α is then normalized such that 
  ∑_Z=U'∑_z=1^Zα^Z_z,t+1 + ∑_j ∈ A_tα^A_j,t+1 = 1.
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
   §.§ Algorithm
  
  
  The Aux-Net is a test-then-train approach and since the number of auxiliary features are changing, the trained model learned at time step t can't be used as it is for training or testing at time step t+1. We define a knowledge base K which is updated after each time instance t.
  We represent all the parameters of the knowledge base by  ' . The knowledge base K at any time instance t is given by
  
      K_t = {W'_t, c'_t, θ'_t, α'_t},
          where G_t = {G^S_t, G^M_t, G^A_t, G^E_t}if G ∈{W', c', θ', α'}
  
  
  
  r0.5
  
      < g r a p h i c s >
  
  Block diagram of Aux-Net algorithm. 
  
  
  
  
  
  Before training or testing, the model needs to incorporate the incoming dynamic auxiliary features.
  We define a model M_t given by equation <ref>, that handles the asynchronous availability of auxiliary features (A_t) by introducing the variable γ. The model M_t predicts an output ŷ_̂t̂, given x_t and updates its parameter giving M^*_t based on the loss incurred. Before moving to the next instance, we update the final parameters of K_t based on M^*_t, giving knowledge base K_t+1. The block diagram of the algorithm is shown in Figure <ref> and algorithm is given in Algorithm <ref>.
  
  
  Creating Model (M_t): Based on the auxiliary features A_t received at time step t and knowledge base K_t, the model M_t is created before prediction and training. The auxiliary layers corresponding to A_t are kept active and all the other auxiliary layers are freeze. Freezing of layers means all the parameters associated with this layer will not be trained. In other terms, freezing means removing the layer from the model. Since, some of the auxiliary layers are removed, the value α of the model changes and a parameter γ is introduced. The model M_t is given by:
  
      M_t = M(W_t, c_t, θ_t, α_t, γ_t)
  
  
  where G_t = {G'^S_t, G'^M_t, {G'^A_j,t}_∀ j ∈ A_t, G'^E_t} if G = {W, c, θ},
  α_t = {α^Z_z,t}_∀ C2 where
  α^Z_z,t =
  α'^Z_z,t/ [∑_Z=U'∑_z=1^Zα'^Z_z,t + ∑_j ∈ A_tα'^A_j,t], and
  γ_t = {γ^P_p,t}_∀ C1,
  γ^P_p,t =
  α'^P_p,t/[ α'^M_1,t + ∑_j ∈ A_tα'^A_j,t].
  
  
  
  Obtaining knowledge base K_t+1 for next instance:
  The parameters of the model M_t are updated based on the loss incurred at time instance t. The updated model, represented by M^*_t is given by:
  
  
  
  
      M^*_t = M(W^*_t, c^*_t, θ^*_t, α^*_t)
  
  where W^*_t, c^*_t, θ^*_t, α^*_t are the parameters obtained by updating the parameters W_t, c_t, θ_t, α_t of the model M_t by using equation <ref>, <ref>, <ref>, and <ref>.
  After training the model at time step t, we create the knowledge base K_t+1 before moving to the next iteration. All the parameters updated at time step t and the parameters of the freezed layers (A-A_t) are collected. Then, K_t+1 is given by:
  
  
  
  
      K_t+1 = {W'_t+1, c'_t+1, θ'_t+1, α'_t+1}
  
  where G'_t+1 = {G^*_t, {G'^A_j,t}_∀  j ∈ A-A_t} if G ∈{W, c, θ}, and
  α'_t+1 = {α'^Z_z,t+1}_Z ∈ U,   z = {1,...,Z} where α'^Z_z,t+1 = α”^Z_z,t/ [ ∑_Z ∈ U∑_z=1^Zα”^Z_z,t] and
  α”_t+1 = {α^*_t, {α'^A_j,t}_∀  j ∈ A-A_t}.
  
  
  
  
  
  
  
  
  
  
  § EXPERIMENTAL RESULTS
  
  
  
  
  We evaluate our model using the Italy power demand dataset <cit.>. It has 1096 data instances with 24 input features. In all the studies, we retain the original order of the input features. To the best of our knowledge, there is no method that incorporates the intermittently available input data in an online setting.
  
  Thus, we compare the Aux-Net model with the ODL model. We train both the models in a purely online setting where after each instance the model predicts and trains. 
  
  Architecture details We fix the number of base layers (S) to be 5, the number of middle layer (M) is 1, and the number of end layers (E) is also 5 for Aux-Net. The number of auxiliary layers (A) are equal to the number of auxiliary features.
  The number of layers for ODL is set as 11 (S+E+M = 11).
  For both Aux-Net and ODL, we used the the ReLU activation function and the number of nodes in each layer was set as 50. The Adam optimizer (η = 0.01) was used for backpropagation. The smoothing rate and the discount rate was set as λ = 0.2 and β = 0.99 respectively. The cross-entropy loss was chosen as the loss function. The above settings are true for all the following experiments.
  
  Varying the probability p of the availability of auxiliary inputs in Aux-Net The first 12 input features of Italy power demand dataset are considered as the base features and remaining as the auxiliary features. The availability of each auxiliary feature at a given time instance is modeled as a uniform distribution with probability p. The same value of p is used for all the auxiliary features but the availability of each is computed independently. The results of Aux-Net with varying values of p, ODL with all the 24 features, and ODL with only the 12 base features are presented in Table <ref>. We report the average of losses observed at all the time instances, and similarly the average accuracy observed across all the time instances. The cumulative average loss and accuracy curves are shown in Fig. <ref>. We study the performance of Aux-Net and comparison with ODL with the following aims:
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  ∙ Sensitivity of Aux-Net to p and its performance: The average accuracy and loss for all the time instances in the dataset shows monotonic trend as a function of p, as noted in Table <ref>. This shows that Aux-Net is sensitive to the availability of the auxiliary inputs, as expected. Yet, the performance of Aux-Net degrades gracefully as p reduces. Moreover, Aux-Net still performs better compared to ODL with 12 features when p<1 (as ODL can not work with inconsistent features). Further, the best case performance of Aux-Net when p=1.00, is comparable to the scenario of ODL with 24 features. This means that even though the knowledge base of Aux-Net supports for 2^12 knowledge models, only the knowledge model with largest dimensionality is invoked and trained. In this case loss of Aux-Net is poorer than ODL, but the accuracy is better. In case of p=0.5 which means no consistency in either availability or unavailability of the auxiliary inputs the observed poorer performance of Aux-Net in comparison to ODL is only marginal, indicating robustness of Aux-Net to the extremely challenging scenario and its graceful degradation.
  r6.8cm
  
  
  
    Average accuracy and loss of Aux-Net (for different values of probability(p) of availability of auxiliary features) and ODL (with different number of input features(feat)) in Italy Power Demand dataset. ODL is shown in italics.
    
    
  
    
      
      
      Model          Accuracy      Loss 
  
      ODL(24 feat)       0.8783      0.4297 
  
      [gray]0.9Aux-Net(p = 1.00)       [gray]0.90.8884     [gray]0.90.5093 
  
      [gray]0.9Aux-Net(p = 0.99)       [gray]0.90.8811      [gray]0.90.5165 
  
      [gray]0.9Aux-Net(p = 0.95)       [gray]0.90.8637      [gray]0.90.5168 
  
      [gray]0.9Aux-Net(p = 0.90)       [gray]0.90.8243     [gray]0.90.5456 
  
      [gray]0.9Aux-Net(p = 0.80)       [gray]0.90.7054      [gray]0.90.6130 
  
      [gray]0.9Aux-Net(p = 0.70)       [gray]0.90.6240      [gray]0.90.6788 
  
      [gray]0.9Aux-Net(p = 0.60)       [gray]0.90.6167      [gray]0.90.6831 
  
      ODL(12 feat)       0.6139      0.6868 
  
      [gray]0.9Aux-Net(p = 0.50)       [gray]0.90.5956      [gray]0.90.6975 
  
    
  
  
  
  ∙ Agile adaptation of Aux-Net: The demand on agility significantly enhances as p reduces. For example, for p=0.6 in Figure <ref>(c), not only a different knowledge model needs to be invoked at every instance but also the same knowledge model may not be invoked in next many time instances. The situation is easier when p=0.9 even though there are many time instances when a different knowledge model is invoked. Nonetheless, Aux-Net remains stable in either case and adapts to the agility needs in an efficient manner, indicated in accuracy and loss plots in Figure <ref>(a,b). Indeed, the accuracy is better and the loss decreases faster over time for p=0.9. Nonetheless, when p=0.6, the accuracy and loss curves closely follow ODL with 12 features, indicating that even though new knowledge models are being dynamically invoked every single instance, the performance of Aux-Net does not deteriorate in comparison to ODL and Aux-Net is indeed able to maintain agility over time, contributing to reduced loss and improved accuracy as time passes.
  
  ∙ Decreased loss and improved accuracy over time: We note that for the situation of 12 auxiliary inputs, support for 2^12 knowledge models, and invocation of each knowledge model multiple times is needed to study the aspects such as convergence of knowledge base over time. Yet, the decreasing loss in Figure <ref>(b) is a positive indicator of performance improvement over time and possible convergence.
  
  Varying number of base features In this experiment, we fix p as 0.9, but vary the number of base features (B) from 1-23. The number of auxiliary features (A) are consequently (24-B). The first B features in the dataset are used as base features in Aux-Net and the only features in ODL. The average loss of Aux-Net and ODL are compared in Fig. <ref> as a function of B. We observe the following:
  
  ∙ Extreme scalability: As expected, the performances of both Aux-Net and ODL deteriorate as B reduces. Nonetheless, the loss of Aux-Net is significantly smaller than ODL in the challenging scenarios when more than 4 inputs are inconsistently available. This clearly indicates that Aux-Net is able to leverage the auxiliary inputs for better learning even if they are inconsistently available.
  Especially, the extremely challenging scenarios (B = 1 for example) demonstrate that Aux-Net is indeed able to step up to the need of supporting several knowledge models of varying inputs and dimensionalities and provide better performance than the minimalist approach.
  
  ∙ Poorer performance than ODL when B ∈ [20,23]: During initialization, Aux-Net assigns the same weights (α) to each classifier. However, the classifier corresponding to an auxiliary feature will be lossier as compared to the classifier of middle layer that uses base features. As time progresses, the value of α for each layer gets customized to suit its contribution towards accurate classification. Often, it means that α of auxiliary layer reduces in the first few time instances, indicating that Aux-Net has learnt that its inconsistent availability may cause increased loss if α corresponding to it is high.
  
  
  
  
  
  
  § DISCUSSION AND CONCLUSION
  
  
  
  Scalability and knowledge entity: Aux-Net supports scalability for the situations ranging from no auxiliary input being available to all auxiliary inputs being available. Aux-Net incorporates knowledge models corresponding to all possible combinations of auxiliary inputs within a single knowledge base. The architectural support in Aux-Net for auxiliary inputs in the form of dedicated parallel layers is a critical feature for scalability. At the same time, being able to update the pertinent knowledge models selectively and reflect the new knowledge back into the main knowledge base (see Fig. <ref>) ensures that a single knowledge base needs to be maintained as opposed to the resource-heavy maximalist approach. Further more, online learning in the current framework dispenses away the need of offline storage of data. Nonetheless, in the future application-specific framework, maintaining a stash of offline data may provide an advantage and exploring that is a possibility.
  
  Agility and stability: Agility in Aux-Net is characterized by its ability to dynamically invoke the relevant knowledge model without making the network unstable or unadaptive. A key factor that supports dynamic stability and agility is the importance parameter γ, which automatically adjusts the contributions of base inputs (through the middle layer) and the currently available auxiliary inputs so that neither the new auxiliary features introduce inordinate instability, nor are they suppressed.
  
  It is of interest to investigate the convergence of Aux-Net, which could not be investigated rigorously in this study though indicators of convergence were observed (results in the supplementary). Since there was no possibility so far for dealing with intermittently available inputs, we found that there is a dearth of suitable benchmark datasets and applications, which allow us to empirically assess aspects such as convergence. However, we deem that more elaborate studies are needed on suitably designed datasets and investigation of rigorous theoretical proofs of convergence will be significantly useful.
  
  So far, we have demonstrated scalability, agility, and stability of Aux-Net and its ability to deal with intermittently available inputs in a completely online manner. This, in our observation is not only the first such architecture, it is also a first demonstration of results on intermittently available input features. Having set a new paradigm, we hope that new datasets, new frameworks, new applications, and more extensive studies are developed in the near future to exploit the possibility of learning in extremely dynamic and uncertain scenarios. We hope that advanced artificial intelligence for dynamic complex environments will soon emerge. We will work on providing further conceptual groundwork to Aux-Net, identifying or creating new benchmark datasets, extending Aux-Net to perform tasks such as prediction and detection or deal with more variety of inputs, such as images, adapt it to use convolutional kernels, and working with asynchronous multi-modal inputs in the future.
  
  
  Machine learning community has been afflicted by rigid architectures for long even though activities in extreme learning, neuro-evolution, and incremental or online learning have been explored to ease the problem of architectural rigidity. Yet, the dream to perform advanced artificial intelligence in a highly dynamic, situation adaptive manner for efficient operation in real-world dynamic complex environments is far from accomplished. Even the most advanced AI agents, such as autonomous cars considers rigid architecture as the amount and type of data availability changes. We are all waiting for a truly agile, scalable, self-adapting non-rigid artificial intelligence approach that redefines how intelligent machines deal with varying amount and types of input features and ad hoc environment.
  
  Aux-Net is a baby step towards the above mentioned dream. For the first time (in our knowledge) we have showcased that an architecture can be online, scalable and agile in nature. In the future, scalable and agile machine learning will bring the next wave of research and development activities, which can address the pressing needs of advanced machine learning in complex dynamic environment. To support the initial activity on this new direction, we will release the Aux-Net source code and its development platform for the benefit of the further research and development activities.
  
  Aux-Net in its current form has its limitations. It needs to be developed for online image based classification similar to the current state-of-the-art deep learning architecture. It has been currently built on keras with tensorflow backend, which currently lack support for Aux-Net type online scalable and agile learning. We will soon release the basic functionality libraries which can support the scalable, agile and online learning. We invite researchers for developing suitable benchmarking datasets from dynamic complex environment with scalable and agile machine learning needs as well as contribute to better implementation and other AI tasks.
  
  
  
  
  
  unsrtnat
  
  
  
     
  
  
  