Clustering(eps, device, max_len=1000, dist_type='cos')

Bases: object

General clustering framework with center alignment.

Parameters:
  • eps (float) –

    Convergence threshold.

  • device (device) –

    Device to use.

  • max_len (int, default: 1000 ) –

    Maximum batch length. Default: 1000.

  • dist_type (str, default: 'cos' ) –

    Distance metric type. Default: 'cos'.
align_centers()

Align current centers with initial centers.

Returns:
  • ndarray –

    Optimal alignment indices using linear assignment.
Notes

Solves the linear assignment problem to find optimal matching between current and initial centers.

assign_fake_labels(feats)

Assign samples to nearest cluster centers.

Parameters:
  • feats (Tensor) –

    Input features, shape (num_samples, feature_dim).
Returns:
  • tuple –

    Contains: - torch.Tensor: Distances to each center - torch.Tensor: Assigned cluster labels
Notes

Uses specified distance metric (cos/euc) for assignment.

clustering_stop(centers)

Check clustering convergence condition.

Parameters:
  • centers (Tensor or None) –

    Current cluster centers.
Notes

Convergence is determined by:

  1. If centers is None: continue clustering
  2. If mean distance between current and previous centers < eps: stop

Prints current distance for monitoring.

collect_samples(feat, label)

Store features and labels for clustering.

Parameters:
  • feat (Tensor) –

    Input features.

  • label (Tensor) –

    Ground truth labels.
Notes

Stores:

  • Ground truth labels
  • Features
  • Sample indices
feature_clustering(feat, label)

Perform iterative clustering until convergence.

Parameters:
  • feat (Tensor) –

    Input features.

  • label (Tensor) –

    Ground truth labels.
Notes

Process:

  1. Assign samples to nearest centers
  2. Update centers
  3. Check convergence
  4. Align with initial centers
set_init_centers(init_centers)

Initialize cluster centers.

Parameters:
  • init_centers (Tensor) –

    Initial cluster centers, shape (num_classes, feature_dim).
Notes

Stores both current and initial centers for tracking changes and later alignment.

DIST(dist_type)

Bases: object

Distance metric calculator for clustering.

Parameters:
  • dist_type (str) –

    Type of distance metric ('cos' or 'euc').
cos(pointA, pointB, cross)

Compute cosine distance.

Parameters:
  • pointA (Tensor) –

    First set of points.

  • pointB (Tensor) –

    Second set of points.

  • cross (bool) –

    If True, compute cross-distances.
Returns:
  • Tensor –

    Cosine distance(s): 0.5 * (1 - cos(θ)).
euc(pointA, pointB, cross)

Compute Euclidean distance.

Parameters:
  • pointA (Tensor) –

    First set of points.

  • pointB (Tensor) –

    Second set of points.

  • cross (bool) –

    If True, compute cross-distances.
Returns:
  • Tensor –

    Euclidean distance(s).
get_dist(pointA, pointB, cross=False)

Calculate distance between points.

Parameters:
  • pointA (Tensor) –

    First set of points.

  • pointB (Tensor) –

    Second set of points.

  • cross (bool, default: False ) –

    If True, compute cross-distances between all pairs. Default: False.
Returns:
  • Tensor –

    Distance matrix or vector.
GMMClustering(num_class, device, dist_type='cos')

Bases: object

Gaussian Mixture Model clustering with center alignment.

Parameters:
  • num_class (int) –

    Number of clusters.

  • device (device) –

    Device to use.

  • dist_type (str, default: 'cos' ) –

    Distance metric type. Default: 'cos'.
align_centers(src_center, tgt_center)

Align target centers with source centers.

Parameters:
  • src_center (Tensor) –

    Source domain centers.

  • tgt_center (Tensor) –

    Target domain centers.
Returns:
  • ndarray –

    Optimal alignment indices.
forward(src_centers, emb_t, y_t, target_edge_index, target_edge_attr, smooth, smooth_r)

Perform GMM clustering and align with source centers.

Parameters:
  • src_centers (Tensor) –

    Source domain cluster centers.

  • emb_t (Tensor) –

    Target domain embeddings.

  • y_t (Tensor) –

    Target domain ground truth labels.

  • target_edge_index (Tensor) –

    Target domain edge indices.

  • target_edge_attr (Tensor) –

    Target domain edge attributes.

  • smooth (bool) –

    Whether to apply label smoothing.

  • smooth_r (float) –

    Smoothing ratio.
Returns:
  • dict –

    Clustering results including:

    • data: node indices
    • label: predicted labels
    • dist2center: probabilities
    • gt: ground truth labels
smooth(edge_index, v, smooth_r)

Apply label smoothing using graph structure.

Parameters:
  • edge_index (Tensor) –

    Edge indices.

  • v (Tensor) –

    Edge weights.

  • smooth_r (float) –

    Smoothing ratio.
Returns:
  • tuple –

    (smoothed_labels, smoothed_probabilities)
gcn_norm(edge_index, edge_weight=None, num_nodes=None, improved=False, add_self_loops=True, dtype=None)

Compute symmetric normalization for graph convolution.

Parameters:
  • edge_index (Union[Tensor, SparseTensor]) –

    Edge indices or sparse adjacency matrix.

  • edge_weight (Tensor, default: None ) –

    Edge weights. Default: None (all ones).

  • num_nodes (int, default: None ) –

    Number of nodes. Default: None (inferred).

  • improved (bool, default: False ) –

    If True, use A + 2I instead of A + I. Default: False.

  • add_self_loops (bool, default: True ) –

    Whether to add self-loops. Default: True.

  • dtype (dtype, default: None ) –

    Data type for edge weights. Default: None.
Returns:
  • Union[SparseTensor, Tuple[Tensor, Tensor]] –

    If input is SparseTensor: Normalized sparse adjacency matrix If input is edge_index: (normalized_edge_index, normalized_edge_weights)
Notes

Features:

  1. Handles both sparse and dense formats
  2. Adds self-loops with configurable weight
  3. Computes symmetric normalization
  4. Handles numerical stability
  5. Supports improved GCN variant

Implementation details:

  • Automatically adds self-loops if requested
  • Handles infinite values in degree normalization
  • Supports both SparseTensor and edge_index formats
  • Memory-efficient sparse operations
get_emb_centers(embeddings, label_array, n_label)

Calculate centroids of embeddings per label.

Parameters:
  • embeddings (Tensor) –

    Node embeddings.

  • label_array (Tensor) –

    Label assignments.

  • n_label (int) –

    Number of labels.
Returns:
  • Tensor –

    Centroid embeddings for each label.
onehot(label_matrix, num_classes)

Convert labels to one-hot encoding.

Parameters:
  • label_matrix (Tensor) –

    Label indices.

  • num_classes (int) –

    Number of classes.
Returns:
  • Tensor –

    One-hot encoded labels.