# Patent

## Title
Large-scale data clustering with dynamic social context

## Abstract

A system and method for dynamic, semi-supervised clustering comprises receiving data attributes, generating a set of ensemble partitions using the data attributes, forming a convex hull using the set of ensemble partitions, generating a simplex vector by performing ensemble clustering on the convex hull, receiving dynamic links, deriving an optimal simplex vector using the simplex vector and the dynamic links, computing a current optimal clustering result using the optimal simplex vector, and outputting the current optimal clustering result.

## Background
BACKGROUND
The present disclosure relates generally to the field of semi-supervised clustering.
Data clustering is an important task that has found numerous applications in many domains, including information retrieval, recommender systems, computer vision, etc. However, data clustering is inherently a challenge and ill-posed problem due to its unsupervised nature. Semi-supervised clustering addresses this issue by effectively exploring the available side information that is often cast in the form of pairwise constraints: must-links for pairs of data points that belong to the same cluster, and cannot-links for pairs of data points that belong to different clusters. There are two major categories of approaches to semi-supervised clustering: (i) the constrained clustering approaches that employ the side information to restrict the solution space and only find the solution that is consistent with the pairwise constraints, and (ii) the distance metric learning based approaches that first learn a distance metric from the given pairwise constraints, and then perform data clustering using the learned distance metric.
One issue that is often overlooked by the existing semi-supervised clustering approaches is how to efficiently update the data partitioning when the pairwise constraints are dynamic, i.e., when new pairwise constraints are generated sequentially. This is a natural situation in various real-world applications. For example, in social networks, the user attributes, such as gender, school, major, nationality, interests, etc., can be considered as features, and the social connections, like friendship and common community membership, can be considered as the side information. Hence, the task of grouping users is essentially a semi-supervised clustering problem. However, since the connections in the social network are often changing, one needs a semi-supervised clustering algorithm that is able to cope with dynamic pairwise constraints. In addition, applications of crowdsourcing often require soliciting contributions dynamically collected from a large group of human workers. In the framework of semi-supervised crowd clustering, a set of objects should be partitioned based on their features as well as manual annotations collected through crowdsourcing, where those annotations (e.g., pairwise constraints) are provided by a set of online users instead of a single oracle in a sequential way.
Active semi-supervised clustering aims to select the pairwise constraints or queries in an active way to improve the clustering performance. Thus this active clustering also needs efficient updating with dynamic pairwise constraints. Due to the requirements of dynamic updating, neither the constrained clustering nor the distance metric based semi-supervised clustering efficiently update the partitioning results when the pairwise constraints are changed since each clustering needs to re-optimize the objective function over all the data points, making both clusterings computationally infeasible for large scale datasets.
Moreover, in social network analysis, the problem of updating the user communities based on the connections has attracted growing attention. However, the existing work about social network partitioning are different from the setting of dynamic semi-supervised clustering, mainly because of the following two reasons: (i) the existing work often only uses link information to guide the clustering and ignores the important feature information of the data points (i.e., users), and (ii) the existing work needs to observe all the link information between users, while semi-supervised clustering only assumes to observe a small portion of pairwise constraints to guide the partition.
BRIEF SUMMARY
A system and method which provides a solution to the need for efficient and dynamic semi-supervised clustering is presented. The solution enables efficiently updating the clustering results given new pairwise constraints. Due to the flexibility of handling both data features and dynamic relational information, the semi-supervised clustering is a more general formulation which can be applied in numerous scenarios including, but not limited to, social network partitioning.
A method for dynamic, semi-supervised clustering can comprise receiving data attributes, generating a set of ensemble partitions using the data attributes, forming a convex hull using the set of ensemble partitions, generating a simplex vector by performing ensemble clustering on the convex hull, receiving dynamic links, deriving an optimal simplex vector using the simplex vector and the dynamic links, computing a current optimal clustering result using the optimal simplex vector, and outputting the current optimal clustering result.
A system for dynamic, semi-supervised clustering can comprise a memory, an output device and a hardware processor configured to: receive data attributes, generate a set of ensemble partitions using the data attributes, form a convex hull using the set of ensemble partitions, generate a simplex vector by performing ensemble clustering on the convex hull, receive dynamic links, derive an optimal simplex vector using the simplex vector and the dynamic links, compute a current optimal clustering result using the optimal simplex vector, and output the current optimal clustering result to the output device.
In one aspect, receiving links, deriving an optimal simplex vector, and computing a current best clustering result are repeated. In one aspect, the attributes are received from one of: handwritten images as vectors, and a profile obtained from a social networking platform. In one aspect, the ensemble partitions are generated using fast spectral clustering with subspace sampling. In one aspect, the ensemble partitions are generated using fast spectral clustering with a Hungarian algorithm. In one aspect, the dynamic links comprising must-link links and cannot-link links.
A program storage device readable by a machine, tangibly embodying a program of instructions executable by the machine to perform methods described herein may be also provided.
Further features as well as the structure and operation of various embodiments are described in detail below with reference to the accompanying drawings. In the drawings, like reference numbers indicate identical or functionally similar elements.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 shows the basic steps of the inventive algorithm.
FIG. 2 shows an exemplary algorithm in one embodiment of the present invention.
FIGS. 3A and 3B illustrate NMI vs. number of ensemble partitions with different pairwise constraints.
FIGS. 4A-4F illustrate clustering performances averaged over a plurality of trials.
FIG. 5 illustrates a table of average CPU time for updating the partition in each tier.
FIG. 6 illustrates exemplary computing systems that can run the method of the present invention in one embodiment.



