Patent Publication Number: US-11657322-B2

Title: Method and system for scalable multi-task learning with convex clustering

Description:
CROSS-REFERENCE TO RELATED APPLICATION 
     Priority is claimed to U.S. Provisional Patent Application No. 62/724,704, filed on Aug. 30, 2018, the entire disclosure of which is hereby incorporated by reference herein. 
    
    
     FIELD 
     The present invention relates to a method and system for scalable multi-task learning with convex clustering. 
     BACKGROUND 
     Multi-task learning (MTL) is a branch of machine learning that aims at exploiting the correlation among tasks. To this end, the learning of different tasks is performed jointly (with a better model built for each task). A benefit of multi-task learning is that by learning task relationships, knowledge can be transferred from an information-rich task to information-poor tasks so that the overall generalization error may be reduced. Various multi-task learning algorithms have been proposed. See, e.g., Zhang and Yang, “A Survey on Multi-Task Learning,” arXiv:1707.08114v2 (Jul. 27, 2018) (providing a comprehensive survey on state-of-the-art methods); see also, U.S. Patent Application Publication No. 2013/0151441, entitled “Multi-task learning using Bayesian model with enforced sparsity and leveraging of task correlations” (the entire contents of each of which are hereby incorporated by reference herein). 
     SUMMARY 
     An embodiment of the present invention provides a method for scalable multi-task learning with convex clustering that includes: extracting features from a dataset of a plurality of tasks; generating a graph from the extracted features, nodes of the graph representing linear learning models, each of the linear learning models being for one of the tasks; constraining the graph using convex clustering to generate a convex cluster constrained graph; and obtaining a global solution by minimizing a graph variable loss function, the minimizing the graph variable loss function including: introducing auxiliary variables for each connection between nodes in the convex cluster constrained graph; iteratively performing the following operations until convergence: updating the linear learning models by solving a sparse linear system; and updating the auxiliary variables by solving an equation having the auxiliary variables each be proportional to a vector norm for their respective nodes. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The present invention will be described in even greater detail below based on the exemplary figures. The invention is not limited to the exemplary embodiments. All features described and/or illustrated herein can be used alone or combined in different combinations in embodiments of the invention. The features and advantages of various embodiments of the present invention will become apparent by reading the following detailed description with reference to the attached drawings which illustrate the following: 
         FIG.  1    illustrates a flow diagram of a multi-task regression method according to an embodiment of the present invention; 
         FIG.  2    illustrates a flow diagram of a graph generation operation according to an embodiment of the present invention; 
         FIG.  3    illustrates a global optimal solution solver operation according to an embodiment of the present invention; and 
         FIG.  4    is a block diagram of a processing system according to an embodiment of the present invention. 
     
    
    
     DETAILED DESCRIPTION 
     The present inventors have recognized that there is a problem of efficiently learning multiple regression tasks, where the tasks possess some intrinsic correlation that is not evident or explicitly defined. One example is multiple time series prediction, where each time series possess attributes. Consider, for example, the price or the demand of multiple products. Further, consider also a multitude of stores, as in the case of a single country or multinational scenario. Many factors affect the local behavior of the demand or the price. For example, the weather can play a role, but its effect may be completely different and correlated with other aspects. In addition, the potential number of tasks can be huge. For instance, there can be thousands of products in a retail store, and thousands of stores over the country for a retail chain. In total, there can be millions regression tasks. 
     The present inventors have also recognized that an ideal multi-task regression method should: 1) be able to discover correlation between tasks and exploit their existence to improve the prediction performance; 2) be efficient regarding training time; and 3) have a linear runtime with regard to the number of tasks. The state-of-the-art (SoA) multi-task learning methods, however, fail to provide all of above mentioned features. For example, simple SoA methods cannot explore the relation between tasks, while complex SoA methods are expensive to train and do not scale to large number of tasks. 
     Embodiments of the present invention provide a robust and scalable multi-task learning method and system. The multi-task learning method and system of the present invention optimally learn the tasks&#39; relationships based on the convex clustering of their prediction models. Embodiments outperform previously proposed methods in terms of accuracy and performance, and also scale linearly in the number of tasks. Embodiments can be applied, for example, for multiple time series prediction with an extensive number of time series (tasks). Thus, embodiments of the present invention can provide the three ideal features of multi-task regression methods discussed above, amounting to an improvement in the field of machine learning. 
     In addition, as shown below, embodiments of the present invention outperform other approaches, particularly in the case of large datasets having many tasks (with each task possessing a small number of instances within the dataset) where the SoA methods hit performance issues (that are not present in embodiments of the present invention). One aspect of embodiments of the present invention that enables this improved performance is that embodiments scale linearly with the number of tasks and can deal with regression problems on a large dataset. Further, due to their linear time-scalability, the methods of embodiments can be used easily in an iterative hyperparameter selection and frequent retraining scenarios. 
     In embodiments discussed herein, a linear model is assumed. However, this assumption, as is evident from the results and the applications, is not restrictive, especially when dealing with a short time series, the prediction accuracy of more complex methods is worse (as compared to the present invention) due to the overfitting on small datasets. 
     In order to solve a multi-task learning problem when the number of tasks is large, embodiments of the present invention combine two measures to balance between the training error and the generalization performance by introducing a regularization term that captures the correlation among tasks in the form of a graph. In particular, embodiments of the present invention integrates with convex clustering on a graph of learned linear models and solves the underlying convex problem with a novel optimization method that iteratively solves a structured linear system. 
     By utilizing the clustering of regression tasks by their predictability in multi-task learning and employing convex functions, embodiments of the present invention achieve accuracy that is proportional to the square of the prediction error, while also having the correlation capturing function be proportional to the Euclidian distance of the predictors. 
     In addition, because embodiments of the present invention implement a method having functions formulated to lead to a sparse linear system (i.e., two structured positive semi-definite matrices having a sparse block diagonal component and a sparse Laplacian component), the functions can be empirically solved in linear-time regarding the number of tasks by a Combinatory Multi-Grid (CMG) method. See, e.g., Ioannis et al., “Combinatorial preconditioners and multilevel solvers for problems in computer vision and image processing,” Computer Vision and Understanding 115(12), pp. 1636-1646 (2011) (discussing the CMG method) (the entire contents of which is hereby incorporated by reference herein). 
     Embodiments of the present invention therefore provide a system and method having unique advantages for multi-task regression in terms of improved: accuracy; computational efficiency; computational and memory scalability; and tuning as compared to the SoA. 
     An embodiment of the present invention provides a method for scalable multi-task learning with convex clustering, the method including: extracting a feature from task data; generating a graph from the extracted features; generating an optimization surface based on the generated graph using convex clustering; and obtaining a global optimal solution by iteratively solving a structured linear solution. Embodiments may also use the learned model for making predictions. The method may further include preprocessing the task data before extracting the feature data. In an embodiment, the data preprocessing may include removing missing values and/or normalization. 
     According to an embodiment, a method for scalable multi-task learning with convex clustering is provided that includes: extracting features from a dataset of a plurality of tasks; generating a graph from the extracted features, nodes of the graph representing linear learning models, each of the linear learning models being for one of the tasks; constraining the graph using convex clustering to generate a convex cluster constrained graph; and obtaining a global solution by minimizing a graph variable loss function. Minimizing the graph variable loss function includes: introducing auxiliary variables for each connection between nodes in the convex cluster constrained graph; iteratively performing the following operations until convergence: updating the linear learning models by solving a sparse linear system; and updating the auxiliary variables by solving an equation having the auxiliary variables each be proportional to a vector norm for their respective nodes. In an embodiment, the auxiliary variables are proportional to the inverse of an L2 norm for their respective nodes. 
     The graph variable loss function with introduced auxiliary variables can be expressed as: 
                 min     W   ,   L           1   2     ⁢       ∑     t   =   1     T           ❘   &#34;\[LeftBracketingBar]&#34;         ❘   &#34;\[LeftBracketingBar]&#34;           W   t   T     ⁢     X   t       -     y   t         ❘   &#34;\[RightBracketingBar]&#34;         ❘   &#34;\[RightBracketingBar]&#34;       2   2           +       λ   2     ⁢       ∑     i   ,     j   ∈   G             (         l     i   ,   j       ⁢         ❘   &#34;\[LeftBracketingBar]&#34;         ❘   &#34;\[LeftBracketingBar]&#34;         W   i     -     W   j         ❘   &#34;\[RightBracketingBar]&#34;         ❘   &#34;\[RightBracketingBar]&#34;       2   2       +       1   4     ⁢     l     i   ,   j       -   1           )     .               
