code: def smacof(
      similarities,
      metric=True,
      n_components=2,
      init=None,
      n_init=8,
      n_jobs=1,
      max_iter=300,
      verbose=0,
      eps=1e-3,
      random_state=None,
      return_n_iter=False,
  ):
      """
      Computes multidimensional scaling using SMACOF (Scaling by Majorizing a
      Complicated Function) algorithm
  
      The SMACOF algorithm is a multidimensional scaling algorithm: it minimizes
      a objective function, the *stress*, using a majorization technique. The
      Stress Majorization, also known as the Guttman Transform, guarantees a
      monotone convergence of Stress, and is more powerful than traditional
      techniques such as gradient descent.
  
      The SMACOF algorithm for metric MDS can summarized by the following steps:
  
      1. Set an initial start configuration, randomly or not.
      2. Compute the stress
      3. Compute the Guttman Transform
      4. Iterate 2 and 3 until convergence.
  
      The nonmetric algorithm adds a monotonic regression steps before computing
      the stress.
  
      Parameters
      ----------
      similarities : symmetric ndarray, shape (n_samples, n_samples)
          similarities between the points
  
      metric : boolean, optional, default: True
          compute metric or nonmetric SMACOF algorithm
  
      n_components : int, optional, default: 2
          number of dimension in which to immerse the similarities
          overridden if initial array is provided.
  
      init : {None or ndarray of shape (n_samples, n_components)}, optional
          if None, randomly chooses the initial configuration
          if ndarray, initialize the SMACOF algorithm with this array
  
      n_init : int, optional, default: 8
          Number of time the smacof algorithm will be run with different
          initialisation. The final results will be the best output of the
          n_init consecutive runs in terms of stress.
  
      n_jobs : int, optional, default: 1
  
          The number of jobs to use for the computation. This works by breaking
          down the pairwise matrix into n_jobs even slices and computing them in
          parallel.
  
          If -1 all CPUs are used. If 1 is given, no parallel computing code is
          used at all, which is useful for debugging. For n_jobs below -1,
          (n_cpus + 1 + n_jobs) are used. Thus for n_jobs = -2, all CPUs but one
          are used.
  
      max_iter : int, optional, default: 300
          Maximum number of iterations of the SMACOF algorithm for a single run
  
      verbose : int, optional, default: 0
          level of verbosity
  
      eps : float, optional, default: 1e-6
          relative tolerance w.r.t stress to declare converge
  
      random_state : integer or numpy.RandomState, optional
          The generator used to initialize the centers. If an integer is
          given, it fixes the seed. Defaults to the global numpy random
          number generator.
  
      return_n_iter : bool
          Whether or not to return the number of iterations.
  
      Returns
      -------
      X : ndarray (n_samples,n_components)
          Coordinates of the n_samples points in a n_components-space
  
      stress : float
          The final value of the stress (sum of squared distance of the
          disparities and the distances for all constrained points)
  
      n_iter : int
          The number of iterations corresponding to the best stress.
          Returned only if `return_n_iter` is set to True.
  
      Notes
      -----
      "Modern Multidimensional Scaling - Theory and Applications" Borg, I.;
      Groenen P. Springer Series in Statistics (1997)
  
      "Nonmetric multidimensional scaling: a numerical method" Kruskal, J.
      Psychometrika, 29 (1964)
  
      "Multidimensional scaling by optimizing goodness of fit to a nonmetric
      hypothesis" Kruskal, J. Psychometrika, 29, (1964)
      """
  
      similarities = check_array(similarities)
      random_state = check_random_state(random_state)
  
      if hasattr(init, "__array__"):
          init = np.asarray(init).copy()
          if not n_init == 1:
              warnings.warn(
                  "Explicit initial positions passed: "
                  "performing only one init of the MDS instead of %d"
                  % n_init
              )
              n_init = 1
  
      best_pos, best_stress = None, None
  
      if n_jobs == 1:
          for it in range(n_init):
              pos, stress, n_iter_ = _smacof_single(
                  similarities,
                  metric=metric,
                  n_components=n_components,
                  init=init,
                  max_iter=max_iter,
                  verbose=verbose,
                  eps=eps,
                  random_state=random_state,
              )
              if best_stress is None or stress < best_stress:
                  best_stress = stress
                  best_pos = pos.copy()
                  best_iter = n_iter_
      else:
          seeds = random_state.randint(
              np.iinfo(np.int32).max, size=n_init
          )
          results = Parallel(
              n_jobs=n_jobs, verbose=max(verbose - 1, 0)
          )(
              delayed(_smacof_single)(
                  similarities,
                  metric=metric,
                  n_components=n_components,
                  init=init,
                  max_iter=max_iter,
                  verbose=verbose,
                  eps=eps,
                  random_state=seed,
              )
              for seed in seeds
          )
          positions, stress, n_iters = zip(*results)
          best = np.argmin(stress)
          best_stress = stress[best]
          best_pos = positions[best]
          best_iter = n_iters[best]
  
      if return_n_iter:
          return best_pos, best_stress, best_iter
      else:
          return best_pos, best_stress
  
file_path: catboost/contrib/python/scikit-learn/py2/sklearn/manifold/mds.py
imports: import numpy
  import warnings
  from ..base import BaseEstimator
  from ..metrics import euclidean_distances
  from ..utils import check_random_state, check_array, check_symmetric
  from ..externals.joblib import Parallel
  from ..externals.joblib import delayed
  from ..isotonic import IsotonicRegression
label_desc: Use image node_id 2 for calling a global function with example usage: smacof(similarities, metric, n_components, init, n_init, n_jobs, max_iter, verbose, eps, random_state, return_n_iter) and returns: best_pos,  best_stress,  best_iter, best_pos,  best_stress