code: def kmeans_plusplus_torch(
      X: torch.Tensor,
      n_clusters: int,
      random_state: int,
      n_local_trials: int = 30,
      device: torch.device = torch.device("cpu"),
  ):
      """
      Choose initial centroids for initializing k-means algorithm. The performance of
      k-means algorithm can vary significantly by the initial centroids. To alleviate
      this problem, k-means++ algorithm chooses initial centroids based on the probability
      proportional to the distance from the formally chosen centroids. The centroids
      selected by k-means++ algorithm improve the chance of getting more accurate and
      stable clustering results. The overall implementation of k-means++ algorithm is
      inspired by the numpy based k-means++ implementation in:
          https://github.com/scikit-learn/scikit-learn
  
      Originally, the implementation of the k-means++ algorithm in scikit-learn is based
      on the following research article:
          Arthur, David, and Sergei Vassilvitskii. k-means++: The advantages of careful
          seeding. Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete
          algorithms, Society for Industrial and Applied Mathematics (2007)
  
      Args:
          X (Tensor):
              Matrix containing cosine similarity values among embedding vectors (N x N)
          n_clusters (int):
              Maximum number of speakers for estimating number of speakers.
              Shows stable performance under 20.
          random_state (int):
              Seed variable for setting up a random state.
          n_local_trials (int):
              Number of trials for creating initial values of the center points.
          device (torch.device)
              Torch device variable.
  
      Returns:
          centers (Tensor):
              The coordinates for center points that are used for initializing k-means algorithm.
          indices (Tensor):
              The indices of the best candidate center points.
      """
      torch.manual_seed(random_state)
      X = X.to(device)
      n_samples, n_features = X.shape
  
      centers = torch.zeros(n_clusters, n_features, dtype=X.dtype)
      center_id = torch.randint(0, n_samples, (1,)).long()
      indices = torch.full(
          [
              n_clusters,
          ],
          -1,
          dtype=torch.int,
      )
  
      centers[0] = X[center_id].squeeze(0)
      indices[0] = center_id.squeeze(0)
  
      centers = centers.to(device)
      closest_dist_diff = (
          centers[0, None].repeat(1, X.shape[0]).view(X.shape[0], -1)
          - X
      )
      closest_dist_sq = (
          closest_dist_diff.pow(2).sum(dim=1).unsqueeze(dim=0)
      )
      current_pot = closest_dist_sq.sum()
  
      for c in range(1, n_clusters):
          rand_vals = torch.rand(n_local_trials) * current_pot.item()
  
          if len(closest_dist_sq.shape) > 1:
              torch_cumsum = torch.cumsum(closest_dist_sq, dim=1)[0]
          else:
              torch_cumsum = torch.cumsum(closest_dist_sq, dim=0)
  
          candidate_ids = torch.searchsorted(
              torch_cumsum, rand_vals.to(device)
          )
  
          N_ci = candidate_ids.shape[0]
          distance_diff = X[candidate_ids].repeat(1, X.shape[0]).view(
              X.shape[0] * N_ci, -1
          ) - X.repeat(N_ci, 1)
          distance = distance_diff.pow(2).sum(dim=1).view(N_ci, -1)
          distance_to_candidates = torch.minimum(
              closest_dist_sq, distance
          )
          candidates_pot = distance_to_candidates.sum(dim=1)
  
          best_candidate = torch.argmin(candidates_pot)
          current_pot = candidates_pot[best_candidate]
          closest_dist_sq = distance_to_candidates[best_candidate]
          best_candidate = candidate_ids[best_candidate]
  
          centers[c] = X[best_candidate]
          indices[c] = best_candidate
      return centers, indices
  
imports: from typing import Dict, List, Tuple
  import torch
  from torch.linalg import eigh, eigvalsh
label_desc: Use image node_id 4 for calling a global function with example usage: kmeans_plusplus_torch(X, n_clusters, random_state, n_local_trials, device) and returns: centers,  indices