Here, W i  is a linear learning model of the linear learning models for task T i  of the tasks, λ is a weighting factor, G is the convex cluster constrained graph, X i  is a vector of an input of the task T i , y i  is a vector of an input for the task T i , l i,j  is an auxiliary variable of the auxiliary variables for one of the connections between the nodes, ∥W i −W j ∥ 2  is the vector norm, which is an L2 norm, for the one of the connections between the nodes, L is a set containing the auxiliary variables, and W is a set of the linear learning models.
 
     According to an embodiment, the sparse linear system can be expressed as: (A+B)V=C. Here, A=(λΣ i,j∈G l i,j (e i −e j )(e i −e j ) T )⊗Ip, B=XX T , C=XY T ,e i ∈   T  is an indicator vector with an ith element set to 1 and other elements set to 0, and I P  is an identity matrix of size P. Also, X is a block diagonal matrix containing the vector of the input for each of the tasks, Y is a row vector containing the vector the input for each of the tasks, and V is a column vector containing the linear learning models of the tasks. The solving of the sparse linear system includes executing a combinatorial multigrid algorithm. 
     In an embodiment, the auxiliary variables are updated by solving the following equation for each of the auxiliary variables: 
     
       
         
           
             
               l 
               
                 i 
                 , 
                 j 
               
             
             = 
             
               
                 1 
                 
                   2 
                   ⁢ 
                   
                     
                       ❘ 
                       &#34;\[LeftBracketingBar]&#34; 
                     
                     
                       
                         
                           ❘ 
                           &#34;\[LeftBracketingBar]&#34; 
                         
                         
                           
                             W 
                             i 
                           
                           - 
                           
                             W 
                             j 
                           
                         
                          
                       
                       2 
                     
                   
                 
               
               . 
             
           
         
       
     
     According to an embodiment, obtaining the global solution generates a multi-task predictor. 
     The method may further include using the multi-task predictor to make a prediction, and executing a control operation on a system associated with the tasks based on the prediction. 
     The method may further include updating the multi-task predictor based on receiving new data points. 
     The method may further include preprocessing the task dataset before extracting the features. The data preprocessing may include removing missing values and/or normalizing the task data. 
     According to an embodiment, extracting the features from the task dataset includes performing an auto regressive function on the task dataset. 
     According to an embodiment, the generating the graph from the extracted features includes learning the linear learning model for each of the tasks from the extracted features that correspond to the respective task. 
     The learned linear model for each task can be represented by a weight vector. The graph can be a k-nearest neighbor graph in Euclidean space. 
     According to another embodiment, a multi-task learning system is provided that includes a processor coupled to a non-transitory storage memory containing instructions, which when executed by the processor, cause the multi-task learning system to: extract features from a dataset of a plurality of tasks; generate a graph from the extracted features, nodes of the graph representing linear learning models, each of the linear learning models being for one of the tasks; constrain the graph using convex clustering to generate a convex cluster constrained graph; and obtain a global solution by minimizing a graph variable loss function. Minimizing the graph variable loss function includes: introducing auxiliary variables for each connection between nodes in the convex cluster constrained graph; iteratively performing the following operations until convergence: updating the linear learning models by solving a sparse linear system; and updating the auxiliary variables by solving an equation having the auxiliary variables each be proportional to a vector norm for their respective nodes. 
     According to another embodiment, a non-transitory processor-readable storage medium is provided that stores instructions that upon execution cause a multi-task learning system to: extract features from a dataset of a plurality of tasks; generate a graph from the extracted features, nodes of the graph representing linear learning models, each of the linear learning models being for one of the tasks; constrain the graph using convex clustering to generate a convex cluster constrained graph; and obtain a global solution by minimizing a graph variable loss function. The minimizing the graph variable loss function includes: introducing auxiliary variables for each connection between nodes in the convex cluster constrained graph; iteratively performing the following operations until convergence: updating the linear learning models by solving a sparse linear system; and updating the auxiliary variables by solving an equation having the auxiliary variables each be proportional to a vector norm for their respective nodes. 
       FIG.  1    shows a flow diagram of a multi-task regression method according to an embodiment of the present invention. 
     The multi-task regression method  100  shown in  FIG.  1    includes: a data preprocessing operation (S 101 ); a feature extraction operation (S 102 ); a graph generation operation (S 103 ); a optimization surface generation operation (S 104 ); a global optimal solution obtaining operation (S 105 ); a prediction application operation (S 106 ); a system control operation (S 107 ); and a model update operation (S 107 ). These operations are discussed in more detail below. 
     A data preprocessing operation (S 101 ) can be the first operation of the multi-task regression method  100 . In the data preprocessing operation (S 101 ), input data is preprocessed before being used in subsequent operations. The input data for the multi-task regression method  100  can be a dataset of tasks (e.g., regression tasks). In an embodiment, the input data may be preprocessed to remove missing values, and/or to normalize the data (data normalization). 
     According to some embodiments, the data preprocessing operation is optional or not implemented. 
     A feature extraction operation is performed (S 102 ) on the task dataset. In machine learning, feature extraction is a dimensionality reduction process, were an initial set of raw variables is reduced to more manageable groups (features) for processing, while still accurately and completely describing the input dataset. Feature extraction can start from an initial dataset and build derived values (features), which are intended to be informative and non-redundant, as well as to facilitate subsequent learning and prediction steps. 
     As shown in the embodiment of  FIG.  1   , the feature extraction operation is performed on the dataset after it has been through the preprocessing operation (S 101 ) (i.e., the input to the feature extraction operation is the preprocessed dataset). In an embodiment, the preprocessed dataset received as the input to the feature extraction operation (S 102 ) is a dataset normalized by a data normalization operation (i.e., a normalized dataset). 
     In an embodiment, the feature extraction operation (S 102 ) includes performing an auto regressive (AR) operation on the normalized data, for example an AR for time series data. As a person of ordinary skill in the art would recognize, however, other forms of feature extraction, including other regression algorithms, can be performed. 
     A graph generation operation (S 103 ) is performed where the method generates a graph G. The input to the graph generation operation is the output of the feature extraction operation (S 102 ), e.g., the extracted features for each task of the task dataset. The output graph G of the graph generation operation (S 103 ) includes linear models as nodes and the relationships between them. 
       FIG.  2    illustrates an example embodiment of the graph generation operation (S 103 ′). First, the extracted features are received for each task (S 103   a ). From the extracted features for each task, the graph generation operation (S 103 ′) learns a linear model for the task (S 103   b ). Each learned linear model can be, for example, represented by a vector of length d in Euclidian space (a weight vector). Then the method generates a graph of the learned linear models (S 103   c ), where each node represents the linear model of a task. The learned graph then can be output to the next operation (S 103   d ). 
     According to an embodiment, the graph G is a k-nearest neighbor graph on the linear models learned independently for each task (where the models are represented by vectors). There can be and edge between two models (i.e., the learned predictor model for a task) if they are in the k-nearest neighbor of each other in the Euclidean space of the vectors. 
     As a person of ordinary skill in the art would understand, various linear learning models may be used without diverging from the scope of the present invention. Similarly, embodiments of the present invention can implement various methods of mapping the learned models into a relational vector graph of models. 
     Returning to  FIG.  1   , an optimization surface generation operation (S 104 ) is performed on the graph G generated by the graph generation operation (S 103 ). The optimization surface generation method restricts an optimization problem by adding a convex constraint (the L2 norm) on pairs of tasks (i.e., the learned predictor model for the pars of tasks) if there is an edge between them. The L2 norm is a vector norm that calculates the distance of a vector coordinate from an origin of the vector space. As such, it is also known as the Euclidean norm as it is calculated as the Euclidean distance from the origin. The result is a positive distance value. The L2 norm is calculated as the square root of the sum of the squared vector values. 
     Accordingly, by executing the graph generation operation (S 103 ) together with the optimization surface generation operation (S 104 ), embodiments instantiate a new model for multi-task regression that integrates with convex clustering on the k-nearest neighbor graph of the prediction models of the tasks. Convex clustering solves clustering of data as a regularized reconstruction problem; however, because the target of multi-task learning is the prediction, the convex clustering in the present invention uses the prediction error of the prediction models (instead of the reconstruction error). By using convex clustering, embodiments of the present invention have an advantage over other SoA models in that convex clustering is efficient with linear scalability. See, e.g., Hocking et al., “Clusterpath: An Algorithm for Clustering using Convex Fusion Penalties”, in ICML (2011) (giving an overview of convex clustering) (the entire contents of which is hereby incorporated by reference herein). 
     Next, the multi-task regression method  100  obtains a global optimal solution (S 105 ) to the convex clustering on the k-nearest neighbor graph of the prediction models. In an embodiment, the multi-task regression method  100  obtains the global optimal solution by minimizing a graph regularized loss function. To obtain the global optimal solution, an embodiment of the present invention iteratively generates a sparse mixed block diagonal and a sparse problem, solves an approximate linear least square problem, and checks solution performance until convergence is reached. 
       FIG.  3    illustrates an embodiment of the global optimal solution operation (S 105 ′). As shown in  FIG.  3   , the global optimal solution is obtained by minimizing the graph regularized loss function by: 
     a. introducing a variable for the edges of the graph (S 105   a ); 
     b. updating the models by solving a sparse linear system (S 105   b ); 
     c. updating the variables (S 105   c ); 
     d. iteratively performing (b) and (c) until convergence (S 105   e ); and 
     e. upon convergence, outputting the optimized predictor model. 
     The variables introduced for the edges (S 105   a ) are auxiliary variables for each of the connections between nodes in the k-nearest neighbor graph. Effectively, the variables are weights for the L2 norm regularizer. 
     In an embodiment, each model is a node on the graph represented as a weight vector for a task. The initial weight vector is determined by the model learning operation for the task performed in the graph generation operation (S 103 )—e.g., in the operation of learning a linear model for each task operation (S 103   b ). 
     After the global optimal solution to the multi-task regression problem is solved to determine the final prediction model, the prediction model can be used to perform prediction operations on the relevant tasks. As shown in the embodiment of  FIG.  1   , the prediction operations can include an apply predictor operation (S 106 ) and a control system operation (S 107 ). In the apply predictor operation (S 106 ), the prediction model can be instantiated and input with data and make the predictions of the associated tasks. In the control system operation (S 107 ), the system concerned with the multi-task regression problem can make control decisions based on the predictions made for the tasks. 
     A model update operation can also be performed (S 108 ), which may include updating the model when new data points come. In an embodiment, performances are measured in the model update operation. The new data points (e.g., new data points obtained by measuring performances) may be sent as inputs to the data preprocessing operation (S 101 ), and the method may continue (e.g., repeat one or more of S 102 -S 108 ). 
     Aspects of the present invention are discussed more formally below in relation to an embodiment applied to a time series prediction. 
     For a time series prediction, an embodiment considers n time series T 1 , . . . , T n  each containing t i  samples. For each task (in this example, the time series), the embodiment considers the last d sample (e.g., AR: Auto Regressive) X ij =[T i,j-1 , . . . T i,j-d ]. The output of the task becomes y i =[y i,1 , . . . y i,t     i   ]. The regression problem can be formulated as:
 
 W     i     min   ∥X   i   W   i   −y   i ∥ 2   2   +λ∥W   i ∥ 2   2   (EQ. 1)
 