DETAILED DESCRIPTION
A system and method for efficient and dynamic semi-supervised clustering via convex searching is presented. The system and method is both time and memory efficient. In the system and method, the clustering problem can be cast into a searching problem in a feasible clustering space, where each point in that space corresponds to one partitioning result of the data. The dynamic semi-supervised clustering algorithm presented herein directly searches in a convex clustering space to derive a feasible partitioning that is consistent with the updated pairwise constraints. The clustering space is a convex hull with the extreme points being m different partitions of the initial n data points after realigning by the Hungarian algorithm (see Harold W. Kuhn, “The Hungarian Method for the Assignment Problem”). Each of the m partitions is known as an ensemble partition denoted by P1, P2, . . . , Pm.
Note that any inner point in such a convex hull can be mapped to a feasible data partitioning. According to the median partition based ensemble clustering approaches, the optimal partition should be similar to all the ensemble partitions. In other words, the optimal partition should lie in the inner space of this convex hull and the partition can be uniquely represented as an m-dimensional simplex vector γ={γ1, . . . , γm} given that the m extreme points are fixed. In particular, when a set of new pairwise constraints is received at time t, the simplex γt is updated based on γt-1 through a natural relaxation of the gradient descent step. Since γt-1 is the optimal solution that is consistent with both the data features and the pairwise constraints received before time t, the partition can be updated to γt directly from γt-1 based on the newly arrived pairwise constraints without considering all of the n data points. After updating γt, the partitioning matrix can be obtained by a convex combination of the ensemble partitions as P=γt1P1+γt2P2+ . . . +γtmPm, where γti indicates the i-th entry of the simplex vector γt. Then the final data partitions can be obtained by applying fast k-means algorithm on P.
FIG. 1 shows one embodiment of a method that is run on a computer system, such as, for example, the system shown in FIG. 6, which will be described in detail below. The basic steps of FIG. 1 are as follows. In step S101, the system receives or obtains data attributes that are processed to generate m different ensemble partitions P1, P2, . . . , Pm 102 from data attributes. These data attributes can be obtained, for example, as vectors from handwritten images, such as digital images, scanned imaged, etc., or from a user profile in a social networking platform such as LinkedIn®, FacebookTM, etc. In step S105, the computer system is configured to form a convex hull 104 using the generated ensemble partitions. In step S109, a start point, e.g., simplex vector 106, is generated by ensemble clustering performed using the convex hull. Steps S101-S109 can be performed in an off-line or static mode, as discussed in more detail below.
In step S111, the system receives new pairwise constraints, for example at time t, and updates the simplex vector based on the newly received pairwise constraints and a previously generated simplex vector, if available. (In the initial execution of the algorithm, no previously generated simplex vector exists.) The simplex vector can be updated through solving a mathematical optimization problem, as is known to one skilled in the art. In step S115, the system is configured to compute the current optimal clustering results. In one embodiment, this may be performed using a k-means clustering algorithm. In other words, the clusters are efficiently updated in accordance with the dynamic links to create a current optimal clustering result. This result can be displayed on an output device such as a printer or computer monitor. In one embodiment, the display of results can be a graphical demonstration. In one embodiment, the display of results can be a text format indicating the group memberships of each item, such as users, objects, etc. Steps S111-S115 can be performed dynamically, and can be repeated as additional dynamic links are received.
The current best clustering result can be, for example, clusters or small groups of data based on particular attributes. For example, if the data attributes received in step S101 are obtained from a user's profile which includes user's location and user's language, then the current optimal clustering result can be clusters of users grouped by attributes of user location and user language. In another example, if the data attributes are obtained from handwritten images which include color, then the current optimal clustering result can be clusters of images grouped by attribute of color. Other attributes can also be used.
In summary, the dynamic clustering is performed through updating an m-dimensional simplex vector, where the computational cost is only related to m, the dimension of the simplex space. Note that a simplex vector is a vector whose elements are non-negative and the summation of all of the elements equals one (1). Typically, the value of m will be far smaller than the size of data n. Hence, the online updating process of the algorithm is extremely scalable. To verify the efficiency and effectiveness of this algorithm, empirical studies, which were conducted on several real-world benchmark datasets, are described below. The results show that this algorithm outperforms state-of-the art semi-supervised clustering algorithms in both clustering accuracy and computational efficiency.
The system and method can be described in more detail as follows. Let D={O1, . . . , On} be the set of n objects to be clustered, and let X=(x1, . . . , xn) be their feature representations, where xiεRd is a vector of d dimensions. Given X, one can easily derive a similarity matrix W ε Rnxn, where Wij indicates the similarity between object i and object j based on their features. Let M denote the set of new must-link constraints where (xi, xj)εM implies that xi and xj should be in the same cluster. Let C denote the set of new cannot-link constraints, where (xi, xj)εC implies that xi and xj belong to different clusters. For the convenience of presentation, also define set Ωt=M ∪ C to include all the new pairwise constraints generated at time t. Also, Ωt_is denoted as all the existing pairwise constraints generated before time t and Ω=Ωt ∪ Ωt_. Let r be the number of clusters. In one embodiment, the inventive dynamic semi-supervised clustering algorithm partitions n objects into r clusters that are (i) consistent with the data matrix X and the existing pairwise constraints Ωt _ such that data points with similar input patterns and dense connections are put into the same cluster, and (ii) are able to efficiently update the clusters with new pairwise constraints in Ωt.
A set of binary membership matrices is defined as F={F|Fε{0,1}n×r, F*iTF*j=0∀i≠j, ΣFk*=1: ∀k}. Given the similarity matrix W and the pairwise constraints Ω, a set of classical constrained clustering algorithms want to find a membership matrix F which optimize the following objective function:




  
    
      
        
          
            
              min
              
                F
                ∈
                F
              
            
            ⁢
            
              
                1
                
                  
                  Ω
                  
                
              
              ⁢
              
                
                  ∑
                  
                    s
                    ∈
                    Ω
                  
                
                ⁢
                
                  
                
                ⁢
                
                  L
                  ⁡
                  
                    (
                    
                      s
                      ,
                      F
                    
                    )
                  
                
              
            
          
          +
          
            λR
            ⁡
            
              (
              
                W
                ,
                F
              
              )
            
          
        
        ,
      
    
    
      
        (
        
          EQ
          ⁢
          
            
          
          ⁢
          1
        
        )
      
    
  




where  (•) is a loss function which incurs non-zero penalty if the membership F is not consistent with the pairwise constraint s, and R (•) is a regularizer function to impose a reasonable partition given the similarity matrix W.
To efficiently update the membership matrix F with new pairwise constraints, the data clustering problem is transferred into a searching problem in a convex set, such that each inner point of the set can map to a feasible clustering result. To this end, all the possible clustering results form a convex hull with rn extreme points. Then this set can be restricted to a smaller convex hull with significantly fewer extreme points by applying a spectral relaxation.
Next, a convex searching space is generated. In this generating step, the clustering problem is cast into the problem of searching in a convex set. To this end, (EQ 1) is rewritten by defining regularizer function R (•) as graph embedding function:




  
    
      
        
          
            min
            
              F
              ∈
              F
            
          
          ⁢
          
            
              1
              
                
                Ω
                
              
            
            ⁢
            
              
                ∑
                
                  s
                  ∈
                  Ω
                
              
              ⁢
              
                
              
              ⁢
              
                L
                ⁡
                
                  (
                  
                    s
                    ,
                    F
                  
                  )
                
              
            
          
        
        +
        
          λ
          ⁢
          
            
          
          ⁢
          
            tr
            ⁡
            
              (
              
                
                  F
                  T
                
                ⁢
                LF
              
              )
            
          
        
      
    
    
      
        (
        
          EQ
          ⁢
          
            
          
          ⁢
          2
        
        )
      
    
  




where tr(•) is the trace function and L is the graph Laplacian matrix defined by L=D−W (e.g., L is an approximation of  in EQ 1). Here D is a diagonal matrix D=diag(d1, d2, . . . , dn) with di=Σj Wij. The reason to use graph embedding as regularization function is that:




  
    tr
    ⁡
    
      (
      
        
          F
          T
        
        ⁢
        LF
      
      )
    
  
  =
  
    
      1
      2
    
    ⁢
    
      
        ∑
        
          i
          =
          1
        
        r
      
      ⁢
      
        
      
      ⁢
      
        
          ∑
          
            j
            ,
            
              k
              =
              1
            
          
          n
        
        ⁢
        
          
        
        ⁢
        
          
            
              W
              jk
            
            ⁡
            
              (
              
                
                  F
                  ji
                
                -
                
                  F
                  ki
                
              
              )
            
          
          2
        
      
    
  




