class_docstr: Logistic Regression (aka logit, MaxEnt) classifier.
  
  In the multiclass case, the training algorithm uses the one-vs-rest (OvR)
  scheme if the 'multi_class' option is set to 'ovr', and uses the cross-
  entropy loss if the 'multi_class' option is set to 'multinomial'.
  (Currently the 'multinomial' option is supported only by the 'lbfgs',
  'sag' and 'newton-cg' solvers.)
  
  This class implements regularized logistic regression using the
  'liblinear' library, 'newton-cg', 'sag' and 'lbfgs' solvers. It can handle
  both dense and sparse input. Use C-ordered arrays or CSR matrices
  containing 64-bit floats for optimal performance; any other input format
  will be converted (and copied).
  
  The 'newton-cg', 'sag', and 'lbfgs' solvers support only L2 regularization
  with primal formulation. The 'liblinear' solver supports both L1 and L2
  regularization, with a dual formulation only for the L2 penalty.
  
  Read more in the :ref:`User Guide <logistic_regression>`.
  
  Parameters
  ----------
  penalty : str, 'l1' or 'l2', default: 'l2'
      Used to specify the norm used in the penalization. The 'newton-cg',
      'sag' and 'lbfgs' solvers support only l2 penalties.
  
  dual : bool, default: False
      Dual or primal formulation. Dual formulation is only implemented for
      l2 penalty with liblinear solver. Prefer dual=False when
      n_samples > n_features.
  
  C : float, default: 1.0
      Inverse of regularization strength; must be a positive float.
      Like in support vector machines, smaller values specify stronger
      regularization.
  
  fit_intercept : bool, default: True
      Specifies if a constant (a.k.a. bias or intercept) should be
      added to the decision function.
  
  intercept_scaling : float, default 1.
      Useful only when the solver 'liblinear' is used
      and self.fit_intercept is set to True. In this case, x becomes
      [x, self.intercept_scaling],
      i.e. a "synthetic" feature with constant value equal to
      intercept_scaling is appended to the instance vector.
      The intercept becomes ``intercept_scaling * synthetic_feature_weight``.
  
      Note! the synthetic feature weight is subject to l1/l2 regularization
      as all other features.
      To lessen the effect of regularization on synthetic feature weight
      (and therefore on the intercept) intercept_scaling has to be increased.
  
  class_weight : dict or 'balanced', default: None
      Weights associated with classes in the form ``{class_label: weight}``.
      If not given, all classes are supposed to have weight one.
  
      The "balanced" mode uses the values of y to automatically adjust
      weights inversely proportional to class frequencies in the input data
      as ``n_samples / (n_classes * np.bincount(y))``.
  
      Note that these weights will be multiplied with sample_weight (passed
      through the fit method) if sample_weight is specified.
  
      .. versionadded:: 0.17
         *class_weight='balanced'* instead of deprecated
         *class_weight='auto'*.
  
  max_iter : int, default: 100
      Useful only for the newton-cg, sag and lbfgs solvers.
      Maximum number of iterations taken for the solvers to converge.
  
  random_state : int seed, RandomState instance, default: None
      The seed of the pseudo random number generator to use when
      shuffling the data. Used only in solvers 'sag' and 'liblinear'.
  
  solver : {'newton-cg', 'lbfgs', 'liblinear', 'sag'}, default: 'liblinear'
      Algorithm to use in the optimization problem.
  
      - For small datasets, 'liblinear' is a good choice, whereas 'sag' is
          faster for large ones.
      - For multiclass problems, only 'newton-cg', 'sag' and 'lbfgs' handle
          multinomial loss; 'liblinear' is limited to one-versus-rest
          schemes.
      - 'newton-cg', 'lbfgs' and 'sag' only handle L2 penalty.
  
      Note that 'sag' fast convergence is only guaranteed on features with
      approximately the same scale. You can preprocess the data with a
      scaler from sklearn.preprocessing.
  
      .. versionadded:: 0.17
         Stochastic Average Gradient descent solver.
  
  tol : float, default: 1e-4
      Tolerance for stopping criteria.
  
  multi_class : str, {'ovr', 'multinomial'}, default: 'ovr'
      Multiclass option can be either 'ovr' or 'multinomial'. If the option
      chosen is 'ovr', then a binary problem is fit for each label. Else
      the loss minimised is the multinomial loss fit across
      the entire probability distribution. Works only for the 'newton-cg',
      'sag' and 'lbfgs' solver.
  
      .. versionadded:: 0.18
         Stochastic Average Gradient descent solver for 'multinomial' case.
  
  verbose : int, default: 0
      For the liblinear and lbfgs solvers set verbose to any positive
      number for verbosity.
  
  warm_start : bool, default: False
      When set to True, reuse the solution of the previous call to fit as
      initialization, otherwise, just erase the previous solution.
      Useless for liblinear solver.
  
      .. versionadded:: 0.17
         *warm_start* to support *lbfgs*, *newton-cg*, *sag* solvers.
  
  n_jobs : int, default: 1
      Number of CPU cores used during the cross-validation loop. If given
      a value of -1, all cores are used.
  
  Attributes
  ----------
  coef_ : array, shape (n_classes, n_features)
      Coefficient of the features in the decision function.
  
  intercept_ : array, shape (n_classes,)
      Intercept (a.k.a. bias) added to the decision function.
      If `fit_intercept` is set to False, the intercept is set to zero.
  
  n_iter_ : array, shape (n_classes,) or (1, )
      Actual number of iterations for all classes. If binary or multinomial,
      it returns only 1 element. For liblinear solver, only the maximum
      number of iteration across all classes is given.
  
  See also
  --------
  SGDClassifier : incrementally trained logistic regression (when given
      the parameter ``loss="log"``).
  sklearn.svm.LinearSVC : learns SVM models using the same algorithm.
  
  Notes
  -----
  The underlying C implementation uses a random number generator to
  select features when fitting the model. It is thus not uncommon,
  to have slightly different results for the same input data. If
  that happens, try with a smaller tol parameter.
  
  Predict output may not match that of standalone liblinear in certain
  cases. See :ref:`differences from liblinear <liblinear_differences>`
  in the narrative documentation.
  
  References
  ----------
  
  LIBLINEAR -- A Library for Large Linear Classification
      http://www.csie.ntu.edu.tw/~cjlin/liblinear/
  
  SAG -- Mark Schmidt, Nicolas Le Roux, and Francis Bach
      Minimizing Finite Sums with the Stochastic Average Gradient
      https://hal.inria.fr/hal-00860051/document
  
  Hsiang-Fu Yu, Fang-Lan Huang, Chih-Jen Lin (2011). Dual coordinate descent
      methods for logistic regression and maximum entropy models.
      Machine Learning 85(1-2):41-75.
      http://www.csie.ntu.edu.tw/~cjlin/papers/maxent_dual.pdf