where X i =[X i,1 , . . . , X i,t     i   ] and y i =[y i,1 , . . . , y i,t     t   ] are the vector form of the input and the output of the single task T i .
 
     As described above, embodiments of the present invention implement convex clustering to learn accurate predictor models using the prediction error (as compared to using the reconstruction error that is used by SoA convex clustering). For the general case then, the problem can be reformulated as: 
                       min   W         1   2     ⁢       ∑     t   =   1     T                  W   t   T     ⁢     X   t       -     y   t            2   2           +       λ   2     ⁢       ∑     i   ,     j   ∈   G                    W     i   -       ⁢     W   j            2                 (     EQ   .         2     )               
where W i  is the predictor (or regressor or model) for the task T i  and λ is a weighting factor that is found iteratively. In an embodiment, W i  represents the weight vector for a task indexed by i.
 
     In an embodiment, the neighboring graph G is computed on the predictors W i  for all tasks. As such, here the index i is a node in the graph G and the index j is a neighboring node in graph G. The graph G is a k-nearest neighbor graph on the predictors learned independently for each task T. 
     The second term is the regularization term of the predictors, which is the L2 norm. The L2-norm is not squared, which enables greater training performance because a squared norm would increase the penalty of distant predictors. This choice, however, also does not allow for the use of SoA techniques for solving the objective function. Therefore, the methods of embodiments of the present invention perform a new efficient algorithm for solving Equation (2) by iteratively solving a structured linear system. 
     In particular, Equation (2) can be solved by solving an equivalent problem: 
     
       
         
           
             
               
                 
                   
                     
                       min 
                       
                         W 
                         , 
                         L 
                       
                     
                     
                       
                         1 
                         2 
                       
                       ⁢ 
                       
                         
                           ∑ 
                           
                             t 
                             = 
                             1 
                           
                           T 
                         
                         
                           
                              
                             
                               
                                 
                                   W 
                                   t 
                                   T 
                                 
                                 ⁢ 
                                 
                                   X 
                                   t 
                                 
                               
                               - 
                               
                                 y 
                                 t 
                               
                             
                              
                           
                           2 
                           2 
                         
                       
                     
                   
                   + 
                   
                     
                       λ 
                       2 
                     
                     ⁢ 
                     
                       
                         ∑ 
                         
                           i 
                           , 
                           
                             j 
                             ∈ 
                             G 
                           
                         
                       
                       
                         ( 
                         
                           
                             
                               l 
                               
                                 i 
                                 , 
                                 j 
                               
                             
                             ⁢ 
                             
                               
                                  
                                 
                                   
                                     W 
                                     i 
                                   
                                   - 
                                   
                                     W 
                                     j 
                                   
                                 
                                  
                               
                               2 
                               2 
                             
                           
                           + 
                           
                             
                               1 
                               4 
                             
                             ⁢ 
                             
                               l 
                               
                                 i 
                                 , 
                                 j 
                               
                               
                                 - 
                                 1 
                               
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     EQ 
                     . 
                         
                     3 
                   
                   ) 
                 
               
             
           
         
       
     
     Here, an auxiliary variable L={l i,j } is introduced for each connection between node i and j in graph G, and to form Equation (3) above. According to an embodiment, the auxiliary variables are updated by solving an equation having the auxiliary variables each be proportional to the inverse of a vector norm for their respective nodes. 
     Equation (3) learns the weights l i,j  for the squared L2 norm regularizer ∥W i −W j ∥ 2   2  as in Graph regularized Multi-Task Learning (SRMTL). See, e.g., Zhou et al., “Clustered Multi-Task Learning Via Alternating Structure Optimization,” in Neural Information Processing Systems Conference (NIPS) 24 (2011) (the entire contents of which is hereby incorporated by reference herein). 
     Equation (3) can be solved by alternately optimizing W and L. According to an embodiment, optimization is achieved by minimizing the loss function regarding W and L alternatively. 
     When W is fixed, the derivative of Equation (3) is obtained with respect to l i,j , which is set to zero, and the updated rule is obtained as shown below in Equation (4) (which is the update rule for L ij ). By this way L is solved (i.e., optimized). 
     
       
         
           
             
               
                 
                   
                     l 
                     
                       i 
                       , 
                       j 
                     
                   
                   = 
                   
                     1 
                     
                       2 
                       ⁢ 
                       
                         
                            
                           
                             
                               W 
                               i 
                             
                             - 
                             
                               W 
                               j 
                             
                           
                            
                         
                         2 
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     EQ 
                     . 
                         
                     4 
                   
                   ) 
                 
               
             
           
         
       
     
     To solve (i.e., optimize) W, L is fixed, which leads to Equation (3) equaling: 
     
       
         
           
             
               
                 
                   
                     
                       min 
                       W 
                     
                     
                       
                         1 
                         2 
                       
                       ⁢ 
                       
                         
                           ∑ 
                           
                             t 
                             = 
                             1 
                           
                           T 
                         
                         
                           
                              
                             
                               
                                 
                                   W 
                                   t 
                                   T 
                                 
                                 ⁢ 
                                 
                                   X 
                                   t 
                                 
                               
                               - 
                               
                                 y 
                                 t 
                               
                             
                              
                           
                           2 
                           2 
                         
                       
                     
                   
                   + 
                   
                     
                       λ 
                       2 
                     
                     ⁢ 
                     
                       
                         ∑ 
                         
                           i 
                           , 
                           
                             j 
                             ∈ 
                             G 
                           
                         
                       
                       
                         ( 
                         
                           
                             l 
                             
                               i 
                               , 
                               j 
                             
                           
                           ⁢ 
                           
                             
                                
                               
                                 
                                   W 
                                   i 
                                 
                                 - 
                                 
                                   W 
                                   j 
                                 
                               
                                
                             
                             2 
                             2 
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     EQ 
                     . 
                         
                     5 
                   
                   ) 
                 
               
             
           
         
       
     
     Here, X∈   TP×N  and can be defined as a block diagonal matrix, and Y∈   1×N  and can be defined as as a row vector: 
               X   =     [           X   1                                     ⋱                                     X   T           ]       ⁢   
     Y   =     [       y   1     ,   …         ,     y   T       ]             
