class_docstr: t-distributed Stochastic Neighbor Embedding.
  
  t-SNE [1] is a tool to visualize high-dimensional data. It converts
  similarities between data points to joint probabilities and tries
  to minimize the Kullback-Leibler divergence between the joint
  probabilities of the low-dimensional embedding and the
  high-dimensional data. t-SNE has a cost function that is not convex,
  i.e. with different initializations we can get different results.
  
  It is highly recommended to use another dimensionality reduction
  method (e.g. PCA for dense data or TruncatedSVD for sparse data)
  to reduce the number of dimensions to a reasonable amount (e.g. 50)
  if the number of features is very high. This will suppress some
  noise and speed up the computation of pairwise distances between
  samples. For more tips see Laurens van der Maaten's FAQ [2].
  
  Read more in the :ref:`User Guide <t_sne>`.
  
  Parameters
  ----------
  n_components : int, optional (default: 2)
      Dimension of the embedded space.
  
  perplexity : float, optional (default: 30)
      The perplexity is related to the number of nearest neighbors that
      is used in other manifold learning algorithms. Larger datasets
      usually require a larger perplexity. Consider selecting a value
      between 5 and 50. The choice is not extremely critical since t-SNE
      is quite insensitive to this parameter.
  
  early_exaggeration : float, optional (default: 4.0)
      Controls how tight natural clusters in the original space are in
      the embedded space and how much space will be between them. For
      larger values, the space between natural clusters will be larger
      in the embedded space. Again, the choice of this parameter is not
      very critical. If the cost function increases during initial
      optimization, the early exaggeration factor or the learning rate
      might be too high.
  
  learning_rate : float, optional (default: 1000)
      The learning rate can be a critical parameter. It should be
      between 100 and 1000. If the cost function increases during initial
      optimization, the early exaggeration factor or the learning rate
      might be too high. If the cost function gets stuck in a bad local
      minimum increasing the learning rate helps sometimes.
  
  n_iter : int, optional (default: 1000)
      Maximum number of iterations for the optimization. Should be at
      least 200.
  
  n_iter_without_progress : int, optional (default: 30)
      Only used if method='exact'
      Maximum number of iterations without progress before we abort the
      optimization. If method='barnes_hut' this parameter is fixed to
      a value of 30 and cannot be changed.
  
      .. versionadded:: 0.17
         parameter *n_iter_without_progress* to control stopping criteria.
  
  min_grad_norm : float, optional (default: 1e-7)
      Only used if method='exact'
      If the gradient norm is below this threshold, the optimization will
      be aborted. If method='barnes_hut' this parameter is fixed to a value
      of 1e-3 and cannot be changed.
  
  metric : string or callable, optional
      The metric to use when calculating distance between instances in a
      feature array. If metric is a string, it must be one of the options
      allowed by scipy.spatial.distance.pdist for its metric parameter, or
      a metric listed in pairwise.PAIRWISE_DISTANCE_FUNCTIONS.
      If metric is "precomputed", X is assumed to be a distance matrix.
      Alternatively, if metric is a callable function, it is called on each
      pair of instances (rows) and the resulting value recorded. The callable
      should take two arrays from X as input and return a value indicating
      the distance between them. The default is "euclidean" which is
      interpreted as squared euclidean distance.
  
  init : string or numpy array, optional (default: "random")
      Initialization of embedding. Possible options are 'random', 'pca',
      and a numpy array of shape (n_samples, n_components).
      PCA initialization cannot be used with precomputed distances and is
      usually more globally stable than random initialization.
  
  verbose : int, optional (default: 0)
      Verbosity level.
  
  random_state : int or RandomState instance or None (default)
      Pseudo Random Number generator seed control. If None, use the
      numpy.random singleton. Note that different initializations
      might result in different local minima of the cost function.
  
  method : string (default: 'barnes_hut')
      By default the gradient calculation algorithm uses Barnes-Hut
      approximation running in O(NlogN) time. method='exact'
      will run on the slower, but exact, algorithm in O(N^2) time. The
      exact algorithm should be used when nearest-neighbor errors need
      to be better than 3%. However, the exact method cannot scale to
      millions of examples.
  
      .. versionadded:: 0.17
         Approximate optimization *method* via the Barnes-Hut.
  
  angle : float (default: 0.5)
      Only used if method='barnes_hut'
      This is the trade-off between speed and accuracy for Barnes-Hut T-SNE.
      'angle' is the angular size (referred to as theta in [3]) of a distant
      node as measured from a point. If this size is below 'angle' then it is
      used as a summary node of all points contained within it.
      This method is not very sensitive to changes in this parameter
      in the range of 0.2 - 0.8. Angle less than 0.2 has quickly increasing
      computation time and angle greater 0.8 has quickly increasing error.
  
  
  Attributes
  ----------
  embedding_ : array-like, shape (n_samples, n_components)
      Stores the embedding vectors.
  
  kl_divergence_ : float
      Kullback-Leibler divergence after optimization.
  
  Examples
  --------
  
  >>> import numpy as np
  >>> from sklearn.manifold import TSNE
  >>> X = np.array([[0, 0, 0], [0, 1, 1], [1, 0, 1], [1, 1, 1]])
  >>> model = TSNE(n_components=2, random_state=0)
  >>> np.set_printoptions(suppress=True)
  >>> model.fit_transform(X) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
  array([[ 0.00017599,  0.00003993],
         [ 0.00009891,  0.00021913],
         [ 0.00018554, -0.00009357],
         [ 0.00009528, -0.00001407]])
  
  References
  ----------
  
  [1] van der Maaten, L.J.P.; Hinton, G.E. Visualizing High-Dimensional Data
      Using t-SNE. Journal of Machine Learning Research 9:2579-2605, 2008.
  
  [2] van der Maaten, L.J.P. t-Distributed Stochastic Neighbor Embedding
      http://homepage.tudelft.nl/19j49/t-SNE.html
  
  [3] L.J.P. van der Maaten. Accelerating t-SNE using Tree-Based Algorithms.
      Journal of Machine Learning Research 15(Oct):3221-3245, 2014.
      http://lvdmaaten.github.io/publications/papers/JMLR_2014.pdf