enables finding the partitions such that the objects in the same cluster share large similarities while the objects from different clusters share small similarities. However, it can be shown that




  
    min
    
      F
      ∈
      F
    
  
  ⁢
  
    tr
    (
    
      
        F
        T
      
      ⁢
      LF
    
    )
  




binary integer programming (“BIP”) problem, which is NP hard and not easy to optimize.

To address the above issue, the objective (EQ 2) subject to the following constraint optimization problem can be rewritten as:




  
    
      
        
          
            min
            
              F
              ∈
              F
            
          
          ⁢
          
            
              1
              
                
                Ω
                
              
            
            ⁢
            
              
                ∑
                
                  s
                  ∈
                  Ω
                
              
              ⁢
              
                
              
              ⁢
              
                L
                ⁡
                
                  (
                  
                    s
                    ,
                    F
                  
                  )
                
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              s
              .
              t
              .
              
                
              
              ⁢
              
                tr
                ⁡
                
                  (
                  
                    
                      F
                      T
                    
                    ⁢
                    LF
                  
                  )
                
              
            
            ≤
            Λ
          
          ,
        
      
    
    
      
        (
        
          EQ
          ⁢
          
            
          
          ⁢
          3
        
        )
      
    
  




where Λ is a positive parameter ensuring that the optimization function (EQ 3) has feasible solutions. The set Δ={F|tr(FTLF)≦Λ, FεRnxr}. Note that this set Δ is a convex set given the graph Laplacian matrix L is a Positive-Definite (PSD) Matrix. The constraint optimization problem (EQ 3) is used to find a partition in the convex set Δ that best matches all the pairwise constraints in Ω. Since the convex set Δ is still not easy to project into, the set Δ can be approximated to another convex set that is much easier to represent. Accordingly, the following lemma is provided.
Lemma 1: All the feasible partitions Fε  are the extreme points of a convex hull. This can be easily proved by contradiction.
Suppose not all the feasible partitions Fε  are the extreme points of a convex hull, then at least one feasible partition, denoted as F1, is the inner point of a convex hull whose extreme points are some other feasible partitions F1, . . . Fl ε. Thus, F1 is a convex combination of F1, . . . Fi:




  
    F
    i
  
  =
  
    
      ∑
      
        j
        =
        1
      
      l
    
    ⁢
    
      
    
    ⁢
    
      γ
      ⁢
      
        
      
      ⁢
      
        jF
        j
      
    
  




where γ is an l-dimensional vector satisfying γ≧0 and 1Tγ=1. Note that each row of Fi contains only a single one (1) and all the other elements are zero (0); γj should be equal to 0 for any Fj≠Fi. Otherwise Fi cannot be equal to




  A
  =
  
    
      ∑
      
        j
        =
        1
      
      l
    
    ⁢
    
      
    
    ⁢
    
      γ
      ⁢
      
        
      
      ⁢
      
        jF
        j
      
    
  




since there exist at least one index (a, b) such that Fi (a, b)=0 while A(a,b)>0. Since Fi≠Fj, ∀j=1, . . . l, we have Y=01, which contradict with the constraint 1Tγ=1.

Similarly, the following lemma can be derived.
Lemma 2. Any non-empty subsets of  are the extreme points of a convex hull.
Given Lemma 2, the algorithm finds a set of feasible partitions in  to form a convex hull Δ′ such that it is a good approximation to the convex constraint set Δ in (EQ 3). To obtain multiple partitions using spectral clustering, a common strategy can be used to generate multiple partitions of a same data set in ensemble clustering. First, randomly select some subsets of features in X, then generate m different similarity matrices denoted as S1, S2, . . . , Sm. Then apply the spectral clustering algorithm, which is a spectral relaxation of an NP hard normalized graph cut, to find multiple data partitions, i.e. compute the top r eigenvectors of Si, i=1, . . . , m, and then run the k-means cluster algorithm over the computed eigenvectors. To improve the computational efficiency, apply a spectral clustering algorithm that reduces computational cost by a matrix sparsification technique and a Nystrom approximation.
Let P1, . . . , Pmε be m ensemble partitions that are generated from spectral clustering using random subspaces, followed by applying the Hungarian algorithm to realign their labels. Then, a convex hull can be formed according to:




  
    
      Δ
      ′
    
    =
    
      {
      
        
          
            F
            ❘
            F
          
          =
          
            
              ∑
              
                i
                =
                1
              
              m
            
            ⁢
            
              
                γ
                i
              
              ⁢
              
                P
                i
              
            
          
        
        ,
        
          γ
          ≥
          0
        
        ,
        
          
            
              1
              T
            
            ⁢
            γ
          
          =
          1
        
      
      }
    
  
  ,




where each simplex vector γ corresponds to one point F in the convex hull Δ′ and r clusters can be easily generated by running a simple clustering algorithm such as k-means on F.
In one embodiment, the validity of searching feasible partitions in the convex hull Δ′ is ensured by: (i) since spectral clustering essentially optimizes




  
    min
    
      F
      ∈
      F
    
  
  ⁢
  
    tr
    ⁡
    
      (
      
        
          F
          T
        
        ⁢
        LF
      
      )
    
  




by spectral relaxation, the extreme points F1, . . . , Fm obtained using spectral clustering should form a convex hull that is closely related to the original convex set Δ={F| tr(FTLF)≦Λ, FεRnxr} in the optimization problem (EQ 3), and (ii) according to the median partition based ensemble clustering approaches, the optimal partition should be similar to all the individual partitions indicating that the optimal partition should lie in the inner space of the convex hull Δ′ and it can be uniquely represented by an m-dimensional simplex vector γ.

Then the problem of finding a large-scale n x r matrix F is cast into the problem of finding an m-dimensional simplex vector γ, according to (EQ 4) as follows:




  
    
      
        
          
            min
            
              γ
              ∈
              
                R
                m
              
            
          
          ⁢
          
            
              1
              
                
                Ω
                
              
            
            ⁢
            
              
                ∑
                
                  s
                  ∈
                  Ω
                
              
              ⁢
              
                L
                ⁡
                
                  (
                  
                    s
                    ,
                    F
                  
                  )
                
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              s
              .
              t
              .
              
                
              
              ⁢
              F
            
            =
            
              
                ∑
                
                  i
                  =
                  1
                
                m
              
              ⁢
              
                
                  γ
                  i
                
                ⁢
                
                  F
                  i
                
              
            
          
          ,
          
            

          
          ⁢
          
            γ
            ≥
            0
          
          ,
          
            

          
          ⁢
          
            
              
                1
                T
              
              ⁢
              γ
            
            =
            1.
          
        
      
    
    
      
        (
        
          EQ
          ⁢
          
            
          
          ⁢
          4
        
        )
      
    
  