class_docstr_tok: ["Logistic","Regression","(","aka","logit",",","MaxEnt",")","classifier",".","In","the","multiclass","case",",","the","training","algorithm","uses","the","one-vs-rest","(","OvR",")","scheme","if","the","'multi_class","'","option","is","set","to","'ovr","'",",","and","uses","the","cross-","entropy","loss","if","the","'multi_class","'","option","is","set","to","'multinomial","'",".","(","Currently","the","'multinomial","'","option","is","supported","only","by","the","'lbfgs","'",",","'sag","'","and","'newton-cg","'","solvers",".",")","This","class","implements","regularized","logistic","regression","using","the","'liblinear","'","library",",","'newton-cg","'",",","'sag","'","and","'lbfgs","'","solvers",".","It","can","handle","both","dense","and","sparse","input",".","Use","C-ordered","arrays","or","CSR","matrices","containing","64-bit","floats","for","optimal","performance",";","any","other","input","format","will","be","converted","(","and","copied",")",".","The","'newton-cg","'",",","'sag","'",",","and","'lbfgs","'","solvers","support","only","L2","regularization","with","primal","formulation",".","The","'liblinear","'","solver","supports","both","L1","and","L2","regularization",",","with","a","dual","formulation","only","for","the","L2","penalty",".","Read","more","in","the",":","ref",":","`","User","Guide","<","logistic_regression",">","`",".","Parameters","--","--","--","--","--","penalty",":","str",",","'l1","'","or","'l2","'",",","default",":","'l2'","Used","to","specify","the","norm","used","in","the","penalization",".","The","'newton-cg","'",",","'sag","'","and","'lbfgs","'","solvers","support","only","l2","penalties",".","dual",":","bool",",","default",":","False","Dual","or","primal","formulation",".","Dual","formulation","is","only","implemented","for","l2","penalty","with","liblinear","solver",".","Prefer","dual=False","when","n_samples",">","n_features",".","C",":","float",",","default",":","1.0","Inverse","of","regularization","strength",";","must","be","a","positive","float",".","Like","in","support","vector","machines",",","smaller","values","specify","stronger","regularization",".","fit_intercept",":","bool",",","default",":","True","Specifies","if","a","constant","(","a.k.a",".","bias","or","intercept",")","should","be","added","to","the","decision","function",".","intercept_scaling",":","float",",","default","1",".","Useful","only","when","the","solver","'liblinear","'","is","used","and","self.fit_intercept","is","set","to","True",".","In","this","case",",","x","becomes","[","x",",","self.intercept_scaling","]",",","i.e",".","a","``","synthetic","''","feature","with","constant","value","equal","to","intercept_scaling","is","appended","to","the","instance","vector",".","The","intercept","becomes","``","intercept_scaling","*","synthetic_feature_weight","``",".","Note","!","the","synthetic","feature","weight","is","subject","to","l1\/l2","regularization","as","all","other","features",".","To","lessen","the","effect","of","regularization","on","synthetic","feature","weight","(","and","therefore","on","the","intercept",")","intercept_scaling","has","to","be","increased",".","class_weight",":","dict","or","'balanced","'",",","default",":","None","Weights","associated","with","classes","in","the","form","``","{","class_label",":","weight","}","``",".","If","not","given",",","all","classes","are","supposed","to","have","weight","one",".","The","``","balanced","''","mode","uses","the","values","of","y","to","automatically","adjust","weights","inversely","proportional","to","class","frequencies","in","the","input","data","as","``","n_samples","\/","(","n_classes","*","np.bincount","(","y",")",")","``",".","Note","that","these","weights","will","be","multiplied","with","sample_weight","(","passed","through","the","fit","method",")","if","sample_weight","is","specified",".","..","versionadded",":",":","0.17","*","class_weight='balanced","'","*","instead","of","deprecated","*","class_weight='auto","'","*",".","max_iter",":","int",",","default",":","100","Useful","only","for","the","newton-cg",",","sag","and","lbfgs","solvers",".","Maximum","number","of","iterations","taken","for","the","solvers","to","converge",".","random_state",":","int","seed",",","RandomState","instance",",","default",":","None","The","seed","of","the","pseudo","random","number","generator","to","use","when","shuffling","the","data",".","Used","only","in","solvers","'sag","'","and","'liblinear","'",".","solver",":","{","'newton-cg","'",",","'lbfgs","'",",","'liblinear","'",",","'sag","'","}",",","default",":","'liblinear'","Algorithm","to","use","in","the","optimization","problem",".","-","For","small","datasets",",","'liblinear","'","is","a","good","choice",",","whereas","'sag","'","is","faster","for","large","ones",".","-","For","multiclass","problems",",","only","'newton-cg","'",",","'sag","'","and","'lbfgs","'","handle","multinomial","loss",";","'liblinear","'","is","limited","to","one-versus-rest","schemes",".","-","'newton-cg","'",",","'lbfgs","'","and","'sag","'","only","handle","L2","penalty",".","Note","that","'sag","'","fast","convergence","is","only","guaranteed","on","features","with","approximately","the","same","scale",".","You","can","preprocess","the","data","with","a","scaler","from","sklearn.preprocessing",".","..","versionadded",":",":","0.17","Stochastic","Average","Gradient","descent","solver",".","tol",":","float",",","default",":","1e-4","Tolerance","for","stopping","criteria",".","multi_class",":","str",",","{","'ovr","'",",","'multinomial","'","}",",","default",":","'ovr'","Multiclass","option","can","be","either","'ovr","'","or","'multinomial","'",".","If","the","option","chosen","is","'ovr","'",",","then","a","binary","problem","is","fit","for","each","label",".","Else","the","loss","minimised","is","the","multinomial","loss","fit","across","the","entire","probability","distribution",".","Works","only","for","the","'newton-cg","'",",","'sag","'","and","'lbfgs","'","solver",".","..","versionadded",":",":","0.18","Stochastic","Average","Gradient","descent","solver","for","'multinomial","'","case",".","verbose",":","int",",","default",":","0","For","the","liblinear","and","lbfgs","solvers","set","verbose","to","any","positive","number","for","verbosity",".","warm_start",":","bool",",","default",":","False","When","set","to","True",",","reuse","the","solution","of","the","previous","call","to","fit","as","initialization",",","otherwise",",","just","erase","the","previous","solution",".","Useless","for","liblinear","solver",".","..","versionadded",":",":","0.17","*","warm_start","*","to","support","*","lbfgs","*",",","*","newton-cg","*",",","*","sag","*","solvers",".","n_jobs",":","int",",","default",":","1","Number","of","CPU","cores","used","during","the","cross-validation","loop",".","If","given","a","value","of","-1",",","all","cores","are","used",".","Attributes","--","--","--","--","--","coef_",":","array",",","shape","(","n_classes",",","n_features",")","Coefficient","of","the","features","in","the","decision","function",".","intercept_",":","array",",","shape","(","n_classes",",",")","Intercept","(","a.k.a",".","bias",")","added","to","the","decision","function",".","If","`","fit_intercept","`","is","set","to","False",",","the","intercept","is","set","to","zero",".","n_iter_",":","array",",","shape","(","n_classes",",",")","or","(","1",",",")","Actual","number","of","iterations","for","all","classes",".","If","binary","or","multinomial",",","it","returns","only","1","element",".","For","liblinear","solver",",","only","the","maximum","number","of","iteration","across","all","classes","is","given",".","See","also","--","--","--","--","SGDClassifier",":","incrementally","trained","logistic","regression","(","when","given","the","parameter","``","loss=","''","log","''","``",")",".","sklearn.svm.LinearSVC",":","learns","SVM","models","using","the","same","algorithm",".","Notes","--","--","-","The","underlying","C","implementation","uses","a","random","number","generator","to","select","features","when","fitting","the","model",".","It","is","thus","not","uncommon",",","to","have","slightly","different","results","for","the","same","input","data",".","If","that","happens",",","try","with","a","smaller","tol","parameter",".","Predict","output","may","not","match","that","of","standalone","liblinear","in","certain","cases",".","See",":","ref",":","`","differences","from","liblinear","<","liblinear_differences",">","`","in","the","narrative","documentation",".","References","--","--","--","--","--","LIBLINEAR","--","A","Library","for","Large","Linear","Classification","http",":","\/\/www.csie.ntu.edu.tw\/~cjlin\/liblinear\/","SAG","--","Mark","Schmidt",",","Nicolas","Le","Roux",",","and","Francis","Bach","Minimizing","Finite","Sums","with","the","Stochastic","Average","Gradient","https",":","\/\/hal.inria.fr\/hal-00860051\/document","Hsiang-Fu","Yu",",","Fang-Lan","Huang",",","Chih-Jen","Lin","(","2011",")",".","Dual","coordinate","descent","methods","for","logistic","regression","and","maximum","entropy","models",".","Machine","Learning","85","(","1-2",")",":41-75.","http",":","\/\/www.csie.ntu.edu.tw\/~cjlin\/papers\/maxent_dual.pdf"]
docstr: Fit the model according to the given training data.
  
  Parameters
  ----------
  X : {array-like, sparse matrix}, shape (n_samples, n_features)
      Training vector, where n_samples is the number of samples and
      n_features is the number of features.
  
  y : array-like, shape (n_samples,)
      Target vector relative to X.
  
  sample_weight : array-like, shape (n_samples,) optional
      Array of weights that are assigned to individual samples.
      If not provided, then each sample is given unit weight.
  
      .. versionadded:: 0.17
         *sample_weight* support to LogisticRegression.
  
  Returns
  -------
  self : object
      Returns self.