Here,    TP×N  is a two-dimensional matrix space with multiply (T,P) entries in the first dimension and N entries in the second dimension, and    1×N  is a one dimensional matrix space with N entries.
 
     A column vector V can also be defined as: 
     
       
         
           
             V 
             = 
             
               [ 
               
                 
                   
                     
                       W 
                       1 
                     
                   
                 
                 
                   
                     ⋱ 
                   
                 
                 
                   
                     
                       W 
                       T 
                     
                   
                 
               
               ] 
             
           
         
       
     
     By defining these vectors and the bock diagonal matrix, Equation (5) can be rewritten as: 
                       min   v         1   2     ⁢                V   T     ⁢   X     -   y          2   2         +       λ   2     ⁢       ∑     i   ,     j   ∈   G           (       l     i   ,   j       ⁢            V   ⁡   (       (       e   i     -     e   j       )     ⊗   Ip     )          2   2       )                 (     EQ   .         6     )               
where e i ∈   T  is an indicator vector with the ith element set to 1 and others set to 0, and I P  is an identity matrix of size P, P being the number of features. Here,  R T  is a vector space with T entries.
 
     By setting the derivative of Equation (6) regarding V to zero, the optimal solution of V can be obtained (and thus each W is optimized) by solving the following linear system:
 
( A+B ) V=C   (EQ. 7)
 