docstr: Runs t-SNE.
docstr_tok: ["Runs","t-SNE","."]
code: def _tsne(
      self,
      P,
      degrees_of_freedom,
      n_samples,
      random_state,
      X_embedded=None,
      neighbors=None,
      skip_num_points=0,
  ):
      """Runs t-SNE."""
      # t-SNE minimizes the Kullback-Leiber divergence of the Gaussians P
      # and the Student's t-distributions Q. The optimization algorithm that
      # we use is batch gradient descent with three stages:
      # * early exaggeration with momentum 0.5
      # * early exaggeration with momentum 0.8
      # * final optimization with momentum 0.8
      # The embedding is initialized with iid samples from Gaussians with
      # standard deviation 1e-4.
  
      if X_embedded is None:
          # Initialize embedding randomly
          X_embedded = 1e-4 * random_state.randn(
              n_samples, self.n_components
          )
      params = X_embedded.ravel()
  
      opt_args = {
          "n_iter": 50,
          "momentum": 0.5,
          "it": 0,
          "learning_rate": self.learning_rate,
          "n_iter_without_progress": self.n_iter_without_progress,
          "verbose": self.verbose,
          "n_iter_check": 25,
          "kwargs": dict(skip_num_points=skip_num_points),
      }
      if self.method == "barnes_hut":
          m = "Must provide an array of neighbors to use Barnes-Hut"
          assert neighbors is not None, m
          obj_func = _kl_divergence_bh
          objective_error = _kl_divergence_error
          sP = squareform(P).astype(np.float32)
          neighbors = neighbors.astype(np.int64)
          args = [
              sP,
              neighbors,
              degrees_of_freedom,
              n_samples,
              self.n_components,
          ]
          opt_args["args"] = args
          opt_args["min_grad_norm"] = 1e-3
          opt_args["n_iter_without_progress"] = 30
          # Don't always calculate the cost since that calculation
          # can be nearly as expensive as the gradient
          opt_args["objective_error"] = objective_error
          opt_args["kwargs"]["angle"] = self.angle
          opt_args["kwargs"]["verbose"] = self.verbose
      else:
          obj_func = _kl_divergence
          opt_args["args"] = [
              P,
              degrees_of_freedom,
              n_samples,
              self.n_components,
          ]
          opt_args["min_error_diff"] = 0.0
          opt_args["min_grad_norm"] = self.min_grad_norm
  
      # Early exaggeration
      P *= self.early_exaggeration
  
      params, kl_divergence, it = _gradient_descent(
          obj_func, params, **opt_args
      )
      opt_args["n_iter"] = 100
      opt_args["momentum"] = 0.8
      opt_args["it"] = it + 1
      params, kl_divergence, it = _gradient_descent(
          obj_func, params, **opt_args
      )
      if self.verbose:
          print(
              "[t-SNE] KL divergence after %d iterations with early "
              "exaggeration: %f" % (it + 1, kl_divergence)
          )
      # Save the final number of iterations
      self.n_iter_final = it
  
      # Final optimization
      P /= self.early_exaggeration
      opt_args["n_iter"] = self.n_iter
      opt_args["it"] = it + 1
      params, error, it = _gradient_descent(
          obj_func, params, **opt_args
      )
  
      if self.verbose:
          print(
              "[t-SNE] Error after %d iterations: %f"
              % (it + 1, kl_divergence)
          )
  
      X_embedded = params.reshape(n_samples, self.n_components)
      self.kl_divergence_ = kl_divergence
  
      return X_embedded
  
imports: import numpy
  from scipy import linalg
  import scipy.sparse
  from scipy.spatial.distance import pdist
  from scipy.spatial.distance import squareform
  from ..neighbors import BallTree
  from ..base import BaseEstimator
  from ..utils import check_array
  from ..utils import check_random_state
  from ..utils.extmath import _ravel
  from ..decomposition import PCA
  from ..metrics.pairwise import pairwise_distances
  from .None import _utils
  from .None import _barnes_hut_tsne
  from ..utils.fixes import astype
  from ..externals.six import string_types
label_desc: Use image node_id 3 for calling the TSNE obj's underlying member method code with example usage: obj._tsne(P, degrees_of_freedom, n_samples, random_state, X_embedded, neighbors, skip_num_points) and returns: X_embedded