Since m=O(1) is a small number that is irrelevant to the data size n, the proposed semi-supervised algorithm is very efficient and can handle very large-scale datasets.
Efficiently Updated Dynamic Semi-supervised Clustering is now described. When the existing pairwise constraints set Ωt_ is empty, the problem (EQ 4) reduces to an ensemble clustering problem which aims to combine multiple partitions of a dataset, generated by different clustering algorithms, into a single data partition. The clustering result in terms of simplex vector γ, denoted as vector γ0, can be simply set to (1/m, . . . , 1/m) or obtained by some existing ensemble clustering algorithms. Note that the pairwise constraints set Ω contains two subsets: the new pairwise constraints Ωt generated at time t and the existing pairwise constraints Ωt_ generated before time t. Accordingly the partition from the simplex γt-1, which was generated from data points X and the pairwise constraints Ωt_ to γt using the new pairwise constraints Ωt must be efficiently updated. This leads to the following optimization problem:




  
    
      
        
          
            
              min
              
                
                  γ
                  t
                
                ∈
                
                  R
                  m
                
              
            
            ⁢
            
              
                1
                
                  
                  Ω
                  
                
              
              ⁢
              
                
                  ∑
                  
                    s
                    ∈
                    
                      Ω
                      t
                    
                  
                
                ⁢
                
                  L
                  ⁡
                  
                    (
                    
                      s
                      ,
                      F
                    
                    )
                  
                
              
            
          
          +
          
            C
            ⁢
            
              
                
                
                  
                    γ
                    t
                  
                  -
                  
                    γ
                    
                      t
                      -
                      1
                    
                  
                
                
              
              2
              2
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              s
              .
              t
              .
              
                
              
              ⁢
              F
            
            =
            
              
                ∑
                
                  i
                  =
                  1
                
                m
              
              ⁢
              
                
                  γ
                  i
                  t
                
                ⁢
                
                  P
                  i
                
              
            
          
          ,
          
            

          
          ⁢
          
            
              γ
              t
            
            ≥
            0
          
          ,
          
            

          
          ⁢
          
            
              
                1
                T
              
              ⁢
              
                γ
                t
              
            
            =
            1.
          
        
      
    
    
      
        (
        
          EQ
          ⁢
          
            
          
          ⁢
          5
        
        )
      
    
  




The first term of objective function (EQ 5) searches for a new partition γt which is most consistent with the new set of pairwise constraints Ω while the second term ensures that the new partition γt is not far away from the previous partition γt-1 because a small number of pairwise constraints usually cannot significantly change the clustering structure of a large data set.
By applying the loss function L as the hinge loss, the optimization problem can be rewritten according to (EQ 6) as follows:




  
    
      
        
          
            
              min
              
                
                  γ
                  t
                
                ∈
                
                  R
                  m
                
              
            
            ⁢
            
              
                ∑
                
                  
                    s
                    ij
                  
                  ∈
                  M
                
              
              ⁢
              
                max
                ⁡
                
                  (
                  
                    0
                    ,
                    
                      
                        
                          
                          
                            
                              F
                              
                                i
                                ⁢
                                
                                  ,
                                  *
                                
                              
                            
                            -
                            
                              F
                              
                                j
                                ⁢
                                
                                  ,
                                  *
                                
                              
                            
                          
                          
                        
                        2
                        2
                      
                      -
                      μ
                    
                  
                  )
                
              
            
          
          +
          
            
              ∑
              
                
                  s
                  ij
                
                ∈
                C
              
            
            ⁢
            
              max
              ⁡
              
                (
                
                  0
                  ,
                  
                    δ
                    -
                    
                      
                        
                        
                          
                            F
                            
                              i
                              ⁢
                              
                                ,
                                *
                              
                            
                          
                          -
                          
                            F
                            
                              j
                              ⁢
                              
                                ,
                                *
                              
                            
                          
                        
                        
                      
                      2
                      2
                    
                  
                
                )
              
            
          
          +
          
            λ
            ⁢
            
              
                
                
                  
                    γ
                    t
                  
                  -
                  
                    γ
                    
                      t
                      -
                      1
                    
                  
                
                
              
              2
              2
            
          
        
        ⁢
        
          

        
        ⁢
        
          
        
        ⁢
        
          
            
              s
              .
              t
              .
              
                
              
              ⁢
              F
            
            =
            
              
                ∑
                
                  k
                  =
                  1
                
                m
              
              ⁢
              
                
                  γ
                  k
                  t
                
                ⁢
                
                  P
                  k
                
              
            
          
          ,
          
            

          
          ⁢
          
            
          
          ⁢
          
            
              γ
              t
            
            ≥
            0
          
          ,
          
            

          
          ⁢
          
            
          
          ⁢
          
            
              
                1
                T
              
              ⁢
              
                γ
                t
              
            
            =
            1
          
          ,
        
      
    
    
      
        (
        
          EQ
          ⁢
          
            
          
          ⁢
          6
        
        )
      
    
  




where μ and δ are two small non-negative parameters. Since max (0, δδ|Fi,*−Fj,*|2) is a non-convex function with respect to F, the domain of F1, . . . , Fmε{0,1}nxr can be changed to F′1, . . . , F′mε{−1,1}nxr. Then the similarity between data point i and data point j can be encoded as |Fi,*+Fj,*|22. This term is zero if ∀k, Fi,k and Fj,k have the same absolute value but opposite signs, thus encouraging different labels. For simplicity, μ and δ can be set to 0, so that the above optimization becomes:




  
    
      
        
          
            
              min
              
                
                  γ
                  t
                
                ∈
                
                  R
                  m
                
              
            
            ⁢
            
              
                ∑
                
                  
                    s
                    ij
                  
                  ∈
                  M
                
              
              ⁢
              
                
                  
                  
                    
                      F
                      
                        i
                        ⁢
                        
                          ,
                          *
                        
                      
                    
                    -
                    
                      F
                      
                        j
                        ⁢
                        
                          ,
                          *
                        
                      
                    
                  
                  
                
                2
                2
              
            
          
          +
          
            
              ∑
              
                
                  s
                  ij
                
                ∈
                C
              
            
            ⁢
            
              
                
                
                  
                    F
                    
                      i
                      ⁢
                      
                        ,
                        *
                      
                    
                  
                  +
                  
                    F
                    
                      j
                      ⁢
                      
                        ,
                        *
                      
                    
                  
                
                
              
              2
              2
            
          
          +
          
            λ
            ⁢
            
              
                
                
                  
                    γ
                    t
                  
                  -
                  
                    γ
                    
                      t
                      -
                      1
                    
                  
                
                
              
              2
              2
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              s
              .
              t
              .
              
                
              
              ⁢
              F
            
            =
            
              
                ∑
                
                  k
                  =
                  1
                
                m
              
              ⁢
              
                
                  γ
                  k
                  t
                
                ⁢
                
                  P
                  k
                
              
            
          
          ,
          
            

          
          ⁢
          
            
              γ
              t
            
            ≥
            0
          
          ,
          
            

          
          ⁢
          
            
              
                1
                T
              
              ⁢
              
                γ
                t
              
            
            =
            1.
          
        
      
    
    
      
        (
        
          EQ
          ⁢
          
            
          
          ⁢
          7
        
        )
      
    
  




