Patent Publication Number: US-8990128-B2

Title: Graph-based framework for multi-task multi-view learning

Description:
BACKGROUND 
     The present disclosure relates to systems and methods for learning tasks and, a novel system and method for complicated learning problems with both feature heterogeneity and task heterogeneity. 
     Many real-world problems exhibit dual-heterogeneity. To be specific, a single learning task might have features in multiple views (i.e., feature heterogeneity); different learning tasks might be related with each other through one or more shared views (features) (i.e., task heterogeneity). For example, sentiment classification for movie reviews and for political blog posts are two related tasks. They both have the word features. However, political blog posts may have additional features based on the social network of the blog users. Another example is depicted as an illustration in  FIG. 1  directed to multi-lingual web image annotation  10 , where images  12  collected from Chinese web sites and images  15  collected from English web sites both have content-based features (image features, e.g., as represented by a color histogram), and they also have task-specific features, i.e., surrounding texts  22  in Chinese and surrounding texts  25  in English, respectively. 
     Neither multi-task learning nor multi-view learning alone is optimal for such complicated learning problems. 
     As known, the basic idea of multi-view learning is to make use of the consistency among different views to achieve better performance. In multi-task learning, people model task relatedness in various ways. 
     Existing multi-task learning explores the relatedness with other tasks, but disregards the consistency among different views of a single task; whereas existing multi-view learning ignores the label information from other related tasks. 
     There does not exist an effective learning method to fully explore both the feature heterogeneity and the task heterogeneity simultaneously. This is partially due to the fact that existing multi-task learning and multi-view learning algorithms adopt quite different methodologies. 
     It would be highly desirable to provide a system and method that provides for and solves novel Multi-Task Multi-View learning problems. 
     SUMMARY 
     A system, method and computer program product that relies on both feature heterogeneity and task heterogeneity simultaneously for solving a learning problem is provided. The system and method seamlessly bridges Multi-Task learning and Multi-View (M 2 TV) learning methods together to solve learning problem. 
     The Multi-Task Multi-View (M 2 TV) learning problem on one hand, uses the label information from related tasks to make up for the lack of labeled data in a single task; on the other hand, it uses the consistency among different views to improve the performance. It is tailored for the complicated dual heterogeneous problems where multiple related tasks have both shared and task-specific views (features), since it makes full use of the available information. 
     For M 2 TV learning, there is described a graph-based framework (GraM 2 ). Within each task, there is constructed a bipartite graph for each view, modeling the relationship between the examples and the features in this view. The consistency among different views is obtained by requiring them to produce the same classification function, which is commonly used in multi-view learning. Across different tasks, their relationship is established by imposing the similarity constraint on the common views. Furthermore, an iterative algorithm (IteM 2 ) is proposed to solve the GraM 2  framework. 
     There is provided a system, method and computer program product for classifying entities from multiple channels in multi-task multi-view learning problems, said entities of different tasks being related with each other through shared features in multiple views and a single learning task relating to a task specific feature in multiple views. The method comprises: generating a bi-partite graph-based model relating one or more examples and features in each the view; forming an objective function to impose consistency of each task and similarity constraints on common views of different tasks based on graphs generated from the model, wherein for each task, a first function g( ) is defined on entities which takes on class label values; and, a second function f( ) is defined on each view which takes values on the features in the view, the second function feature values used to determine the class label of an entity having such features; iteratively solving the objective function over each the task to obtain values for the first functions and second functions; and, generating labels that classify the entities based on obtained values for the first functions, wherein as programmed processor device is configured to perform one or more of the model generating, the forming, the iteratively solving and the label generating. 
     A computer program product is provided for performing operations. The computer program product includes a storage medium readable by a processing circuit and storing instructions run by the processing circuit for running a method(s). The method(s) are the same as listed above. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The above and further advantages of the present invention may be better understood by referring to the following description in conjunction with the accompanying drawings, in which: 
         FIG. 1  is a diagram illustrating a non-limiting M 2 TV learning problem  10  including multiple related tasks having both shared and task-specific views; 
         FIG. 2  particularly illustrates a bi-partite graph structure  50  for the M 2 TV learning problem example of  FIG. 1 ; 
         FIG. 3  is a pseudo-code depiction of a method for solving an optimization problem (i.e., objective function) for the graph-based framework (GraM 2 ) for M 2 TV learning according to one embodiment; 
         FIG. 4  is a pseudo-code depiction of a further method for initializing variables including calculating a normalized affinity matrices and initializing function g i (•) defined on examples used for the classification according to an example embodiment; 
         FIG. 5  is a pseudo-code depiction of a further method for assigning predicted class labels for use in the first method of  FIG. 2  according to an example embodiment; and, 
         FIGS. 6A and 6B  illustrate the comparison results comparing the IteM 2  classifying method to an example three problems for respective two (2) tasks with non-identical views example case where a computed classification error is depicted for the 20 newsgroups data set of the example; 
         FIG. 7  shows comparison results of the average classification error computed for an example WebKB dataset highlighting improved performance of IteM 2  classifying for example case of Multiple tasks with Identical Views; and, 
         FIGS. 8A and 8B  each shows an average classification error of all the tasks vs. the number of labeled examples in each task for Problem A and B, respectively. 
         FIG. 9  shows an example M 2 TV learning problem implemented for extending an automated Question-Answer QA system to another language according to the techniques described herein; 
         FIG. 10  illustrates an exemplary hardware configuration of a computing system  400  running and/or implementing the method steps described herein. 
     
    
    
     DETAILED DESCRIPTION 
     There is introduced a novel problem named Multi-Task Multi-View learning (M 2 TV), where multiple related tasks have both shared and task-specific views, and a solution for solving such multi-task learning/multi-view learning problems. 
     For example, in a task of classifying web sites as depicted in the illustrative example  10  of  FIG. 1 , a Task 1 involves classifying images on Chinese Web-sites while a Task 2 involves classifying images on English Web-sites. Task 1 provides two (2) views: 1) low-level image feature (e.g., photograph  12 ), and view 2) textual features extracted from content surrounding the image (e.g., the Chinese language text characters  22  being mapped to tokens  23  representing word stem(s)), e.g., resulting from applying TF-IDF processing of Chinese text content surrounding the image. Likewise, in  FIG. 1 , the Task 2 involving classifying images on English web-sites provides two views: 1) low-level image feature (e.g., graphic object  15 ), and view 2) textual features (e.g., the English language text  25  mapped to tokens  26  representing word stem(s)), e.g., resulting from applying TF-IDF processing of English text extracted from content surrounding the images. Thus, in multi-view, multi-task learning, for classifying web-sites, for each Task, an example view 1 involves classifying images according to its low level image features extracted from images, e.g., color histogram, texture, or shape; and an example view 2 consists of features extracted from text surrounding images as represented by language tokens that span a highly dimensional feature space. Thus, from processing Task 1 and 2 textual feature views (e.g., view 2) there is obtained a highly dimensional feature vector with each element(s) (e.g., a word) having a value if mapped to a corresponding token(s). These view 2 tasks are task specific views as Chinese characters can not be mapped to English language token, and vice versa, English characters can not be mapped to Chinese character tokens. 
     A common view in this example of  FIG. 1  would thus include the low-level image features of each picture(s) or images on a web-site, e.g. a color histogram including a vector of color values. These image feature values, for example, may be output and used to differentiate the images, e.g., cartoon or graphic, or a real photograph. For example, as an output of the classification processing, using the low-level image features, web-sites having cartoon images may be assigned a first label (e.g., a value −1), while web-sites having photographic images may be assigned a second label (e.g., +1). Thus, in the classifying problem of classifying images on web-sites, each image in the site may be assigned a label, for each of many pluralities of web-sites. 
     To solve a multi-task learning nor multi-view learning problem a graph-based framework (GraM 2 ) for M 2 TV learning is implemented. Further there is provided an effective algorithm (IteM 2 ) for the GraM 2  framework where it can be shown that IteM 2  converges to an optimal solution in a scalable way. 
     In M 2 TV learning, there is also performed multi-view learning within a single task. In addition, use is made of the label information from other related tasks, which is particularly useful when the number of labeled examples in a single task is very small. Further in M 2 TV learning, there is also performed multi-task learning via the common views shared by different tasks. In addition, the method and system is able to leverage the consistency among different views of a single task to achieve better performance. 
     M 2 TV: Problem Definition 
     Suppose that there is T tasks and V views in total. Each task has V i  views, 1≦V i ≦V, i=1, . . . , T. Each view corresponds to a type of feature, e.g., bag of words, linkage among the examples, etc. For the i th task and the k th view, there are d ik  features. Let S ij  denote the set of indices of common views shared by the i th and j th tasks. S ii =φ. For example, S 12 ={1} means that Task 1 and Task 2 share the first view. If 1εS 12 , and 1εS 13 , then 1εS 23 . 
     For the i th task, there is n i  examples, which are denoted X i ={x i1 , . . . , x in     i   }⊂ Σ k=1   V     i   d ik . In one embodiment, it is assumed that that the features are non-negative, e.g., word frequency in document classification. Without loss of generality, suppose that the first m i  examples are labeled y i1 , . . . , y im     i   , which are either 1 or −1. Note that m i  is usually very small compared with n i . One goal is to leverage the label information from all the tasks to help classify the unlabeled examples in each task, as well as to use the consistency among different views of a single task to improve the performance (e.g., decrease classification error when classifying entities with labels). 
     GraM 2 : A Graph-Based Framework 
     A graph-based framework (GraM 2 ) is provided for M 2 TV learning. There is first presented its objective function. Then it is shown how it can be reduced to standard supervised learning via an RKHS. 
     In the GraM 2  framework, there is two types of functions defined: “G( )” and “F( )”. Function G( ) is defined on the examples (entity nodes). To be specific, for the i th task, there is defined function g i (•), which takes values on x i1 , . . . , x in     i   ·g i (•)&gt;0 indicates a positive class label whereas g i (•)&lt;0 indicates a negative class label. The other function F( ) is defined on the features (feature nodes). To be specific, for the i th task and the k th view, define function ƒ ik (•), which takes values on the features in this view. ƒ ik (•) helps determine the class label of an example having such features. Take sentiment classification as an example. ƒ ik (•)&gt;0 indicates positive polarity of a word whereas ƒ ik (•)&lt;0 indicates negative polarity. The polarity of all the words in a document together will determine the sentiment of the document. Furthermore, if |ƒ ik (•)| is large, then the corresponding word often has strong polarity; on the other hand, if |ƒ k (•)| is small, then the corresponding word has weak polarity, which may even have conflicting polarity in different context. 
     For the i th task and the k th view, there is constructed a bipartite graph G ik ={N ik , E ik } where N ik  is the set of nodes and E ik  is the set of undirected edges. N ik  consists of two types of nodes, i.e., the nodes that correspond to the examples in this task, and the nodes that correspond to the features in this view. There is an edge between an example node and a feature node if and only if the feature value for the example is positive, and the weight of the edge is just the feature value.  FIG. 2  shows an example of such bipartite graphs. 
       FIG. 2  particularly illustrates a bi-partite graph structure  50  for the M 2 TV learning example  10  of  FIG. 1 . In  FIG. 2 , Task 1 and Task 2 (black squares  52 A,  52 B) have both a shared view (diamonds  55 ) and the task specific views (circles  57   1  and triangles  57   2  for the two views of Task 1, and pluses  58  for the view of Task 2). The weight of an edge between an example entity node (nodes black squares  52 A,  52 B) and a feature node ( 57   1 ,  57   2 ,  58 ) is set to the feature value. Feature nodes attach to entity nodes based on whether that entity has that corresponding feature. If so, an edge (having an associated weight) connects the feature of the entity node. 
     For non-limiting purposes of explanation, bi-partite graph-based structure  50  of  FIG. 2  depicts the example M 2 TV learning problem  10  of  FIG. 1 . As referred to herein, examples or entities refer to the objects that are to be classified or assigned a score (e.g., for regression tasks). Further, as used herein, channels refer to various sources of information for describing entities/examples. The labeled examples are provided as inputs to the programmed algorithm described herein with respect to  FIG. 3 . In  FIG. 1 , square elements  52 A represent the entities in Task 1, e.g., images in Chinese Web-sites; while elements  52 B represent the entities in Task 2, e.g., images in English Web-sites. The shared view elements  55  (e.g., diamonds) represent the features in the shared view, e.g., low-level image features such as a color histogram. Thus, if there are 36 shared color features, these will be represented by 36 elements in set  55 . Task specific views (represented as circles  57   1  and triangles  57   2 ) are shown for the two views of Task 1, and pluses  58  represent the view of Task 2. It is understood that, for each Task  52 A,  52 B there is no limit as to how many specific views each can have. The weight of an edge between an example entity node (nodes black squares  52 A,  52 B) and a feature node ( 57   1 ,  57   2 ,  58 ) is set to the feature value. Feature nodes attach to entity nodes based on whether that entity has that corresponding feature. If so, an edge (having an associated weight) connects the feature of the entity node. 
     In the example, the features  57   1  in Task 1 specific view 1 may correspond to the Chinese tokens obtain from text mapping, while the features  57   2  in Task 1 specific view 2 may correspond to the TF-IDF representation of Tweets (e.g., represented by tokens), for example, in a user&#39;s the social network. Likewise, Task 2, specific view may comprise features  58  corresponding to, for example, the English tokens obtain from text mapping. 
     As shown in example graph  50 ,  FIG. 2 , a word feature (Chinese token)  58  in the Task 1 specific view nodes  57   a  indicates a common feature with two of the entity nodes  53 ,  54 , i.e., first two entity nodes (Chinese Web-site images)  53 ,  54  in Task 1, both have a common textual word feature (e.g. a word token) as indicated by graph edges joining feature node  58  of task 1 specific view 1 nodes  57   1  to respective entity nodes  53 ,  54  in  FIG. 1 . Additionally, entity node  53  in Task 1 (e.g., an image) indicates having two common word features with a social network (e.g. word token entries) as indicated by respective graph edges from entity node  53  joining feature nodes  59   a ,  59   b  of Task 1 specific view 2 nodes  57   2  in  FIG. 2 . 
     This model information is represented as computer data structures accessed and processed by a programmed computing system, e.g., implementing MATLAB available from Mathworks™ (http://www.mathworks.com/products/matlab/). For the example shown in  FIG. 2 , it is desired in one example embodiment, to classify all the images of the Chinese web-site. It may be the case that several classification labels exist for some of the images on Chinese web-sites Task 1 and English web-sites Task 2 (e.g., cartoon (−1 label) or real photograph (+1 label)). However, in an exemplary problem, all remaining Task  52 A,  52 B entities (e.g., images) need to be classified and one example application is to obtain labels for all Chinese and English web-sites according to the bi-partite graph. In the solution to this problem, a function is defined on both the entity nodes and the features node. 
     Generally, in the method for M 2 TV learning, a graph-based framework is built. Within each task, there is constructed a bipartite graph for each view, modeling the relationship between the examples and the features in this view. The consistency among different views is obtained by requiring them to produce the same classification function, which is commonly used in multi-view learning. 
     Across different tasks, their relationship is established by imposing the similarity constraint on the common views. Furthermore, an iterative algorithm is proposed to solve the framework. On one hand, Multi-Task Multi-View learning uses the label information from related tasks to make up for the lack of labeled data in a single task; on the other hand, it uses the consistency among different views to improve the performance. It is tailored for the complicated dual-heterogeneous problems where multiple related tasks have both shared and task-specific views (features), since it makes full use of the available information. 
     With respect to the data representations of a bi-partite graph structure, let W ik , (n i +d ik )×(n i +d ik ), denote the affinity matrix for G ik  having the following structure: 
     
       
         
           
             
               W 
               ik 
             
             = 
             
               [ 
               
                 
                   
                     
                       0 
                       
                         
                           n 
                           i 
                         
                         × 
                         
                           n 
                           i 
                         
                       
                     
                   
                   
                     
                       A 
                       ik 
                     
                   
                 
                 
                   
                     
                       A 
                       ik 
                       T 
                     
                   
                   
                     
                       
                         0 
                         
                           
                             d 
                             ik 
                           
                           × 
                           d 
                         
                       
                       ik 
                     
                   
                 
               
               ] 
             
           
         
       
     
     where A ik  is an n i ×d ik  matrix. If the t th feature of the s th example is positive, then A ik  (s, t) (the element of A ik  in the s th row and t th column) is set to be this feature value. Furthermore, W ik  is normalized to obtain:
 
 T   ik   =D   ik   −1/2   W   ik   D   ik   −1/2   (1)
 
where D ik  is a diagonal matrix whose s th element D ik (s) is equal to the sum of the s th row of W ik .
 
     On bipartite graph G ik , there is observed label consistency among the nodes. To be specific, a positive example (i.e., g i (•)&gt;0) should be connected with positive features (i.e., ƒ ik (•)&gt;0) and vice versa. In a more principled way, the consistency is measured by 
                     C   ik     =       ⁢       ∑     s   =   1       n   i       ⁢       ∑     t   =   1       d   ik       ⁢         A   ik     ⁡     (     s   ,   t     )       ⁢       (           g   i     ⁡     (   s   )             D   ik     ⁡     (   s   )           -         f   ik     ⁡     (   t   )             D   ik     ⁡     (       n   i     +   t     )             )     2                       =       ⁢              g   i          2     +            f   ik          2     -     2   ⁢     g   i   T     ⁢     L   ik     ⁢     f   ik                     
where L ik  is an n i ×d ik  matrix, and its element in the s th row and t th column L ik  (s, t)=T ik (s, n i +t).
 
     In this way, for Task i, there is had V i  such bipartite graphs, which correspond to C i1 , . . . , C iV     i   . Therefore, the overall consistency of Task i is measured by 
               C   i     =         ∑     k   =   1       V   i       ⁢           ⁢       a   ik     ⁢     C   ik         +       μ   i     ⁢          g   i            -            y   i          2             
where a ik , μ i  are positive parameters, and y i  is an n i -dimensional vector. The first m i  elements of y i  are set to be the class labels of the corresponding examples, and the remaining elements are set to be 0. In C i , the first term implicitly measures the consistency among different views since the function g i (•) is shared by all the bipartite graphs, and the second term measures the consistency with the label information.
 
     On the other hand, if Task i and Task j are directly related, i.e., S ij ≠φ, it is hoped to observe similarity on the common views of the two tasks. To be specific, ∀kεS ij , ∥ƒ ik −ƒ jk ∥ 2  should be small. In this way, given a certain task, the information of other related tasks can be leveraged to improve its performance. 
     Combining the overall consistency of each task and the similarity on the common views of different tasks, there is obtained the following objective function for GraM 2 . 
                     Q   ⁡     (     f   ,   g     )       =         ∑     i   =   1     T     ⁢           ⁢     C   i       +     b   ⁢       ∑     i   =   1     T     ⁢           ⁢       ∑     j   =   1     T     ⁢       ∑     k   ⁢           ⁢   ε   ⁢           ⁢     S   ij         ⁢              f   ik     -     f   jk            2                       (   2   )               
where ƒ is function defined on feature node, and g is function defined on entity nodes, and where b is a non-negative parameter. When b=0, different tasks are decoupled.
 
       FIG. 3  provides an effective method (IteM 2 )  100  for solving this optimization problem. 
     The proposed IteM 2  algorithm  100  of  FIG. 3  programmed for example, in MATLAB, works as follows: Step (1) is an initialization step, where using the algorithm  200  depicted in  FIG. 3 , there is calculated the normalized affinity matrices using Equation (1), and initialize the function g i  for Task i to include the label information. Referring back to  FIG. 3 , at  110  corresponding from Steps (2) to (24), there is repeatedly updated both the function g i  and the function ƒ ik  by n iter  times. In particular, at  115 , corresponding to steps (3)-(8) there is depicted that portion of the solution that iterates over the number of tasks; and, at each iteration, updates the function f( ) defined on each view for the task-specific non-shared views defined for each task. 
     Then, at  120  between Steps (9) and (17), there is depicted that portion of the solution that iterates over the number of views, determines at each iteration whether a current view is shared by a task; and if determined that the current view is shared, updating the function f( ) defined on the view for the shared view. More particularly, for the k th view, there is collectively updated the functions ƒ ik  for the tasks with this view. To be specific, the matrix A 3  is calculated as follows:
 
 A   3   =A   2   A   1   −1   (3)
 
where A 1  denotes an |I k |×|I k | matrix with diagonal element A 1 (i,i) set to a I     k     (i)k +2b(|I k |−1), (I k (i) is the i th  element of I k ), and the other elements set to −2b; A 2  denotes an d k ×|I k | matrix whose i th  column is set to a I     k     (i)k L I     k     (i)k   T g I     k     (i) .
 
     Then, returning to  225 ,  FIG. 1  corresponding to steps (18)-(24), there is depicted iterating over the number of tasks i, calculate an intermediate parameter and update the function g( ) defined for each task as a function of the calculated intermediate parameter and sub-matrix (L ik ) of the normalized affinity matrix and the updated function f( ). 
     Finally, in Step (25), there is obtained the predicted class labels using the algorithm of  300  of  FIG. 5 , which normalizes the function g i  according to the proportion of both classes in the labeled set of each task. For example, there is calculated a percentage of examples having positive label values in an initial set of examples. For example, as a result of processing algorithm  100 , the functions g( ) are sorted according to their values in a descending order; and then the top g( ) functions are assigned a same positive label to according to the example percentage, and the remaining functions g( ) are assigned the opposite label values. 
     The optimality and convergence of the iteration process between Step (2) and (25) of IteM 2  algorithm is guaranteed. That is, it can be proved that If n iter  is sufficiently large, V i =v, μ i =μ, and a ik =a, i=1, . . . , T, k=1, . . . , v, Step (2) to (25) of IteM 2  converge to the optimal solution of Equation (2). 
     An example as to the effectiveness of the classification function according to the IteM 2  method is now described. In one, non-limiting example experiment, there is applied a SVM-2K algorithm such as described in a reference to J. D. R. Farquhar et al. entitled “Two view learning: SVM-2K,” Theory and Practice. NIPS, 2005 on the multiple views of each task respectively; with other conventional techniques, e.g., SMTL such as described in a reference to Qiuhua Liu et al. entitled “Semi-Supervised Multitask Learning”,  NIPS,  2007—a semi-supervised multi-task learning framework, which uses unlabeled data based on Markov random walk, and CASO such as described in a reference to Jianhui Chen et al. entitled “A convex formulation for learning shared structures from multiple tasks”  ICML, pages  18, 2009—: a multi-task learning algorithm—applied on the common views of all the tasks. To provide a fair comparison, the output of these competitors are adjusted in the same way. All the experiments are repeated a multiple of times, and report both the average classification error and the standard deviation. 
     For the proposed IteM 2  algorithm, there is initially set a ik =1, i=1, . . . , T, k=1, . . . , V i  since there is no evidence showing the superiority of one view or another. In one embodiment, there is set μ i =0.01, i=1, . . . , T. The number of iteration steps n iter  is set to 100, for example, and parameter b is set to 1 in the example. 
     Two Tasks with Non-Identical Views 
     In an example directed to two tasks with non-identical views, there is first performed experiments on 20 newsgroups data set. On this data set, three (3) problems were created, each problem having 2 tasks, which share a common view consisting of the common vocabulary. The task specific vocabulary corresponds to the unique view of each task. Therefore, in this example, there is set T=2, V=3, V 1 =V 2 =2, S 12 ={1}. Table 1 provides a task description for 20 newsgroups data set details of the data set, where the number following ‘P’ denotes the problem index, the number following ‘T’ denotes the task index, and the number in the parenthesis is the number of examples. 
     
       
         
           
               
               
               
             
               
                 TABLE 1 
               
               
                   
               
               
                 LABEL 
                 +1 
                 −1 
               
               
                   
               
             
            
               
                 P1T1 
                 COMP. GRAPHICS (581) 
                 RE. AUTOS (592) 
               
               
                 P1T2 
                 COMP.OS. MS- 
                 REC.MOTORCYCLES (596) 
               
               
                   
                 WINDOWS.MISC (572) 
               
               
                 P2T1 
                 COMP.SYS.IBM. 
                 SCI.MED (594 
               
               
                   
                 PC.HARDWARE (587) 
               
               
                 P2T2 
                 COMP.SYS.MAC. 
                 SCI.SPACE (593) 
               
               
                   
                 HARDWARE (575) 
               
               
                 P3T1 
                 REC.AUTOS (592) 
                 TALK.POLITICS.MIDEAST 
               
               
                   
                   
                 (564) 
               
               
                 P3T2 
                 REC.MOTORCYCLES 
                 TALK.POLITICS.GUNS 
               
               
                   
                 (596) 
                 (545) 
               
               
                   
               
            
           
         
       
     
     For this example, the results of IteM 2  when the value of b are varied from 100 to 0 indicate that when b=0, the performance is the worst, especially when the number of labeled examples from each task is small. This is because the label information from other tasks is not utilized. On the other hand, the performance of IteM 2  is quite robust over a wide range of values for b. Therefore, in subsequent experiments, b=1. 
       FIGS. 6A and 6B  are illustrative of the comparison results on the three problems. That is, the representative results shown in  FIG. 6A  indicate the classification error for Task 1 vs. the number of labeled examples in each task, and the results shown in  FIG. 6B  indicate the classification error for Task 2 vs. the number of labeled examples in each task. From  FIGS. 6A and 6B , it is seen that the performance of IteM 2  is the best on both tasks, since SVM-2K does not utilize the label information from other tasks, whereas SMTL and CASO techniques do not consider the consistency among different views of a single task. Furthermore, it is noticed that the difference between SVM-2K and IteM 2  is significant when the number of labeled examples is small. This observation, is consistent because labeled examples from other tasks are particularly useful when there are not many labeled examples in a single task. 
     Multiple Tasks with Identical Views 
     As a further example, the performance of IteM 2  was tested on a “WebKB” data set, which was used to study a co-training algorithm as described in a reference to Avrim Blum et al. entitled “Combining Labeled and Unlabeled Sata with Co-Training”,  COLT,  1998. This data set consists of 1051 web pages collected from the computer science departments of several universities. The goal is to classify each web page as either “course” related or non-course related. On this data set, there are four (4) tasks, each of which consists of the web pages from one university. For each task, there is had three (3) views, which correspond to the words in the web page, the words in the anchor text of hyperlinks pointing to that page, and the words in the title of the web page. It is noted that all 3 views are shared by the 4 tasks. Therefore, T=4, V=3, V i =3, and S ij ={1, 2, 3}, i, j=1, . . . , 4, i≠j. Notice that for such problems (multiple tasks with identical views), the input to IteM 2 , SMTL and CASO are the same since all the tasks have identical views.  FIG. 7  shows an average classification error of all the tasks vs. the number of labeled examples in each task. As shown in  FIG. 7 , the performance of IteM 2  is significantly better than SMTL and CASO, due to leveraging the consistency of multiple views. 
     Multiple Tasks and Non-Identical Views 
     A more general case is now described where there is had multiple tasks with non-identical views. To this end, a email spam data set from ECML 2006 discovery challenge (see, http://www.ecmlpkdd2006.org/challenge.html) is used. In this example, there is had two problems. In Problem A, there are emails from 3 different users (2500 emails per user); whereas in Problem B, there are emails from 15 different users (400 emails per user). The goal is to classify spam vs. ham. For both problems, there is create different tasks for different users. The common view of all the tasks correspond to the common vocabulary, and the unique view of each task correspond to the task-specific vocabulary. Therefore, for Problem A, T=3, V=4, V 1 =V 2 =V 3 =2, and S 12 =S 13 =S 23 ={1}; for Problem B, T=15, V=16, V i =2, and S ij ={1}, i, j=1, . . . , 15, i≠j. 
       FIGS. 8A and 8B  each shows an average classification error of all the tasks vs. the number of labeled examples in each task for Problem A and B, respectively. 
     Other applications of the graph-based methodology described herein include: classifying songs, e.g., on web-sites. For example, as a further learning example including an example task of classifying foreign language (e.g., Chinese) songs and English songs, a Task 1 may involve classifying Chinese songs, while a Task 2 involves classifying English songs. Task 1 would provide two (2) views: 1) low-level audio features (e.g., pitch-class profile), and view 2) textual features (e.g., the Chinese language song lyric mapped to tokens resulting from applying TF-IDF processing of the Chinese song lyrics). Likewise, the Task 2 involving classifying English songs provides two views: 1) low-level audio feature (e.g., pitch-class profile), and view 2) textual features (e.g., the English language song lyric mapped to tokens resulting from applying TF-IDF processing of English song lyric). Thus, in multi-view, multi-task learning, for classifying songs, for each Task, an example view 1 involves classifying songs according to its low level audio features extracted, e.g., audio pitch-class profile; and an example view 2 consists of features extracted from the song lyrics as represented by language tokens. A common view for both Tasks 1 and 2 would be an audio feature such as pitch-class profile. 
     Further example uses are contemplated. For example, the methodology herein could be employed as an example regression task, which may be related to a component within a Question-Anwer (QA) computer system, e.g., the Watson QA system of International Business Machines, Inc. (“IBM”). In such a QA system a Task 1 involves scoring candidate answers in a first language, e.g. Chinese, to a question in that first language, e.g., Chinese, (Task 1), and Task 2 involves scoring answers to a question in a second language, e.g., English (Task 2), and which candidate answers may take on many values. Scoring candidate answers may be performed on both the Chinese and English answers, e.g., Chinese questions result in processing Chinese documents/sources to obtain Chinese candidate answers, while English questions result in processing English documents/sources to obtain English candidate answers. An application performed by the a QA system thus, may be to obtain scores to candidate answers of the set of Chinese questions (Task 1), and simultaneously obtain English candidate answers to the same questions in English (Task 2). However, it may be found that the Chinese language candidate answers may not be sufficient or limited. In this example, the methodology leverages the relatedness between the English domain and the Chinese domain to generate better answers for Chinese questions. Thus to adopt a QA system to another language, e.g., a language such as Chinese, then Watson may first translate a Chinese question to an English equivalent in order to find/obtain better English candidate answer from the English language processing as opposed to the Chinese language processing. In regression, the output is any numerical value (output is continuous). However, their common view may be language-invariant features, e.g., geographical information (e.g., geographic features), or their TD-IDF representation as tokens. 
     Further example use of the methodology described herein include applications for IP licensing to companies that sell multi-media analysis (requiring image classification) and music recommendation systems. 
     A further example use of the methodology described herein includes application(s) for Social Media Analysis (e.g., Banter). For example, label information from benchmark data sets may be leveraged to analyze online media, e.g., from Twitter, blog posts, etc. 
     A further example use of the methodology described herein include application(s) that leverage the knowledge learned for Jeopardy! to perform tasks in other domains, e.g., medical analytics, or for example provide a cross-lingual Jeopardy! wherein English learning is leveraged to extend a QA system to other languages. 
     For example, as shown in  FIG. 9 , shows an example M 2 TV learning problem  350  which the system and methods described is configured to extend operability of a Question-Answering (QA) system in a first language to other languages. In such a solution, Task 1 is shown to provide the answer for a question in one language (e.g., Chinese), and Task 2  370  is to provide the answer for the same question in another language (e.g., English). Here, the examples (entities)  360  in Task 1 and entities  370  in Task 2 correspond to the candidate answers. The common view  375  of the two tasks includes language-invariant features (features that are independent of language), and the specific views of the two tasks, i.e., task specific view  380  corresponding to Task 1 and task specific view  390  corresponding to Task 2 consists of language-dependent features. 
       FIG. 10  illustrates an exemplary hardware configuration of a computing system  400  running and/or implementing the method steps described herein. The hardware configuration preferably has at least one processor or central processing unit (CPU)  411 . The CPUs  411  are interconnected via a system bus  412  to a random access memory (RAM)  414 , read-only memory (ROM)  416 , input/output (I/O) adapter  418  (for connecting peripheral devices such as disk units  421  and tape drives  440  to the bus  412 ), user interface adapter  422  (for connecting a keyboard  424 , mouse  426 , speaker  428 , microphone  432 , and/or other user interface device to the bus  412 ), a communication adapter  434  for connecting the system  400  to a data processing network, the Internet, an Intranet, a local area network (LAN), etc., and a display adapter  436  for connecting the bus  412  to a display device  438  and/or printer  439  (e.g., a digital printer of the like). 
     As will be appreciated by one skilled in the art, aspects of the present invention may be embodied as a system, method or computer program product. Accordingly, aspects of the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as a “circuit,” “module” or “system.” Furthermore, aspects of the present invention may take the form of a computer program product embodied in one or more computer readable medium(s) having computer readable program code embodied thereon. 
     Any combination of one or more computer readable medium(s) may be utilized. The computer readable medium may be a computer readable signal medium or a computer readable storage medium. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the computer readable storage medium would include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with a system, apparatus, or device running an instruction. 
     A computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with a system, apparatus, or device running an instruction. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing. 
     Computer program code for carrying out operations for aspects of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C++ or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The program code may run entirely on the user&#39;s computer, partly on the user&#39;s computer, as a stand-alone software package, partly on the user&#39;s computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user&#39;s computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). 
     Aspects of the present invention are described below with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which run via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. These computer program instructions may also be stored in a computer readable medium that can direct a computer, other programmable data processing apparatus, or other devices to function in a particular manner, such that the instructions stored in the computer readable medium produce an article of manufacture including instructions which implement the function/act specified in the flowchart and/or block diagram block or blocks. 
     The computer program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other devices to cause a series of operational steps to be performed on the computer, other programmable apparatus or other devices to produce a computer implemented process such that the instructions which run on the computer or other programmable apparatus provide processes for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. 
     The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more operable instructions for implementing the specified logical function(s). 
     It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be run substantially concurrently, or the blocks may sometimes be run in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts, or combinations of special purpose hardware and computer instructions. 
     While there has been shown and described what is considered to be preferred embodiments of the invention, it will, of course, be understood that various modifications and changes in form or detail could readily be made without departing from the spirit of the invention. It is therefore intended that the scope of the invention not be limited to the exact forms described and illustrated, but should be construed to cover all modifications that may fall within the scope of the appended claims.