where A=(λΣ i,j∈G l i,j (e i −e j )(e i −e j ) T )⊗Ip,B=XX T ,C=XY T . W will be derived by reshaping V. Here, A is block diagonal and B is very sparse. Also, both A and B are positive semi-definite.
 
     Embodiments apply a combinatory multigrid (CMG) solver to optimize the problem, which scales linearly to the number of tasks n. See, e.g., Ioannis et al., “Combinatorial preconditioners and multilevel solvers for problems in computer vision and image processing,” Computer Vision and Image Understanding 115(12), pp. 1638-1646 (2011) (the entire contents of which is hereby incorporated by reference herein). For the sparse linear system, solvers like CG (conjugate gradient) and PCG (preconditional conjugate gradient) may be used. CMG is a type of PCG solver that is special designed for symmetric diagonally dominant linear system. The problem in Equation (7) can be seen as such problem approximately; therefore, CMG works well to solve Equation (7). 
     Because Equation (3) is biconvex on W and L, alternatively updating Equation (4) and Equation (7) will converge to a local minimum. 
     The above described multi-task learning algorithm has been named Convex Clustering Multi-Task regression Learning (CCMTL) by the present inventors. As described in detail above, the CCMTL algorithm integrates with convex clustering on the k-nearest neighbor graph of the prediction models. CCMTL efficiently solves the underlying convex problem with the optimization method just described. CCMTL is accurate, efficient to train, and empirically scales linearly. As evidenced below, CCMTL outperforms SoA multi-task learning algorithms in terms of prediction accuracy as well as computational efficiency. For example, on a real-world dataset with 28,812 tasks, CCMTL required only around 30 seconds to train on a single thread, while some SoA methods needed up to hours or even days. 
     An embodiment of the CCMTL algorithm is summarized below in Algorithm 1. First, it initializes the weight vector W t  by performing linear regression on each task t separately. Then, it constructs the k-nearest neighbor graph G on W based on the Euclidean distance. Finally, the optimization problem is solved by iteratively updating L and W until convergence. 
     
       
         
           
               
             
               
                   
               
               
                 Algorithm 1: CCMTL 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
            
               
                   
                    Input: {X t Y t } for t = {1,2, ... , T}, λ 
               
               
                   
                    Output: W = {W 1 , ... W T } 
               
               
                   
                 1 for t ← 1 to T do 
               
               
                   
                 2 | Solve W t  by Linear Regression on {X t , Y t } 
               
               
                   
                 3 end 
               
               
                   
                 4 Construct k-nearest neighbor graph G on W; 
               
               
                   
                 5 while not converge do 
               
               
                   
                 6 | Update L using Eq. (3); 
               
               
                   
                 7 | Update W by solving Eq. (6) using CMG; 
               
               
                   
                 8 end 
               
               
                   
                 9 return W; 
               
               
                   
               
            
           
         
       
     
     In the following, example embodiments are described, including in applications of transportation, retail demand estimation for multiple stores, prediction of stock market prices, and drug effects prediction in medicine. 
     Transportation: In an application of an embodiment, a set of routes can be connecting different parts of a city. Each route R i  consists of n i  stops. The set P ij  can be the set of realizations of the route R i , i.e., the set of actually travelled routes. Depending on the data collected from an Automatic Passenger Counting (APC) and Automatic Vehicle Location (AVL) systems, the number of boarding and alighting travelers can be collected at each bus stop, besides the time of the vehicle arrival and departure. With embodiments of the present invention, the following problems, for example, can be formulated and solved: 
     Demand prediction at a given location/stop: For this problem, the task can be formulated at the level of location/stop, and an instance of a task would be each realization of each trip that passes through that stop. The target of each task is the prediction of the number of passengers that is willing to board at this stop. The set of all available stops formulates all tasks that might share some properties (spatial closeness) and causality affects (as in the case of consecutive stops). 
     Travel time prediction: Similar to the previous problem, the target prediction of the task is the time a trip requires to reach a given stop, given the features of the trip, route, and time. 
     Demand prediction at the origin-destination level: In the private transportation sector that is not restricted to pre-defined routes (such as taxis and car sharing), the origin-destination matrix can be reformulated in order to be used in the setting of embodiments. To this end, each origin-destination pair is considered as a task, which leads to quadratic number of tasks, in terms of the number of regions. This formulation can be best handled by the method of an embodiment of the present invention because the clustering step reduces the number of tasks and exploits their correlations. 
     For the three aforementioned example prediction problems, defined in scope of intelligent transportation, the method of embodiments of the present invention provides a better predictive performance and can scale better than the state of the art methods. The method of embodiments achieves this by finding automatically the balance between learning each task (trip) separately and learning all tasks (trips) as a single problem. The method of embodiments finds the right grouping of the tasks (trips), then applies the learning on the found group, while respecting the similarities between similar groups (of trips). In addition, the method of embodiments is efficient to train even for large number of tasks; therefore, the model can be updated in real time. 
     Retail demand estimation for multiple stores: In the retail market, shop owners aim at maximizing their profit by wisely choosing the set of products offered by their stores. By observing the sales of each product at each store, it can easily be seen that the sales of one product affects the sales of others, and the sales of some shops are affected, sometimes, and correlated, other times, with the sales in similar shops (i.e., spatial similarity, and type similarity). 
     In an embodiment, the sales of products are predicted by formulating the sales of each product at each store as a time series (task). Therefore, the number of tasks would be in the order of the number of shops by the number of products. With this formulation, the retail demand prediction can be solved efficiently with the approach of embodiments of the present invention because the detection of similarities between tasks (using neighbor graph) helps in collapsing the number of tasks, while still respecting their correlation. 
     One advantage of applying the approach of embodiments of the present invention to the retail problems, compared to other approaches, is that the approach of embodiments finds the right grouping of (product, store) pairs and then solves the optimization problem. In this way, the approach of embodiments of the present invention achieves a better predictive performance efficiently because it exploits the correlations in the retail market between the different products and the different stores. In addition, the method of embodiments is efficient to train even for large number of tasks; therefore, the model can be updated whenever there are new data points collected. 
     Prediction of stock market prices: In a formulation similar to the retail demand prediction, the demand and offer of stocks in the market could be modelled into a single task, where the purchases of each share are represented as a task. Thereafter, the price development of all shares can be formulated as a multitask problem. 
     Here, one advantage of applying the method of embodiments is that shares that tend to have similar temporal trends (increasing or decreasing) are grouped into similar entities (as a result of clustering), and, hence, exploiting the correlation to improve the training on more examples, task-wise, without declining the generalization performance. 
     Drug effects prediction in medicine: The methods of embodiments can also be used for drug effects prediction. For a given disease, there are more than 20,000 possible small molecules, predicting the effect for each small molecule can be regarded as a regression task. Therefore, predicting the effects for all the drugs can be formulated as a multitask problem. Further, if the drug combination is considered, the number of potential drug pairs or triplets can be huge. Therefore, the methods of embodiments are efficient to handle that case. 
     The CCMTL method of embodiments of the present invention has been experimentally compared with several SoA methods. As baselines, the CCMTL method is compared with single-task learning (STL)—which learns a single model by pooling together the data from all the tasks, and independent task learning (ITL)—which learns each task independently. CCMTL has been further compared to three multi-task feature learning based methods: Joint Feature Learning (L21) (see Argyriou et al., “Multi-task feature learning,” in NIPS, pp. 41-48 (2007) (the entire contents of which is hereby incorporated by reference herein)), Trace-norm Regularized Learning (Trace) (see Ji and Ye, “An accelerated gradient method for trace norm minimization,” in ICML, pp. 457-464 (2009) (the entire contents of which is hereby incorporated by reference herein)), and Robust Multi-task Learning (RMTL) (Chen et al., “Integrating low-rank and group sparse structures for robust multi-task learning,” in KDD, pp. 42-50 (2011) (the entire contents of which is hereby incorporated by reference herein)). CCMTL has also been compared to two other clustering based methods: CMTL (see Jacob et al., “Clustered multi-task learning: A Convex Formulation,” NIPS, pp. 745-752 (2009) (the entire contents of which is hereby incorporated by reference herein)), and FusedMTL (see Zhou et al., “Modeling disease progression via fused sparse group lasso,” in KDD, pp. 1095-1103 (2012) (the entire contents of which is hereby incorporated by reference herein)). Finally, CCMTL has been compared to two decomposition based Multi-task Learning models: BiFactorMTL and TriFactorMTL (see Murugesan et al., “Co-clustering for multitask learning,” ICML (2017) (the entire contents of which is hereby incorporated by reference herein)). 
     All methods were implemented in Matlab. The implementation of L21, Trace, RMTL and FusedMTL were from the Malsar package. See Zhou et al., “Malsar: Multi-task learning via structural regularization,” Arizona State University 21 (2011) (the entire contents of which are hereby incorporated by reference herein). CMTL, BiFactorMTL, and TriFactorMTL were obtained from their authors&#39; personal websites. CCMTL, STL, ITL, L21, Trace and FusedMTL each need one regularization parameter, which was selected from [10 −5 , 10 5 ]. RMTL, CMTL, BiFactorMTL and TriFactorMTL each need two regularization parameters, which were selected from [10 −3 , 10 3 ]. CMTL and BiFactorMTL further needs one hyperparameter and TriFactor further needs two hyperparameters for the number of clusters, which were chosen from [2, 3, 5, 10, 20, 30, 50]. All hyperparameters were selected by internal 5-fold cross validation on the training data. 
     
       
         
           
               
             
               
                 TABLE 1 
               
             
            
               
                   
               
               
                 Summary statistic of the datasets 
               
            
           
           
               
               
               
               
               
            
               
                   
                 Name 
                 Samples 
                 Features 
                 Num Tasks 
               
               
                   
               
            
           
           
               
               
               
               
               
            
               
                   
                 Syn 
                 3000 
                 15 
                 30 
               
               
                   
                 School 
                 15362 
                 28 
                 139 
               
               
                   
                 Sales 
                 34062 
                 5 
                 811 
               
               
                   
                 Ta-Feng 
                 2619320 
                 5 
                 23812 
               
               
                   
                 Alighting 
                 33945 
                 5 
                 1926 
               
               
                   
                 Boarding 
                 33945 
                 5 
                 1926 
               
               
                   
               
            
           
         
       
     
     Synthetic and Real-World datasets were employed. Table 1 (above) shows the statistics about the datasets. Further details are provided below: 
     Synthetic: Syn dataset consists of three groups of tasks with ten tasks in each group. Fifteen features F were generated from  (0,1). Tasks in group 1 were constructed from features 1-5 in F and random 10 features. Similarly, Tasks in group 2 and 3 were constructed from features 6-10 and 11-15 in F respectively. One-hundred samples were generated for each task. 
     Benchmark: School is a benchmark dataset in Multitask regression. See, e.g., Argyriou et al., “Multi-task feature learning,” in NIPS, pp. 41-48 (2007) (the entire contents of which are hereby incorporated by reference herein). The School dataset consists of examination scores of 15,362 students from 139 schools in London. Each school is considered as a task, and the aim is to predict the exam scores for all the students. The dataset used is from the Malsar package. 
     Retail: Sales is a dataset that contains weekly purchased quantities of 811 products over 52 weeks. See Tan et al., “Time series clustering: A superior alternative for market based analysis,” Proceedings of the National Academy of Sciences Conference on Advanced Data and Information Engineering, pp. 241-248 (2013) (there entire contents of which are hereby incorporated by reference herein). The dataset was built using the sale quantities of 5 previous weeks for each product to predict the sale for the current week, resulting in 34,062 samples in total. Ta-Feng is another grocery shopping dataset that consists of transactions data of 23,812 products over 4 months. The data was built in a similar manner, and there are 2,619,320 samples in total. 
     Transportation: Demand prediction is an important aspect for intelligent transportation. For transportation, a dataset was generated by a bus operator in Stockholm. The data was collected from busses directly using Automatic Vehicle Location (AVL) and Automatic passenger Counting (APC) systems. There were two bus lines and two directions for each line, and four routes. Each trip (one realization of a route) was considered as a task, and the target of the instances in this task was to predict the number of passengers taking the bus (boarding) at given bus stop, given the arrival time to the stop and the number of alighting and boarding at the previous two stops. The same dataset was also used to predict the alighting as a target attribute. The two datasets, alighting and boarding, were generated with 33,945 samples each. 
     The performance of the CCMTL method of the present invention was compared to the ADMM based solver on solving the problem of Equation (2). The ADMM solver was implemented using the SnapVX package from NetworkLasso. See Hallac, et al., “Network lasso: Clustering and optimization in large graphs,” KDD, pp. 387-396 (2015) (the entire contents of which is hereby incorporated by reference herein). Both the CCMTL method of the present invention and the ADMM based solver were evaluated on the Syn dataset and the School benchmark dataset. The graph was generated as described in Algorithm 1, and the same graph was used to test two solvers with different λ. Table 2 and 3 depicts the objective functions and runtime comparison on Syn and School datasets respectively. 
     
       
         
           
               
             
               
                 TABLE 2 
               
             
            
               
                   
               
               
                 Objective and runtime comparison between the proposed and the ADMM solver on 
               
               
                 Syn data. 
               
            
           
           
               
               
               
               
               
               
            
               
                   
                 λ = 0.01 
                 λ = 0.1 
                 λ = 1 
                 λ = 10 
                 λ = 100 
               
            
           
           
               
               
               
               
               
               
               
               
               
               
               
            
               
                 Syn 
                 Obj 
                 Time(s) 
                 Obj 
                 Time(s) 
                 Obj 
                 Time(s) 
                 Obj 
                 Time(s) 
                 Obj 
                 Time(s) 
               
               
                   
               
            
           
           
               
               
               
               
               
               
               
               
               
               
               
            
               
                 ADMM 
                 
                   1314 
                 
                 8 
                 
                   1329 
                 
                 8 
                 1474 
                 9 
                 2320 
                 49 
                 7055 
                 180 
               
               
                 CCMTL 
                 
                   1314 
                 
                 
                   0.5 
                 
                 
                   1329 
                 
                 
                   0.5 
                 
                 
                   1472 
                 
                 
                   0.5 
                 
                 
                   2320 
                 
                 
                   0.5 
                 
                 
                   6454 
                 
                 
                   0.5 
                 
               
               
                   
               
            
           
         
       
     
     
       
         
           
               
             
               
                 TABLE 3 
               
             
            
               
                   
               
               
                 Objective and runtime comparison between the proposed and the ADMM solver on 
               
               
                 School data. 
               
            
           
           
               
               
               
               
               
               
            
               
                   
                 λ = 0.01 
                 λ = 0.1 
                 λ = 1 
                 λ = 10 
                 λ = 100 
               
            
           
           
               
               
               
               
               
               
               
               
               
               
               
            
               
                 School 
                 Obj 
                 Time(s) 
                 Obj 
                 Time(s) 
                 Obj 
                 Time(s) 
                 Obj 
                 Time(s) 
                 Obj 
                 Time(s) 
               
               
                   
               
            
           
           
               
               
               
               
               
               
               
               
               
               
               
            
               
                 ADMM 
                 664653 
                 605 
                 665611 
                 583 
                 674374 
                 780 
                 726016 
                 4446 
                 776236 
                 5760 
               
               
                 CCMTL 
                 
                   664642 
                 
                 
                   0.7 
                 
                 
                   665572 
                 
                 
                   0.8 
                 
                 
                   674229 
                 
                 
                   0.9 
                 
                 
                   725027 
                 
                 
                   1.5 
                 
                 
                   764844 
                 
                 
                   1.9 
                 
               
               
                   
               
            
           
         
       
     
     From Tables 2 and 3 it can be seen that, when λs are small, both the CCMTL solver of the present invention and ADMM based solver give close objective function values of Equation (2). However, when λs are large, e.g., 100, the CCMTL method of the present invention provides much smaller objective values than ADMM based solver. This is because the convergence of ADMM is related to its hyperparameters, and the present invention only uses the default ones. In addition, it can be seen that ADMM based solver is expensive to train for the rather small tested datasets Syn and School. In the comparison, the CCMTL solver of the present invention is much more efficient than ADMM based one, with only around 1 second of runtime. 
     In comparison to SoA multi-task learning methods, the prediction accuracy was evaluated using the Root Mean Squared Error (RMSE). All of the experiments were repeated five times for statistical test. The best model and the statistically competitive models (by paired t-test with α=0.05) are shown in boldface. 
     Table 4 depicts the prediction RMSE on Syn dataset with the ratio of training samples ranging from 20% to 40%. In the Syn dataset, tasks are heterogeneous and well partitioned. Thus, STL that trains only single model performs the worst. All the MTL methods outperform the baseline STL and ITL. Among them, the clustering based methods CMTL, BiFactor, TriFactor and CCMTL gave the best predictions. CCMTL and BiFactor outperform all the other methods in all cases. 
     
       
         
           
               
             
               
                 TABLE 4 
               
             
            
               
                   
               
               
                 Results on Synthetic datasets (RMSE). 
               
            
           
           
               
               
               
               
            
               
                   
                 20% 
                 30% 
                 40% 
               
               
                   
               
               
                 STL 
                 2.905 (0.031) 
                 2.877 (0.025) 
                 2.873 (0.036) 
               
               
                 ITL 
                 1.732 (0.077) 
                 1.424 (0.049) 
                 1.284 (0.024) 
               
               
                 L21 
                 1.702 (0.033) 
                 1.388 (0.014) 
                 1.282 (0.011) 
               
               
                 Trace 
                 1.302 (0.042) 
                 1.222 (0.028) 
                 1.168 (0.023) 
               
               
                 RMTL 
                 1.407 (0.028) 
                 1.295 (0.024) 
                 1.234 (0.039) 
               
               
                 CMTL 
                 1.263 (0.038) 
                 1.184 (0.007) 
                 1.152 (0.017) 
               
               
                 FuseMTL 
                 2.264 (0.351) 
                 1.466 (0.025) 
                 1.297 (0.048) 
               
               
                 BiFactor 
                   1.219  ( 0.025 ) 
                   1.150  ( 0.020 ) 
                   1.125  ( 0.013 ) 
               
               
                 TriFactor 
                 1.331 (0.239) 
                 1.255 (0.236) 
                   1.126  ( 0.010 ) 
               
               
                 CCMTL 
                   1.192  ( 0.018 ) 
                   1.161  ( 0.018 ) 
                   1.136  ( 0.015 ) 
               
               
                   
               
            
           
         
       
     
     Table 5 depicts the results on two retail datasets: Sales and Ta-Feng, where the runtime was recorded in seconds for methods with their most expensive parameterization. The best runtimes for MTL methods are shown in boldface. Again, on Sales and Ta-Feng tasks are rather homogenous, where STL performs competitive and outperform many MTL methods. CCMTL outperforms STL as well as all the other methods on Sales datasets. In addition, it only took 1.8 seconds to train CCMTL&#39;s most expensive hyperparameter, while it took dozens (or even hundreds of seconds) for other MTL methods. Similar results can be observed on Ta-Feng dataset, where CCMTL and FuseMTL are the best methods regarding RMSE. However, it only took CCMTL 39.7 seconds, but 9,826 seconds for FuseMTL. The runtime for CMTL, BiFactor and TriFactor are even more than 24 hours. Also, because CMTL and BiFactors have three hyperparameters and TriFactor has four hyperparameters, the hyperparameters selection is even more expensive for them. 
     
       
         
           
               
             
               
                 TABLE 5 
               
             
            
               
                   
               
               
                 Results on Retail datasets 
               
            
           
           
               
               
               
               
               
            
               
                   
                 Sales 
                   
                 Ta-Feng 
                   
               
            
           
           
               
               
               
               
               
            
               
                 Syn 
                 RMSE 
                 Time(s) 
                 RMSE 
                 Time(s) 
               
               
                   
               
            
           
           
               
               
               
               
               
            
               
                 STL 
                 2.861 (0.02) 
                 0.1 
                 0.791 (0.01) 
                 0.2 
               
               
                 ITL 
                 3.115 (0.02) 
                 0.1 
                 0.818 (0.01) 
                 0.4 
               
               
                 L21 
                 3.301 (0.01) 
                 11.8 
                 0.863 (0.01) 
                 5942 
               
               
                 Trace 
                 3.285 (0.21) 
                 10.4 
                 0.863 (0.01) 
                 7041 
               
               
                 RMTL 
                 3.111 (0.01) 
                 3.4 
                 0.808 (0.01) 
                 1396 
               
               
                 CMTL 
                 3.088 (0.01) 
                 43.4 
                 — 
                   &gt;24 h 
               
               
                 FuseMTL 
                 2.898 (0.01) 
                 4.3 
                   0.764  ( 0.01 ) 
                 9826 
               
               
                 BiFactor 
                 2.882 (0.01) 
                 55.7 
                 — 
                   &gt;24 h 
               
               
                 TriFactor 
                 2.857 (0.04) 
                 499.1 
                 — 
                   &gt;24 h 
               
               
                 CCMTL 
                   2.793  ( 0.01 ) 
                 
                   1.8 
                 
                   0.767  ( 0.01 ) 
                 
                   35.3 
                 
               
               
                   
               
            
           
         
       
     
     Table 6 shows the results on the School dataset with the ratio of training samples ranging from 20% to 40%. ITL performs the worst on School because of the limited number of training samples for each task. STL outperforms ITL, the reason possibly being that the tasks are rather homogenous in the School dataset. Surprisingly, the simple STL outperforms many MTL methods, e.g. L21, Trace, RMTL and FusedMTL. MTFactor and TriFactor improve STL only when the training ratios are larger. CCMTL is the best method on the School datasets, and outperforms all the other methods except CMTL on the scenario with 20% training samples, where competitive results are observed. 
     
       
         
           
               
             
               
                 TABLE 6 
               
             
            
               
                   
               
               
                 Results on School datasets (RMSE) 
               
            
           
           
               
               
               
               
            
               
                   
                 20% 
                 30% 
                 40% 
               
               
                   
               
               
                 STL 
                 10.245 (0.026) 
                 10.219 (0.034) 
                 10.241 (0.068) 
               
               
                 ITL 
                 11.427 (0.149) 
                 10.925 (0.085) 
                 10.683 (0.045) 
               
               
                 L21 
                 11.175 (0.079) 
                 11.804 (0.134) 
                 11.442 (0.137) 
               
               
                 Trace 
                 11.117 (0.054) 
                 11.877 (0.542) 
                 11.655 (0.058) 
               
               
                 RMTL 
                 11.095 (0.066) 
                 10.764 (0.068) 
                 10.544 (0.061) 
               
               
                 CMTL 
                   10.219  ( 0.056 ) 
                 10.109 (0.069) 
                 10.116 (0.053) 
               
               
                 FuseMTL 
                 10.372 (0.108) 
                 10.407 (0.269) 
                 10.217 (0.085) 
               
               
                 MTFactor 
                 10.445 (0.135) 
                 10.201 (0.067) 
                 10.116 (0.051) 
               
               
                 TriFactor 
                 10.551 (0.080) 
                 10.224 (0.070) 
                 10.129 (0.020) 
               
               
                 CCMTL 
                   10.170  ( 0.029 ) 
                   10.036  ( 0.046 ) 
                    9.972  ( 0.021 ) 
               
               
                   
               
            
           
         
       
     
     Table 7 depicts the results on the Transportation datasets, using two different target attributes (alighting and boarding). The runtime is presented for the best-found parameterization, and the best runtime achieved by the MTL methods are shown in boldface. The results on this dataset are interesting, especially because both baselines are not competitive as in the previous datasets. This could, safely, lead to the conclusion that the tasks belong to latent groups, where tasks are homogenous intra-group, and heterogeneous inter-groups. All MTL methods (except FuseMTL) outperform at least one of the baselines (STL and ITL) on both datasets. The CCMTL approach of the present invention, reaches an appropriate balance between task independence (ITL) and competitive correlation (STL), as confirmed by the results. The CCMTL approach of the present invention achieves, statistically, the lowest RMSE against the baselines and all the other MTL methods (except SRMTL), and it is at least 40% faster than the fastest MTL method (RMTL). 
     
       
         
           
               
             
               
                 TABLE 7 
               
             
            
               
                   
               
               
                 Results on Transportation datasets 
               
            
           
           
               
               
               
               
               
            
               
                   
                 Alighting 
                   
                 Boarding 
                   
               
            
           
           
               
               
               
               
               
            
               
                 Syn 
                 RMSE 
                 Time(s) 
                 RMSE 
                 Time(s) 
               
               
                   
               
            
           
           
               
               
               
               
               
            
               
                 STL 
                 3.073 (0.02) 
                 0.1 
                 3.236 (0.03) 
                 0.1 
               
               
                 ITL 
                 2.894 (0.02) 
                 0.1 
                 3.002 (0.03) 
                 0.1 
               
               
                 L21 
                 2.865 (0.04) 
                 14.6 
                 2.983 (0.03) 
                 16.7 
               
               
                 Trace 
                 2.835 (0.01) 
                 19.1 
                 2.997 (0.05) 
                 17.5 
               
               
                 RMTL 
                 2.985 (0.03) 
                 6.7 
                 3.156 (0.04) 
                 7.1 
               
               
                 CMTL 
                 2.970 (0.02) 
                 82.6. 
                 3.105 (0.03) 
                 91.8 
               
               
                 FuseMTL 
                 3.080 (0.02) 
                 11.1 
                 3.243 (0.03) 
                 11.3 
               
               
                 BiFactor 
                 3.010 (0.02) 
                 152.1. 
                 3.133 (0.03) 
                 99.7 
               
               
                 TriFactor 
                 2.913 (0.02) 
                 292.3 
                 3.014 (0.03) 
                 359.1 
               
               
                 CCMTL 
                   2.795  ( 0.02 ) 
                 
                   4.8 
                 
                   2.928  ( 0.03 ) 
                 
                   4.1 
                 
               
               
                   
               
            
           
         
       
     
       FIG.  4    is a block diagram of a processing system according to an embodiment. The processing system embodies a specialized computer system specifically configured to implement the method and system for scalable multi-task learning with convex clustering according to the present invention. The processing system  400  therefore executes the algorithms, protocols, systems and methods described above. The processing system  400  includes a processor  404 , such as a central processing unit (CPU) of a computing device or a distributed processor system. The processor  404  executes processor executable instructions to instantiate and employ embodiments of the system for performing the functions and methods described above. In embodiments, the processor executable instructions are locally stored or remotely stored and accessed from a non-transitory computer readable medium, such as storage  410 , which may be a hard drive, cloud storage, flash drive, etc. Read Only Memory (ROM)  406  includes processor executable instructions for initializing the processor  404 , while the random-access memory (RAM)  408  is the main memory for loading and processing instructions executed by the processor  404 . The network interface  412  may connect to a wired network or cellular network and to a local area network or wide area network, such as the Internet. 
     While the invention has been illustrated and described in detail in the drawings and foregoing description, such illustration and description are to be considered illustrative or exemplary and not restrictive. It will be understood that changes and modifications may be made by those of ordinary skill within the scope of the following claims. In particular, the present invention covers further embodiments with any combination of features from different embodiments described above and below. Additionally, statements made herein characterizing the invention refer to an embodiment of the invention and not necessarily all embodiments. 
     The terms used in the claims should be construed to have the broadest reasonable interpretation consistent with the foregoing description. For example, the use of the article “a” or “the” in introducing an element should not be interpreted as being exclusive of a plurality of elements. Likewise, the recitation of “or” should be interpreted as being inclusive, such that the recitation of “A or B” is not exclusive of “A and B,” unless it is clear from the context or the foregoing description that only one of A and B is intended. Further, the recitation of “at least one of A, B and C” should be interpreted as one or more of a group of elements consisting of A, B and C, and should not be interpreted as requiring at least one of each of the listed elements A, B and C, regardless of whether A, B and C are related as categories or otherwise. Moreover, the recitation of “A, B and/or C” or “at least one of A, B or C” should be interpreted as including any singular entity from the listed elements, e.g., A, any subset from the listed elements, e.g., A and B, or the entire list of elements A, B and C.