Encoding F by γ creates




  
    
      
        
          
            min
            
              
                γ
                t
              
              ∈
              
                R
                m
              
            
          
          ⁢
          
            f
            ⁡
            
              (
              
                γ
                t
              
              )
            
          
        
        =
        
          
            
              ∑
              
                
                  s
                  ij
                
                ∈
                M
              
            
            ⁢
            
              
                
                
                  
                    ∑
                    
                      k
                      =
                      1
                    
                    m
                  
                  ⁢
                  
                    
                      γ
                      k
                      t
                    
                    ⁡
                    
                      (
                      
                        
                          
                            P
                            
                              k
                              ′
                            
                          
                          ⁡
                          
                            (
                            
                              i
                              ,
                              
                                :
                              
                            
                            )
                          
                        
                        -
                        
                          
                            P
                            
                              k
                              ′
                            
                          
                          ⁡
                          
                            (
                            
                              j
                              ,
                              
                                :
                              
                            
                            )
                          
                        
                      
                      )
                    
                  
                
                
              
              2
              2
            
          
          +
          
            
              ∑
              
                
                  s
                  ij
                
                ∈
                C
              
            
            ⁢
            
              
                
                
                  
                    ∑
                    
                      k
                      =
                      1
                    
                    m
                  
                  ⁢
                  
                    
                      γ
                      k
                      t
                    
                    ⁡
                    
                      (
                      
                        
                          
                            P
                            k
                            ′
                          
                          ⁡
                          
                            (
                            
                              i
                              ,
                              
                                :
                              
                            
                            )
                          
                        
                        +
                        
                          
                            P
                            k
                            ′
                          
                          ⁡
                          
                            (
                            
                              j
                              ,
                              
                                :
                              
                            
                            )
                          
                        
                      
                      )
                    
                  
                
                
              
              2
              2
            
          
          +
          
            λ
            ⁢
            
              
                
                
                  
                    γ
                    t
                  
                  -
                  
                    γ
                    
                      t
                      -
                      1
                    
                  
                
                
              
              2
              2
            
          
        
      
    
    
      
        (
        
          EQ
          ⁢
          
            
          
          ⁢
          8
        
        )
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            
              s
              .
              t
              .
              
                
              
              ⁢
              
                γ
                t
              
            
            ≥
            0
          
          ,
        
      
    
    
      
        
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            
              
                1
                T
              
              ⁢
              
                γ
                t
              
            
            =
            1
          
          ,
        
      
    
    
      
        
      
    
  




where the notation P′k(i,:) represents the i-th row of the matrix P′k. The optimization problem (EQ 8) can be efficiently solved by gradient descend method. Specifically, the γt is updated by

γt=PΔ(γt-1−η∇f(γt-1)),

where η is a step size and PΔ: Rm→Rm is a projection operator defined as




  
    
      [
      
        
          P
          Δ
        
        ⁡
        
          (
          γ
          )
        
      
      ]
    
    i
  
  =
  
    
      max
      ⁡
      
        (
        
          0
          ,
          
            γ
            i
          
        
        )
      
    
    /
    
      
        ∑
        
          i
          =
          1
        
        m
      
      ⁢
      
        max
        ⁡
        
          (
          
            0
            ,
            
              γ
              i
            
          
          )
        
      
    
  




Let U(ij) be an m x r matrix, where the k-th row of U(ij) is P′k(i,:)−P′k(j,:). Likewise, let V(ij) be an m x r matrix, where the k-th row of V(ij) is equal to P′k(i,:)+P′k(j,:). Then, ∇f(γ) can easily be computed as




  
    ∇
    
      f
      ⁡
      
        (
        
          γ
          
            t
            -
            1
          
        
        )
      
    
  
  =
  
    2
    ⁢
    
      (
      
        
          
            ∑
            
              
                s
                ij
              
              ∈
              M
            
          
          ⁢
          
            
              γ
              
                t
                -
                1
              
            
            ⁢
            
              U
              
                (
                ij
                )
              
            
            ⁢
            
              U
              
                
                  (
                  ij
                  )
                
                ⁢
                T
              
            
          
        
        +
        
          
            ∑
            
              
                s
                ij
              
              ∈
              C
            
          
          ⁢
          
            
              γ
              
                t
                -
                1
              
            
            ⁢
            
              V
              
                (
                ij
                )
              
            
            ⁢
            
              V
              
                
                  (
                  ij
                  )
                
                ⁢
                T
              
            
          
        
        +
        
          γ
          
            t
            -
            1
          
        
        -
        
          γ
          
            t
            -
            2
          
        
      
      )
    
  




Then γt is given by




  
    
      
        
          
            γ
            t
          
          =
          
            
              P
              
                Δ
                ⁢
                
                  
                
              
            
            ⁢
            
              {
              
                
                  
                    γ
                    
                      t
                      -
                      1
                    
                  
                  [
                  
                    
                      I
                      m
                    
                    -
                    
                      2
                      ⁢
                      
                        
                      
                      ⁢
                      
                        η
                        (
                        
                          
                            
                              ∑
                              
                                
                                  s
                                  ij
                                
                                ∈
                                M
                              
                            
                            ⁢
                            
                              
                                U
                                
                                  (
                                  ij
                                  )
                                
                              
                              ⁢
                              
                                U
                                
                                  
                                    (
                                    ij
                                    )
                                  
                                  ⁢
                                  T
                                
                              
                            
                          
                          +
                          
                            
                              ∑
                              
                                
                                  s
                                  ij
                                
                                ∈
                                C
                              
                            
                            ⁢
                            
                              
                                V
                                
                                  (
                                  ij
                                  )
                                
                              
                              ⁢
                              
                                V
                                
                                  
                                    (
                                    ij
                                    )
                                  
                                  ⁢
                                  T
                                
                              
                            
                          
                        
                        )
                      
                    
                  
                  ]
                
                -
                
                  2
                  ⁢
                  
                    η
                    ⁡
                    
                      (
                      
                        
                          γ
                          
                            t
                            -
                            1
                          
                        
                        -
                        
                          γ
                          
                            t
                            -
                            2
                          
                        
                      
                      )
                    
                  
                
              
              }
            
          
        
        ,
      
    
    
      
        (
        
          EQ
          ⁢
          
            
          
          ⁢
          9
        
        )
      
    
  




where Im is the m x m identity matrix. Note that U(ij)U(ij)T and V(ij)V(ij)T can be computed for each pair (i,j) stored in a server. Accordingly, using EQ 9, γt can be efficiently updated based on γt-1 and new pairwise constraints Ωt.
Despite the efficiency of updating γ, the space complexity of storing all the matrices U(ij)U(ij)T and V(ij)V(ij)T is O(n2m2) which is expensive when the number of objects n is large.
Note that the k-th row of the matrix U(ij) either contains all 0 entries, indicating that the extreme point partition P′k put object i and object j in the same cluster, or contains one 2, one −1, and 0 for all the remaining entries, indicating that the extreme point partition P′k put object i and object j in different clusters. Thus the diagonal elements of the matrix U(ij)U(ij)T are either 0 or a positive value (for example, the diagonal equals a positive value of 8). Thus,




  
    I
    m
  
  -
  
    2
    ⁢
    
      
    
    ⁢
    η
    ⁢
    
      
        ∑
        
          
            s
            ij
          
          ∈
          M
        
      
      ⁢
      
        
          U
          
            (
            ij
            )
          
        
        ⁢
        
          U
          
            
              (
              ij
              )
            
            ⁢
            T
          
        
      
    
  




