text: # Authors: Manoj Kumar <manojkumarsivaraj334@gmail.com>
  #          Alexandre Gramfort <alexandre.gramfort@telecom-paristech.fr>
  #          Joel Nothman <joel.nothman@gmail.com>
  # License: BSD 3 clause
  from __future__ import division
  
  import warnings
  import numpy as np
  from scipy import sparse
  from math import sqrt
  
  from ..metrics.pairwise import euclidean_distances
  from ..base import TransformerMixin, ClusterMixin, BaseEstimator
  from ..externals.six.moves import xrange
  from ..utils import check_array
  from ..utils.extmath import row_norms, safe_sparse_dot
  from ..utils.validation import check_is_fitted
  from ..exceptions import NotFittedError
  from .hierarchical import AgglomerativeClustering
  
  
  def _iterate_sparse_X(X):
      """This little hack returns a densified row when iterating over a sparse
      matrix, instead of constructing a sparse matrix for every row that is
      expensive.
      """
      n_samples = X.shape[0]
      X_indices = X.indices
      X_data = X.data
      X_indptr = X.indptr
  
      for i in xrange(n_samples):
          row = np.zeros(X.shape[1])
          startptr, endptr = X_indptr[i], X_indptr[i + 1]
          nonzero_indices = X_indices[startptr:endptr]
          row[nonzero_indices] = X_data[startptr:endptr]
          yield row
  
  
  def _split_node(node, threshold, branching_factor):
      """The node has to be split if there is no place for a new subcluster
      in the node.
      1. Two empty nodes and two empty subclusters are initialized.
      2. The pair of distant subclusters are found.
      3. The properties of the empty subclusters and nodes are updated
         according to the nearest distance between the subclusters to the
         pair of distant subclusters.
      4. The two nodes are set as children to the two subclusters.
      """
      new_subcluster1 = _CFSubcluster()
      new_subcluster2 = _CFSubcluster()
      new_node1 = _CFNode(
          threshold, branching_factor, is_leaf=node.is_leaf,
          n_features=node.n_features)
      new_node2 = _CFNode(
          threshold, branching_factor, is_leaf=node.is_leaf,
          n_features=node.n_features)
      new_subcluster1.child_ = new_node1
      new_subcluster2.child_ = new_node2
  
      if node.is_leaf:
          if node.prev_leaf_ is not None:
              node.prev_leaf_.next_leaf_ = new_node1
          new_node1.prev_leaf_ = node.prev_leaf_
          new_node1.next_leaf_ = new_node2
          new_node2.prev_leaf_ = new_node1
          new_node2.next_leaf_ = node.next_leaf_
          if node.next_leaf_ is not None:
              node.next_leaf_.prev_leaf_ = new_node2
  
      dist = euclidean_distances(
          node.centroids_, Y_norm_squared=node.squared_norm_, squared=True)
      n_clusters = dist.shape[0]
  
      farthest_idx = np.unravel_index(
          dist.argmax(), (n_clusters, n_clusters))
      node1_dist, node2_dist = dist[[farthest_idx]]
  
      node1_closer = node1_dist < node2_dist
      for idx, subcluster in enumerate(node.subclusters_):
          if node1_closer[idx]:
              new_node1.append_subcluster(subcluster)
              new_subcluster1.update(subcluster)
          else:
              new_node2.append_subcluster(subcluster)
              new_subcluster2.update(subcluster)
      return new_subcluster1, new_subcluster2
  
  
  class _CFNode(object):
      """Each node in a CFTree is called a CFNode.
  
      The CFNode can have a maximum of branching_factor
      number of CFSubclusters.
  
      Parameters
      ----------
      threshold : float
          Threshold needed for a new subcluster to enter a CFSubcluster.
  
      branching_factor : int
          Maximum number of CF subclusters in each node.
  
      is_leaf : bool
          We need to know if the CFNode is a leaf or not, in order to
          retrieve the final subclusters.
  
      n_features : int
          The number of features.
  
      Attributes
      ----------
      subclusters_ : array-like
          list of subclusters for a particular CFNode.
  
      prev_leaf_ : _CFNode
          prev_leaf. Useful only if is_leaf is True.
  
      next_leaf_ : _CFNode
          next_leaf. Useful only if is_leaf is True.
          the final subclusters.
  
      init_centroids_ : ndarray, shape (branching_factor + 1, n_features)
          manipulate ``init_centroids_`` throughout rather than centroids_ since
          the centroids are just a view of the ``init_centroids_`` .
  
      init_sq_norm_ : ndarray, shape (branching_factor + 1,)
          manipulate init_sq_norm_ throughout. similar to ``init_centroids_``.
  
      centroids_ : ndarray
          view of ``init_centroids_``.
  
      squared_norm_ : ndarray
          view of ``init_sq_norm_``.
  
      """
      def __init__(self, threshold, branching_factor, is_leaf, n_features):
          self.threshold = threshold
          self.branching_factor = branching_factor
          self.is_leaf = is_leaf
          self.n_features = n_features
  
          # The list of subclusters, centroids and squared norms
          # to manipulate throughout.
          self.subclusters_ = []
          self.init_centroids_ = np.zeros((branching_factor + 1, n_features))
          self.init_sq_norm_ = np.zeros((branching_factor + 1))
          self.squared_norm_ = []
          self.prev_leaf_ = None
          self.next_leaf_ = None
  
      def append_subcluster(self, subcluster):
          n_samples = len(self.subclusters_)
          self.subclusters_.append(subcluster)
          self.init_centroids_[n_samples] = subcluster.centroid_
          self.init_sq_norm_[n_samples] = subcluster.sq_norm_
  
          # Keep centroids and squared norm as views. In this way
          # if we change init_centroids and init_sq_norm_, it is
          # sufficient,
          self.centroids_ = self.init_centroids_[:n_samples + 1, :]
          self.squared_norm_ = self.init_sq_norm_[:n_samples + 1]
  
      def update_split_subclusters(self, subcluster,
                                   new_subcluster1, new_subcluster2):
          """Remove a subcluster from a node and update it with the
          split subclusters.
          """
          ind = self.subclusters_.index(subcluster)
          self.subclusters_[ind] = new_subcluster1
          self.init_centroids_[ind] = new_subcluster1.centroid_
          self.init_sq_norm_[ind] = new_subcluster1.sq_norm_
          self.append_subcluster(new_subcluster2)
  
      def insert_cf_subcluster(self, subcluster):
          """Insert a new subcluster into the node."""
          if not self.subclusters_:
              self.append_subcluster(subcluster)
              return False
  
          threshold = self.threshold
          branching_factor = self.branching_factor
          # We need to find the closest subcluster among all the
          # subclusters so that we can insert our new subcluster.
          dist_matrix = np.dot(self.centroids_, subcluster.centroid_)
          dist_matrix *= -2.
          dist_matrix += self.squared_norm_
          closest_index = np.argmin(dist_matrix)
          closest_subcluster = self.subclusters_[closest_index]
  
          # If the subcluster has a child, we need a recursive strategy.
          if closest_subcluster.child_ is not None:
              split_child = closest_subcluster.child_.insert_cf_subcluster(
                  subcluster)
  
              if not split_child:
                  # If it is determined that the child need not be split, we
                  # can just update the closest_subcluster
                  closest_subcluster.update(subcluster)
                  self.init_centroids_[closest_index] = \
                      self.subclusters_[closest_index].centroid_
                  self.init_sq_norm_[closest_index] = \
                      self.subclusters_[closest_index].sq_norm_
                  return False
  
              # things not too good. we need to redistribute the subclusters in
              # our child node, and add a new subcluster in the parent
              # subcluster to accommodate the new child.
              else:
                  new_subcluster1, new_subcluster2 = _split_node(
                      closest_subcluster.child_, threshold, branching_factor)
                  self.update_split_subclusters(
                      closest_subcluster, new_subcluster1, new_subcluster2)
  
                  if len(self.subclusters_) > self.branching_factor:
                      return True
                  return False
  
          # good to go!
          else:
              merged = closest_subcluster.merge_subcluster(
                  subcluster, self.threshold)
              if merged:
                  self.init_centroids_[closest_index] = \
                      closest_subcluster.centroid_
                  self.init_sq_norm_[closest_index] = \
                      closest_subcluster.sq_norm_
                  return False
  
              # not close to any other subclusters, and we still
              # have space, so add.
              elif len(self.subclusters_) < self.branching_factor:
                  self.append_subcluster(subcluster)
                  return False
  
              # We do not have enough space nor is it closer to an
              # other subcluster. We need to split.
              else:
                  self.append_subcluster(subcluster)
                  return True
  
  
  class _CFSubcluster(object):
      """Each subcluster in a CFNode is called a CFSubcluster.
  
      A CFSubcluster can have a CFNode has its child.
  
      Parameters
      ----------
      linear_sum : ndarray, shape (n_features,), optional
          Sample. This is kept optional to allow initialization of empty
          subclusters.
  
      Attributes
      ----------
      n_samples_ : int
          Number of samples that belong to each subcluster.
  
      linear_sum_ : ndarray
          Linear sum of all the samples in a subcluster. Prevents holding
          all sample data in memory.
  
      squared_sum_ : float
          Sum of the squared l2 norms of all samples belonging to a subcluster.
  
      centroid_ : ndarray
          Centroid of the subcluster. Prevent recomputing of centroids when
          ``CFNode.centroids_`` is called.
  
      child_ : _CFNode
          Child Node of the subcluster. Once a given _CFNode is set as the child
          of the _CFNode, it is set to ``self.child_``.
  
      sq_norm_ : ndarray
          Squared norm of the subcluster. Used to prevent recomputing when
          pairwise minimum distances are computed.
      """
      def __init__(self, linear_sum=None):
          if linear_sum is None:
              self.n_samples_ = 0
              self.squared_sum_ = 0.0
              self.linear_sum_ = 0
          else:
              self.n_samples_ = 1
              self.centroid_ = self.linear_sum_ = linear_sum
              self.squared_sum_ = self.sq_norm_ = np.dot(
                  self.linear_sum_, self.linear_sum_)
          self.child_ = None
  
      def update(self, subcluster):
          self.n_samples_ += subcluster.n_samples_
          self.linear_sum_ += subcluster.linear_sum_
          self.squared_sum_ += subcluster.squared_sum_
          self.centroid_ = self.linear_sum_ / self.n_samples_
          self.sq_norm_ = np.dot(self.centroid_, self.centroid_)
  
      def merge_subcluster(self, nominee_cluster, threshold):
          """Check if a cluster is worthy enough to be merged. If
          yes then merge.
          """
          new_ss = self.squared_sum_ + nominee_cluster.squared_sum_
          new_ls = self.linear_sum_ + nominee_cluster.linear_sum_
          new_n = self.n_samples_ + nominee_cluster.n_samples_
          new_centroid = (1 / new_n) * new_ls
          new_norm = np.dot(new_centroid, new_centroid)
          dot_product = (-2 * new_n) * new_norm
          sq_radius = (new_ss + dot_product) / new_n + new_norm
          if sq_radius <= threshold ** 2:
              (self.n_samples_, self.linear_sum_, self.squared_sum_,
               self.centroid_, self.sq_norm_) = \
                  new_n, new_ls, new_ss, new_centroid, new_norm
              return True
          return False
  
      @property
      def radius(self):
          """Return radius of the subcluster"""
          dot_product = -2 * np.dot(self.linear_sum_, self.centroid_)
          return sqrt(
              ((self.squared_sum_ + dot_product) / self.n_samples_) +
              self.sq_norm_)
  
  
  class Birch(BaseEstimator, TransformerMixin, ClusterMixin):
      """Implements the Birch clustering algorithm.
  
      It is a memory-efficient, online-learning algorithm provided as an
      alternative to :class:`MiniBatchKMeans`. It constructs a tree
      data structure with the cluster centroids being read off the leaf.
      These can be either the final cluster centroids or can be provided as input
      to another clustering algorithm such as :class:`AgglomerativeClustering`.
  
      Read more in the :ref:`User Guide <birch>`.
  
      Parameters
      ----------
      threshold : float, default 0.5
          The radius of the subcluster obtained by merging a new sample and the
          closest subcluster should be lesser than the threshold. Otherwise a new
          subcluster is started. Setting this value to be very low promotes
          splitting and vice-versa.
  
      branching_factor : int, default 50
          Maximum number of CF subclusters in each node. If a new samples enters
          such that the number of subclusters exceed the branching_factor then
          that node is split into two nodes with the subclusters redistributed
          in each. The parent subcluster of that node is removed and two new
          subclusters are added as parents of the 2 split nodes.
  
      n_clusters : int, instance of sklearn.cluster model, default 3
          Number of clusters after the final clustering step, which treats the
          subclusters from the leaves as new samples.
  
          - `None` : the final clustering step is not performed and the
            subclusters are returned as they are.
  
          - `sklearn.cluster` Estimator : If a model is provided, the model is
            fit treating the subclusters as new samples and the initial data is
            mapped to the label of the closest subcluster.
  
          - `int` : the model fit is :class:`AgglomerativeClustering` with
            `n_clusters` set to be equal to the int.
  
      compute_labels : bool, default True
          Whether or not to compute labels for each fit.
  
      copy : bool, default True
          Whether or not to make a copy of the given data. If set to False,
          the initial data will be overwritten.
  
      Attributes
      ----------
      root_ : _CFNode
          Root of the CFTree.
  
      dummy_leaf_ : _CFNode
          Start pointer to all the leaves.
  
      subcluster_centers_ : ndarray,
          Centroids of all subclusters read directly from the leaves.
  
      subcluster_labels_ : ndarray,
          Labels assigned to the centroids of the subclusters after
          they are clustered globally.
  
      labels_ : ndarray, shape (n_samples,)
          Array of labels assigned to the input data.
          if partial_fit is used instead of fit, they are assigned to the
          last batch of data.
  
      Examples
      --------
      >>> from sklearn.cluster import Birch
      >>> X = [[0, 1], [0.3, 1], [-0.3, 1], [0, -1], [0.3, -1], [-0.3, -1]]
      >>> brc = Birch(branching_factor=50, n_clusters=None, threshold=0.5,
      ... compute_labels=True)
      >>> brc.fit(X)
      Birch(branching_factor=50, compute_labels=True, copy=True, n_clusters=None,
         threshold=0.5)
      >>> brc.predict(X)
      array([0, 0, 0, 1, 1, 1])
  
      References
      ----------
      * Tian Zhang, Raghu Ramakrishnan, Maron Livny
        BIRCH: An efficient data clustering method for large databases.
        http://www.cs.sfu.ca/CourseCentral/459/han/papers/zhang96.pdf
  
      * Roberto Perdisci
        JBirch - Java implementation of BIRCH clustering algorithm
        https://code.google.com/archive/p/jbirch
  
      Notes
      -----
      The tree data structure consists of nodes with each node consisting of
      a number of subclusters. The maximum number of subclusters in a node
      is determined by the branching factor. Each subcluster maintains a
      linear sum, squared sum and the number of samples in that subcluster.
      In addition, each subcluster can also have a node as its child, if the
      subcluster is not a member of a leaf node.
  
      For a new point entering the root, it is merged with the subcluster closest
      to it and the linear sum, squared sum and the number of samples of that
      subcluster are updated. This is done recursively till the properties of
      the leaf node are updated.
      """
  
      def __init__(self, threshold=0.5, branching_factor=50, n_clusters=3,
                   compute_labels=True, copy=True):
          self.threshold = threshold
          self.branching_factor = branching_factor
          self.n_clusters = n_clusters
          self.compute_labels = compute_labels
          self.copy = copy
  
      def fit(self, X, y=None):
          """
          Build a CF Tree for the input data.
  
          Parameters
          ----------
          X : {array-like, sparse matrix}, shape (n_samples, n_features)
              Input data.
  
          y : Ignored
  
          """
          self.fit_, self.partial_fit_ = True, False
          return self._fit(X)
  
      def _fit(self, X):
          X = check_array(X, accept_sparse='csr', copy=self.copy)
          threshold = self.threshold
          branching_factor = self.branching_factor
  
          if branching_factor <= 1:
              raise ValueError("Branching_factor should be greater than one.")
          n_samples, n_features = X.shape
  
          # If partial_fit is called for the first time or fit is called, we
          # start a new tree.
          partial_fit = getattr(self, 'partial_fit_')
          has_root = getattr(self, 'root_', None)
          if getattr(self, 'fit_') or (partial_fit and not has_root):
              # The first root is the leaf. Manipulate this object throughout.
              self.root_ = _CFNode(threshold, branching_factor, is_leaf=True,
                                   n_features=n_features)
  
              # To enable getting back subclusters.
              self.dummy_leaf_ = _CFNode(threshold, branching_factor,
                                         is_leaf=True, n_features=n_features)
              self.dummy_leaf_.next_leaf_ = self.root_
              self.root_.prev_leaf_ = self.dummy_leaf_
  
          # Cannot vectorize. Enough to convince to use cython.
          if not sparse.issparse(X):
              iter_func = iter
          else:
              iter_func = _iterate_sparse_X
  
          for sample in iter_func(X):
              subcluster = _CFSubcluster(linear_sum=sample)
              split = self.root_.insert_cf_subcluster(subcluster)
  
              if split:
                  new_subcluster1, new_subcluster2 = _split_node(
                      self.root_, threshold, branching_factor)
                  del self.root_
                  self.root_ = _CFNode(threshold, branching_factor,
                                       is_leaf=False,
                                       n_features=n_features)
                  self.root_.append_subcluster(new_subcluster1)
                  self.root_.append_subcluster(new_subcluster2)
  
          centroids = np.concatenate([
              leaf.centroids_ for leaf in self._get_leaves()])
          self.subcluster_centers_ = centroids
  
          self._global_clustering(X)
          return self
  
      def _get_leaves(self):
          """
          Retrieve the leaves of the CF Node.
  
          Returns
          -------
          leaves : array-like
              List of the leaf nodes.
          """
          leaf_ptr = self.dummy_leaf_.next_leaf_
          leaves = []
          while leaf_ptr is not None:
              leaves.append(leaf_ptr)
              leaf_ptr = leaf_ptr.next_leaf_
          return leaves
  
      def partial_fit(self, X=None, y=None):
          """
          Online learning. Prevents rebuilding of CFTree from scratch.
  
          Parameters
          ----------
          X : {array-like, sparse matrix}, shape (n_samples, n_features), None
              Input data. If X is not provided, only the global clustering
              step is done.
  
          y : Ignored
  
          """
          self.partial_fit_, self.fit_ = True, False
          if X is None:
              # Perform just the final global clustering step.
              self._global_clustering()
              return self
          else:
              self._check_fit(X)
              return self._fit(X)
  
      def _check_fit(self, X):
          is_fitted = hasattr(self, 'subcluster_centers_')
  
          # Called by partial_fit, before fitting.
          has_partial_fit = hasattr(self, 'partial_fit_')
  
          # Should raise an error if one does not fit before predicting.
          if not (is_fitted or has_partial_fit):
              raise NotFittedError("Fit training data before predicting")
  
          if is_fitted and X.shape[1] != self.subcluster_centers_.shape[1]:
              raise ValueError(
                  "Training data and predicted data do "
                  "not have same number of features.")
  
      def predict(self, X):
          """
          Predict data using the ``centroids_`` of subclusters.
  
          Avoid computation of the row norms of X.
  
          Parameters
          ----------
          X : {array-like, sparse matrix}, shape (n_samples, n_features)
              Input data.
  
          Returns
          -------
          labels : ndarray, shape(n_samples)
              Labelled data.
          """
          X = check_array(X, accept_sparse='csr')
          self._check_fit(X)
          reduced_distance = safe_sparse_dot(X, self.subcluster_centers_.T)
          reduced_distance *= -2
          reduced_distance += self._subcluster_norms
          return self.subcluster_labels_[np.argmin(reduced_distance, axis=1)]
  
      def transform(self, X):
          """
          Transform X into subcluster centroids dimension.
  
          Each dimension represents the distance from the sample point to each
          cluster centroid.
  
          Parameters
          ----------
          X : {array-like, sparse matrix}, shape (n_samples, n_features)
              Input data.
  
          Returns
          -------
          X_trans : {array-like, sparse matrix}, shape (n_samples, n_clusters)
              Transformed data.
          """
          check_is_fitted(self, 'subcluster_centers_')
          return euclidean_distances(X, self.subcluster_centers_)
  
      def _global_clustering(self, X=None):
          """
          Global clustering for the subclusters obtained after fitting
          """
          clusterer = self.n_clusters
          centroids = self.subcluster_centers_
          compute_labels = (X is not None) and self.compute_labels
  
          # Preprocessing for the global clustering.
          not_enough_centroids = False
          if isinstance(clusterer, int):
              clusterer = AgglomerativeClustering(
                  n_clusters=self.n_clusters)
              # There is no need to perform the global clustering step.
              if len(centroids) < self.n_clusters:
                  not_enough_centroids = True
          elif (clusterer is not None and not
                hasattr(clusterer, 'fit_predict')):
              raise ValueError("n_clusters should be an instance of "
                               "ClusterMixin or an int")
  
          # To use in predict to avoid recalculation.
          self._subcluster_norms = row_norms(
              self.subcluster_centers_, squared=True)
  
          if clusterer is None or not_enough_centroids:
              self.subcluster_labels_ = np.arange(len(centroids))
              if not_enough_centroids:
                  warnings.warn(
                      "Number of subclusters found (%d) by Birch is less "
                      "than (%d). Decrease the threshold."
                      % (len(centroids), self.n_clusters))
          else:
              # The global clustering step that clusters the subclusters of
              # the leaves. It assumes the centroids of the subclusters as
              # samples and finds the final centroids.
              self.subcluster_labels_ = clusterer.fit_predict(
                  self.subcluster_centers_)
  
          if compute_labels:
              self.labels_ = self.predict(X)
  