docstr_tok: ["Fit","the","model","according","to","the","given","training","data",".","Parameters","--","--","--","--","--","X",":","{","array-like",",","sparse","matrix","}",",","shape","(","n_samples",",","n_features",")","Training","vector",",","where","n_samples","is","the","number","of","samples","and","n_features","is","the","number","of","features",".","y",":","array-like",",","shape","(","n_samples",",",")","Target","vector","relative","to","X.","sample_weight",":","array-like",",","shape","(","n_samples",",",")","optional","Array","of","weights","that","are","assigned","to","individual","samples",".","If","not","provided",",","then","each","sample","is","given","unit","weight",".","..","versionadded",":",":","0.17","*","sample_weight","*","support","to","LogisticRegression",".","Returns","--","--","--","-","self",":","object","Returns","self","."]
code: def fit(self, X, y, sample_weight=None):
      """Fit the model according to the given training data.
  
      Parameters
      ----------
      X : {array-like, sparse matrix}, shape (n_samples, n_features)
          Training vector, where n_samples is the number of samples and
          n_features is the number of features.
  
      y : array-like, shape (n_samples,)
          Target vector relative to X.
  
      sample_weight : array-like, shape (n_samples,) optional
          Array of weights that are assigned to individual samples.
          If not provided, then each sample is given unit weight.
  
          .. versionadded:: 0.17
             *sample_weight* support to LogisticRegression.
  
      Returns
      -------
      self : object
          Returns self.
      """
      if not isinstance(self.C, numbers.Number) or self.C < 0:
          raise ValueError(
              "Penalty term must be positive; got (C=%r)" % self.C
          )
      if (
          not isinstance(self.max_iter, numbers.Number)
          or self.max_iter < 0
      ):
          raise ValueError(
              "Maximum number of iteration must be positive;"
              " got (max_iter=%r)" % self.max_iter
          )
      if not isinstance(self.tol, numbers.Number) or self.tol < 0:
          raise ValueError(
              "Tolerance for stopping criteria must be "
              "positive; got (tol=%r)" % self.tol
          )
  
      X, y = check_X_y(
          X, y, accept_sparse="csr", dtype=np.float64, order="C"
      )
      check_classification_targets(y)
      self.classes_ = np.unique(y)
      n_samples, n_features = X.shape
  
      _check_solver_option(
          self.solver, self.multi_class, self.penalty, self.dual
      )
  
      if self.solver == "liblinear":
          self.coef_, self.intercept_, n_iter_ = _fit_liblinear(
              X,
              y,
              self.C,
              self.fit_intercept,
              self.intercept_scaling,
              self.class_weight,
              self.penalty,
              self.dual,
              self.verbose,
              self.max_iter,
              self.tol,
              self.random_state,
              sample_weight=sample_weight,
          )
          self.n_iter_ = np.array([n_iter_])
          return self
  
      if self.solver == "sag":
          max_squared_sum = row_norms(X, squared=True).max()
      else:
          max_squared_sum = None
  
      n_classes = len(self.classes_)
      classes_ = self.classes_
      if n_classes < 2:
          raise ValueError(
              "This solver needs samples of at least 2 classes"
              " in the data, but the data contains only one"
              " class: %r" % classes_[0]
          )
  
      if len(self.classes_) == 2:
          n_classes = 1
          classes_ = classes_[1:]
  
      if self.warm_start:
          warm_start_coef = getattr(self, "coef_", None)
      else:
          warm_start_coef = None
      if warm_start_coef is not None and self.fit_intercept:
          warm_start_coef = np.append(
              warm_start_coef, self.intercept_[:, np.newaxis], axis=1
          )
  
      self.coef_ = list()
      self.intercept_ = np.zeros(n_classes)
  
      # Hack so that we iterate only once for the multinomial case.
      if self.multi_class == "multinomial":
          classes_ = [None]
          warm_start_coef = [warm_start_coef]
  
      if warm_start_coef is None:
          warm_start_coef = [None] * n_classes
  
      path_func = delayed(logistic_regression_path)
  
      # The SAG solver releases the GIL so it's more efficient to use
      # threads for this solver.
      backend = (
          "threading" if self.solver == "sag" else "multiprocessing"
      )
      fold_coefs_ = Parallel(
          n_jobs=self.n_jobs, verbose=self.verbose, backend=backend
      )(
          path_func(
              X,
              y,
              pos_class=class_,
              Cs=[self.C],
              fit_intercept=self.fit_intercept,
              tol=self.tol,
              verbose=self.verbose,
              solver=self.solver,
              copy=False,
              multi_class=self.multi_class,
              max_iter=self.max_iter,
              class_weight=self.class_weight,
              check_input=False,
              random_state=self.random_state,
              coef=warm_start_coef_,
              max_squared_sum=max_squared_sum,
              sample_weight=sample_weight,
          )
          for (class_, warm_start_coef_) in zip(
              classes_, warm_start_coef
          )
      )
  
      fold_coefs_, _, n_iter_ = zip(*fold_coefs_)
      self.n_iter_ = np.asarray(n_iter_, dtype=np.int32)[:, 0]
  
      if self.multi_class == "multinomial":
          self.coef_ = fold_coefs_[0][0]
      else:
          self.coef_ = np.asarray(fold_coefs_)
          self.coef_ = self.coef_.reshape(
              n_classes, n_features + int(self.fit_intercept)
          )
  
      if self.fit_intercept:
          self.intercept_ = self.coef_[:, -1]
          self.coef_ = self.coef_[:, :-1]
  
      return self
  
imports: import numbers
  import warnings
  import numpy
  from scipy import optimize, sparse
  from .base import LinearClassifierMixin, SparseCoefMixin, BaseEstimator
  from .sag import sag_solver
  from ..feature_selection.from_model import _LearntSelectorMixin
  from ..preprocessing import LabelEncoder, LabelBinarizer
  from ..svm.base import _fit_liblinear
  from ..utils import check_array, check_consistent_length, compute_class_weight
  from ..utils import check_random_state
  from ..utils.extmath import logsumexp, log_logistic, safe_sparse_dot, softmax, squared_norm
  from ..utils.extmath import row_norms
  from ..utils.optimize import newton_cg
  from ..utils.validation import check_X_y
  from ..exceptions import NotFittedError
  from ..utils.fixes import expit
  from ..utils.multiclass import check_classification_targets
  from ..externals.joblib import Parallel, delayed
  from ..model_selection import check_cv
  from ..externals import six
  from ..metrics import SCORERS
label_desc: Use image node_id 2 for calling the LogisticRegression obj's underlying member method code with example usage: obj.fit(X, y, sample_weight) and returns: self, self