basically means that less weights should be assigned to the extreme point partitions which mistakenly assign the object i and the object j in different clusters while they have a must-link connection. Likewise,




  
    I
    m
  
  -
  
    2
    ⁢
    
      
    
    ⁢
    η
    ⁢
    
      
        ∑
        
          
            s
            ij
          
          ∈
          M
        
      
      ⁢
      
        
          U
          
            (
            ij
            )
          
        
        ⁢
        
          U
          
            
              (
              ij
              )
            
            ⁢
            T
          
        
      
    
  




essentially means that less weights should be assigned to the extreme point partitions which mistakenly assign the object i and object j in the same cluster while they have a cannot-link constraint. After applying projection step PΔ the extreme point partitions which are consistent with the new pairwise constraints are assigned with larger weights, while the extreme point partitions which are not consistent with the new pairwise constraints are assigned with smaller weights. This leads to a relaxed updating procedure




  
    
      
        
          γ
          t
        
        =
        
          
            P
            Δ
          
          ⁢
          
            {
            
              
                
                  (
                  
                    1
                    -
                    
                      2
                      ⁢
                      
                        
                      
                      ⁢
                      η
                    
                  
                  )
                
                ⁢
                
                  γ
                  
                    t
                    -
                    1
                  
                
              
              +
              
                2
                ⁢
                
                  
                
                ⁢
                η
                ⁢
                
                  
                
                ⁢
                
                  γ
                  
                    t
                    -
                    2
                  
                
              
              -
              
                η
                ⁢
                
                  
                
                ⁢
                
                  γ
                  
                    t
                    -
                    1
                  
                
                ⁢
                
                  
                    ∑
                    
                      
                        s
                        ij
                      
                      ∈
                      Ω
                    
                  
                  ⁢
                  
                    A
                    
                      (
                      
                        i
                        ,
                        j
                      
                      )
                    
                  
                
              
            
            }
          
        
      
    
    
      
        (
        
          EQ
          ⁢
          
            
          
          ⁢
          10
        
        )
      
    
  




where A(ij) is a m×m diagonal matrix defined as





  
    
      
        
          A
          
            (
            ij
            )
          
        
        =
        
          [
          
            
              
                
                  g
                  ⁡
                  
                    (
                    
                      
                        
                          P
                          1
                          ′
                        
                        ⁡
                        
                          (
                          
                            i
                            ,
                            
                              :
                            
                          
                          )
                        
                      
                      ,
                      
                        
                          P
                          1
                          ′
                        
                        ⁡
                        
                          (
                          
                            j
                            ,
                            
                              :
                            
                          
                          )
                        
                      
                      ,
                      
                        s
                        ij
                      
                    
                    )
                  
                
              
              
                ...
              
              
                0
              
            
            
              
                ⋮
              
              
                ⋱
              
              
                ⋮
              
            
            
              
                0
              
              
                ...
              
              
                
                  g
                  ⁡
                  
                    (
                    
                      
                        
                          P
                          m
                          ′
                        
                        ⁡
                        
                          (
                          
                            i
                            ,
                            
                              :
                            
                          
                          )
                        
                      
                      ,
                      
                        
                          P
                          m
                          ′
                        
                        ⁡
                        
                          (
                          
                            j
                            ,
                            
                              :
                            
                          
                          )
                        
                      
                      ,
                      
                        s
                        ij
                      
                    
                    )
                  
                
              
            
          
          ]
        
      
    
    
      
        (
        
          EQ
          ⁢
          
            
          
          ⁢
          11
        
        )
      
    
  




Here g(a, b, s) is an indicator function whose inputs are two vectors a and b as well as a pairwise constraint s. It is defined as follows:

g(a,b,s)={0 if a=B when sεM, or if a≠b when sεC, 1 otherwise}

The updating procedure (EQ 10) is a relaxation of the procedure (EQ 9) and, in one embodiment, applies a greedy search method. It can be shown that the value of objective function (EQ 8) decreases using the updating procedure (EQ 10). Since the objective function (EQ 8) is lower bounded by 0, it is directly followed by the convergence of the proposed optimization problem.
After obtaining the updated simplex γt, a labeling matrix P can be computed by convex combination of the extreme points with weights γt 

P=γ1tP1+γ2tP2+ . . . +γmtPm 

Then the final partition can be obtained by running fast k-means algorithm over P. The time complexity to update the simplex vector γt from γt-1 is only O (m2), which is a constant time irrelevant to the data size. By running k-means on an n x r matrix P, the time complexity is O(mr). Since both m and r are much smaller than n, the total time complexity is O (n), which cannot be further improved since all the n data points need to be assigned to one cluster. FIG. 2 shows an exemplary algorithm.
As shown in FIG. 2, in one embodiment, the input can be feature representations, new pairwise constraints received at time t, old pairwise constraints received before time t, number of clusters and set size. Initially, in line 2, offline computation is performed in which the convex hull is computed. Next, in line 3, m ensemble partitions are generated by applying fast spectral clustering with subspace sampling and/or Hungarian algorithm. In line 4, a simplex vector γ0 is computed by ensemble clustering on the ensemble partitions. In line 5, a simplex vector γt-1 is computed based on the feature representations and pairwise constraints. In line 6, online updating of simplex vector γt from simplex vector γt-1 and the new pairwise constraints commences. This updating, as shown in lines 7-10, is performed while some pairwise constraints remain unread, and the update comprises, at line 8, reading the next pairwise constraint and, at line 9, computing a diagonal matrix based on a predetermined equation, such as (EQ 11) described herein. When no more pairwise constraints remain unread, in line 11, simplex vector γt is updated based on another predetermined equation, such as (EQ 10) described herein. In line 12, a new partition P is computed from the input feature representations and the computed simplex vectors. In line 13, the updated partition is output by applying fast k-means on the partition.
Extensive empirical evaluations of the inventive dynamic semi-supervised clustering algorithm, Constrained Clustering by Convex Searching (“CCCS”), are presented.
The following six public benchmark databases are used in the exemplary empirical evaluations.
USPS is a widely used handwritten digit database from J. J. Hull, “A database for handwritten text recognition research”, containing 9,298 handwritten images. Each image is a 256 dimensional vector that belongs to one of ten classes.
RCV1 is a subset of text documents from the RCV1 corpus, created by David D. Lewis, et al., “A new benchmark collection for text categorization research”. It contains 193,844 documents that belongs to one of 103 classes.
20 Newsgroups database contains 18,774 documents that belong to twenty (20) news categories.
BlogCatalog is a social network dataset that was crawled on an internet website known as BlogCatalog created by the inventors. When removing the users in multiple groups, 19,664 users who belong to one of 60 different groups remain.
TDT2 dataset contains 9,394 documents belonging to one of 30 classes.
MNIST is also a well-known handwritten digits database. It contains a total of 70,000 handwritten digits.
The statistics of these datasets are summarized in Table I.










TABLE I





Name
# Instances
# Features
# Clusters


















USPS
9,298
256
10


RCV1
193,844
47,236
103


20 Newsgroups
18,774
61,188
20


TDT2
9,394
36,771
30


BlogCatalog
19,664
5,413
60


MNIST
70,000
784
10









Evaluation and parameter settings for these experiments can be as follows. Normalized mutual information (“NMI”) is used to measure the coherence between the inferred data partitions and the ground truth categorization. Given the ground truth partition D={D1, D2, . . . , Dr} and the partition D′={D′1, D′2, . . . , D′r} generated by clustering algorithm, the normalized mutual information is computed as




  
    
      N
      ⁢
      
        
      
      ⁢
      M
      ⁢
      
        
      
      ⁢
      
        I
        ⁡
        
          (
          
            D
            ,
            
              D
              ′
            
          
          )
        
      
    
    =
    
      
        2
        ⁢
        
          
        
        ⁢
        M
        ⁢
        
          
        
        ⁢
        
          I
          ⁡
          
            (
            
              D
              ,
              
                D
                ′
              
            
            )
          
        
      
      
        
          H
          ⁡
          
            (
            D
            )
          
        
        +
        
          H
          ⁡
          
            (
            
              D
              ′
            
            )
          
        
      
    
  
  ,




where M I (X, Y) represents the mutual information between the random variables X and Y, and H(X) represents the Shannon entropy of random variable X. The higher the NMI value (0≦NMI≦1), the better the clustering performance.
To generate ensemble partitions P1, P2, . . . , Pm, initially, d′ out of d features are randomly sampled to compute m different similarity matrices. Two criteria are used in determining the values for d′. First, d′ should be small enough to make the ensemble partitions diverse. Second, d′ should be reasonably large to get good enough ensemble partitions since the quality of the starting point γ0 is highly depend on the quality of the ensemble partitions. In one embodiment, d′ may be set as d′=d/10. Further, in one embodiment, the step size η in (EQ 10) may be set to 0.02.
Next, how the number of ensemble partitions m influences the clustering performance is analyzed. Initially, two benchmark datasets, USPS and RCV1, are used to analyze how the performance is influenced by different number of ensemble partitions m. These two datasets are chosen since they are the smallest and the largest datasets, e.g., testbeds, in the experiment. Also, this allows an analysis of whether the selection of m is influenced by the data size n. To this end, for both of the two datasets, begin with the unsupervised data partition γ0 generated from m={10, 20, 30, 40, 50} different ensemble partitions. Then add 100 randomly sampled pairwise constraints in each tier or iteration, e.g., one round of computation, and execute the proposed semi-supervised clustering algorithm to update the partition. This step is repeated ten (10) times, until the total number of pairwise constraints achieves 1,000. FIGS. 3A and 3B provide two examples of how the performance of the proposed dynamic semi-supervised clustering algorithm is changed with different m and different number of pairwise constraints. FIG. 3A shows pairwise constraints using the USPS data set and FIG. 3B shows pairwise constraints using the RCV1 data set.
Initially, observe that the clustering performance keeps increasing as more and more pairwise constraints have been provided. Moreover, the clustering performance was improved when m increases. The performance gain may be due to the fact that a larger m indicates a larger searching space and also a larger overlap between the convex hull Δ′ and the convex constraint set Δ in accordance with (EQ 3). Also, a large number of ensemble partitions usually provide more diverse clustering results, leading to a better opportunity to find some data partitions that are consistent with most of the pairwise constraints. Furthermore, the performance of the proposed semi-supervised clustering algorithm gradually stabilizes as m increases to 50. This is also consistent with the initial assumption, since when the number of ensemble partitions are already large enough, adding more partitions cannot provide more information since it is most likely that the new partitions are almost the same as some existing partitions. This provides guidance to appropriately choose m: on one hand, m should be reasonably large to provide a diverse and large enough convex searching space Δ′, while on the other hand, m should be relatively small to reduce the computational cost to update the partitions. In one experimental embodiment, m=50.
Comparison with other baseline algorithms can be performed to examine the effectiveness and efficiency of the inventive semi-supervised clustering algorithm. In one aspect, the inventive CCCS can be compared to the following seven state-of-the-art algorithms for semi-supervised clustering, including three constrained clustering algorithms and four distance metric learning algorithms. The three constrained clustering algorithms are (a) MPCK-means, the metric pairwise constrained k-means algorithm, (b) CCSKL, constrained clustering by spectral kernel learning, and (c) PMMC, pairwise constrained maximum margin clustering. The four state-of-the-art distance metric learning algorithms are (d) RCA, the relevant component analysis, (e) DCA, the discriminative component analysis, (f) LMNN, the large margin nearest neighbor classifier, and (g) ITML, the information theoretic metric learning algorithm. The code for the baseline algorithms was provided by their respective authors. For a fair comparison, all the parameters used in the baseline algorithms were their suggested values (if applicable).
In one set of experiments, start with 100 randomly generated pairwise constraints, denoted as tier t1. Then in each tier, another set of 100 randomly sampled pairwise constraints are generated and all the semi-supervised clustering algorithms are called to update the data partition given the newly generated pairwise constraints. Specifically, the baseline semi-supervised clustering algorithms are re-executed by combining the new pairwise constraints with the old ones. These steps are repeated from tier t1 to tier t10, leading to a total of 1,000 randomly sampled pairwise constraints. In one aspect, all the experiments are performed on a PC with Intel Xeon 2:40 GHz processor and 64:0 GB of main memory. Each experiment is repeated five times, and the clustering performance averaged over the five trials is shown in FIGS. 4A-4F.
First observe that, compared to all the baseline algorithms, the inventive dynamic semi-supervised clustering algorithm CCCS yields the best performance for most of the datasets (USPS, RCV1, 20 Newsgroups, BlogCatalog and MNIST). Especially when given a small number of the pairwise constraints, CCCS outperforms the compared methods with significant performance gain. This is because by generating a convex hull from a set of ensemble partitions, the possible searching space is dramatically reduced so that all of the inner points in that convex hull can correspond to reasonably good data partitions. Also, by computing the starting point γ0 based on the idea of ensemble clustering, it is not surprising that γ0 should already be close to the optimal solution. Thus a simple locally-focused search is good enough to recover the optimal partition.
In addition to superior performance, the inventive CCCS algorithm is also extremely efficient, requiring much less running time compared to all the baseline algorithms. FIG. 5 is a table that summarizes the average running time to update the partitions of the CCCS algorithm as well as all the baseline algorithms in each tier, reporting the running time of the three largest datasets, i.e., MNIST, 20 Newsgroups, and RCV1. The results in the table in FIG. 5 show that the CCCS algorithm updates the partition in a time that is significantly less than all the baseline algorithms. Specifically, the results show that even for a dataset with about 200,000 data points, it takes less than 30 seconds for CCCS to update the partitioning.
FIG. 6 illustrates an exemplary hardware configuration of a computing or mobile device computing system infrastructure 600 in which the present methods can be executed, in one embodiment. In one aspect, computing system 600 is programmed to run one or more applications, and is programmed to perform the method processing steps of FIG. 1. The hardware configuration preferably has at least one processor or central processing unit (CPU) 611. The CPUs 611 are interconnected via a system bus 612 to a random access memory (RAM) 614, read-only memory (ROM) 616, input/output (I/O) adapter 618 (for connecting peripheral devices such as disk units 621 and tape drives 640 to the bus 612), user interface adapter 622 (for connecting a keyboard 624, mouse 626, speaker 628, disk drive device 632, and/or other user interface device to the bus 612), a communication adapter 634 for connecting the system 600 to a data processing network, the Internet, an Intranet, a local area network (LAN), etc., and a display adapter 636 for connecting the bus 612 to a display device 638 and/or printer 639 (e.g., a digital printer of the like).
The present invention may be a system, a method, and/or a computer program product. The computer program product may include a computer readable storage medium (or media) having computer readable program instructions thereon for causing a processor to carry out aspects of the present invention.
The computer readable storage medium can be a tangible device that can retain and store instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of the computer readable storage medium includes the following: 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), a static random access memory (SRAM), a portable compact disc read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanically encoded device such as punch-cards or raised structures in a groove having instructions recorded thereon, and any suitable combination of the foregoing. A computer readable storage medium, as used herein, is not to be construed as being transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission media (e.g., light pulses passing through a fiber-optic cable), or electrical signals transmitted through a wire
Computer readable program instructions described herein can be downloaded to respective computing/processing devices from a computer readable storage medium or to an external computer or external storage device via a network, for example, the Internet, a local area network, a wide area network and/or a wireless network. The network may comprise copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers and/or edge servers. A network adapter card or network interface in each computing/processing device receives computer readable program instructions from the network and forwards the computer readable program instructions for storage in a computer readable storage medium within the respective computing/processing device.
Computer readable program instructions for carrying out operations of the present invention may be assembler instructions, instruction-set-architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, firmware instructions, state-setting data, or either source code or object code written in any combination of one or more programming languages, including an object oriented programming language such as Smalltalk, C++ or the like, and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The computer readable program instructions may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user'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'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). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGA), or programmable logic arrays (PLA) may execute the computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry, in order to perform aspects of the present invention.
Aspects of the present invention are described herein 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 readable program instructions.
These computer readable 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 execute 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 readable program instructions may also be stored in a computer readable storage medium that can direct a computer, a programmable data processing apparatus, and/or other devices to function in a particular manner, such that the computer readable storage medium having instructions stored therein comprises an article of manufacture including instructions which implement aspects of the function/act specified in the flowchart and/or block diagram block or blocks.
The computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus or other device to produce a computer implemented process, such that the instructions which execute on the computer, other programmable apparatus, or other device implement 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 instructions, which comprises one or more executable instructions for implementing the specified logical function(s). 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 executed substantially concurrently, or the blocks may sometimes be executed 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 carry out combinations of special purpose hardware and computer instructions.
While the invention has been particularly shown and described with respect to illustrative and preformed embodiments thereof, it will be understood by those skilled in the art that the foregoing and other changes in form and details may be made therein without departing from the spirit and scope of the invention which should be limited only by the scope of the appended claims.

## Claims

1. A computer-implemented method for dynamic, semi-supervised clustering, comprising:
receiving data attributes;
generating a set of ensemble partitions using the data attributes;
forming a convex hull using the set of ensemble partitions;
generating a simplex vector by performing ensemble clustering on the convex hull, the simplex vector being a vector whose elements are non-negative and the summation of all of the elements equals one;
receiving one or more pairwise constraints;
deriving an optimal simplex vector using the simplex vector and the one or more pairwise constraints;
computing a current optimal clustering result using the optimal simplex vector; and
outputting the current optimal clustering result,
wherein a hardware processor device is configured to perform said attribute receiving, generating partitions, forming the convex hull, generating the simplex vector, dynamic link receiving, deriving, computing and outputting.

2. The method according to claim 1, further comprising repeating said receiving links, deriving an optimal simplex vector, and computing a current best clustering result when additional one or more pairwise constraints are received.

3. The method according to claim 1, wherein the attributes are received from one of: handwritten images as vectors, and a profile obtained from a social networking platform.

4. The method according to claim 1, wherein the ensemble partitions are generated using a fast spectral clustering with subspace sampling.

5. The method according to claim 1, wherein the ensemble partitions are further refined using the fast spectral clustering with a Hungarian algorithm.

6. The method according to claim 1, wherein the one or more pairwise constraints comprise one or more must-link links and one or more cannot-link links.

7. A system for dynamic, semi-supervised clustering, comprising:
a memory device;
a display device; and
a hardware processor coupled to the memory device, the processor configured to:
receive data attributes;
generate a set of ensemble partitions using the data attributes;
form a convex hull using the set of ensemble partitions;
generate a simplex vector by performing ensemble clustering on the convex hull, the simplex vector being a vector whose elements are non-negative and the summation of all of the elements equals one;
receive one or more pairwise constraints;
derive an optimal simplex vector using the simplex vector and the one or more pairwise constraints;
compute a current optimal clustering result using the optimal simplex vector; and
output the current optimal clustering result to the display device.

8. The system according to claim 7, further comprising repeating receiving links, deriving an optimal simplex vector, and computing a current best clustering result when additional one or more pairwise constraints are received.

9. The system according to claim 7, wherein the attributes are received from one of: handwritten images as vectors, and a profile obtained from a social networking platform.

10. The system according to claim 7, wherein the ensemble partitions are generated using a fast spectral clustering with subspace sampling.

11. The system according to claim 10, wherein the ensemble partitions are further refined using the fast spectral clustering with a Hungarian algorithm.

12. The system according to claim 7, wherein the one or more pairwise constraints comprise one or more must-link links and one or more cannot-link links.

13. A computer program product for using a multiuser system, the computer program product comprising a non-transitory storage medium readable by a processing circuit and storing instructions run by the processing circuit for performing method steps for dynamic, semi-supervised clustering, comprises:
receiving data attributes;
generating a set of ensemble partitions using the data attributes;
forming a convex hull using the set of ensemble partitions;
generating a simplex vector by performing ensemble clustering on the convex hull, the simplex vector being a vector whose elements are non-negative and the summation of all of the elements equals one;
receiving one or more pairwise constraints;
deriving an optimal simplex vector using the simplex vector and the one or more pairwise constraints;
computing a current optimal clustering result using the optimal simplex vector; and
outputting the current optimal clustering result.

14. The computer program product according to claim 13, further comprising receiving links, deriving an optimal simplex vector, and computing a current best clustering result when additional one or more pairwise constraints are received.

15. The computer program product according to claim 13, wherein the attributes are received from one of: handwritten images as vectors, and a profile obtained from a social networking platform.

16. The computer program product according to claim 13, wherein the ensemble partitions are generated using a fast spectral clustering with subspace sampling.

17. The computer program product according to claim 16, wherein the ensemble partitions are further refined using the fast spectral clustering with a Hungarian algorithm.

18. The computer program product according to claim 13, wherein the one or more pairwise constraints comprise one or more must-link links and one or more cannot-link links.