class_docstr: Linear Support Vector Classification.
  
  Similar to SVC with parameter kernel='linear', but implemented in terms of
  liblinear rather than libsvm, so it has more flexibility in the choice of
  penalties and loss functions and should scale better to large numbers of
  samples.
  
  This class supports both dense and sparse input and the multiclass support
  is handled according to a one-vs-the-rest scheme.
  
  Read more in the :ref:`User Guide <svm_classification>`.
  
  Parameters
  ----------
  C : float, optional (default=1.0)
      Penalty parameter C of the error term.
  
  loss : string, 'hinge' or 'squared_hinge' (default='squared_hinge')
      Specifies the loss function. 'hinge' is the standard SVM loss
      (used e.g. by the SVC class) while 'squared_hinge' is the
      square of the hinge loss.
  
  penalty : string, 'l1' or 'l2' (default='l2')
      Specifies the norm used in the penalization. The 'l2'
      penalty is the standard used in SVC. The 'l1' leads to ``coef_``
      vectors that are sparse.
  
  dual : bool, (default=True)
      Select the algorithm to either solve the dual or primal
      optimization problem. Prefer dual=False when n_samples > n_features.
  
  tol : float, optional (default=1e-4)
      Tolerance for stopping criteria.
  
  multi_class: string, 'ovr' or 'crammer_singer' (default='ovr')
      Determines the multi-class strategy if `y` contains more than
      two classes.
      ``"ovr"`` trains n_classes one-vs-rest classifiers, while ``"crammer_singer"``
      optimizes a joint objective over all classes.
      While `crammer_singer` is interesting from a theoretical perspective
      as it is consistent, it is seldom used in practice as it rarely leads
      to better accuracy and is more expensive to compute.
      If ``"crammer_singer"`` is chosen, the options loss, penalty and dual will
      be ignored.
  
  fit_intercept : boolean, optional (default=True)
      Whether to calculate the intercept for this model. If set
      to false, no intercept will be used in calculations
      (i.e. data is expected to be already centered).
  
  intercept_scaling : float, optional (default=1)
      When self.fit_intercept is True, instance vector x becomes
      ``[x, self.intercept_scaling]``,
      i.e. a "synthetic" feature with constant value equals 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, 'balanced'}, optional
      Set the parameter C of class i to ``class_weight[i]*C`` for
      SVC. 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))``
  
  verbose : int, (default=0)
      Enable verbose output. Note that this setting takes advantage of a
      per-process runtime setting in liblinear that, if enabled, may not work
      properly in a multithreaded context.
  
  random_state : int seed, RandomState instance, or None (default=None)
      The seed of the pseudo random number generator to use when
      shuffling the data.
  
  max_iter : int, (default=1000)
      The maximum number of iterations to be run.
  
  Attributes
  ----------
  coef_ : array, shape = [n_features] if n_classes == 2 else [n_classes, n_features]
      Weights assigned to the features (coefficients in the primal
      problem). This is only available in the case of a linear kernel.
  
      ``coef_`` is a readonly property derived from ``raw_coef_`` that
      follows the internal memory layout of liblinear.
  
  intercept_ : array, shape = [1] if n_classes == 2 else [n_classes]
      Constants in decision function.
  
  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.
  
  The underlying implementation, liblinear, uses a sparse internal
  representation for the data that will incur a memory copy.
  
  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/>`__
  
  See also
  --------
  SVC
      Implementation of Support Vector Machine classifier using libsvm:
      the kernel can be non-linear but its SMO algorithm does not
      scale to large number of samples as LinearSVC does.
  
      Furthermore SVC multi-class mode is implemented using one
      vs one scheme while LinearSVC uses one vs the rest. It is
      possible to implement one vs the rest with SVC by using the
      :class:`sklearn.multiclass.OneVsRestClassifier` wrapper.
  
      Finally SVC can fit dense data without memory copy if the input
      is C-contiguous. Sparse data will still incur memory copy though.
  
  sklearn.linear_model.SGDClassifier
      SGDClassifier can optimize the same cost function as LinearSVC
      by adjusting the penalty and loss parameters. In addition it requires
      less memory, allows incremental (online) learning, and implements
      various loss functions and regularization regimes.
class_docstr_tok: ["Linear","Support","Vector","Classification",".","Similar","to","SVC","with","parameter","kernel='linear","'",",","but","implemented","in","terms","of","liblinear","rather","than","libsvm",",","so","it","has","more","flexibility","in","the","choice","of","penalties","and","loss","functions","and","should","scale","better","to","large","numbers","of","samples",".","This","class","supports","both","dense","and","sparse","input","and","the","multiclass","support","is","handled","according","to","a","one-vs-the-rest","scheme",".","Read","more","in","the",":","ref",":","`","User","Guide","<","svm_classification",">","`",".","Parameters","--","--","--","--","--","C",":","float",",","optional","(","default=1.0",")","Penalty","parameter","C","of","the","error","term",".","loss",":","string",",","'hinge","'","or","'squared_hinge","'","(","default='squared_hinge","'",")","Specifies","the","loss","function",".","'hinge","'","is","the","standard","SVM","loss","(","used","e.g",".","by","the","SVC","class",")","while","'squared_hinge","'","is","the","square","of","the","hinge","loss",".","penalty",":","string",",","'l1","'","or","'l2","'","(","default='l2","'",")","Specifies","the","norm","used","in","the","penalization",".","The","'l2'","penalty","is","the","standard","used","in","SVC",".","The","'l1","'","leads","to","``","coef_","``","vectors","that","are","sparse",".","dual",":","bool",",","(","default=True",")","Select","the","algorithm","to","either","solve","the","dual","or","primal","optimization","problem",".","Prefer","dual=False","when","n_samples",">","n_features",".","tol",":","float",",","optional","(","default=1e-4",")","Tolerance","for","stopping","criteria",".","multi_class",":","string",",","'ovr","'","or","'crammer_singer","'","(","default='ovr","'",")","Determines","the","multi-class","strategy","if","`","y","`","contains","more","than","two","classes",".","``","``","ovr","''","``","trains","n_classes","one-vs-rest","classifiers",",","while","``","``","crammer_singer","''","``","optimizes","a","joint","objective","over","all","classes",".","While","`","crammer_singer","`","is","interesting","from","a","theoretical","perspective","as","it","is","consistent",",","it","is","seldom","used","in","practice","as","it","rarely","leads","to","better","accuracy","and","is","more","expensive","to","compute",".","If","``","``","crammer_singer","''","``","is","chosen",",","the","options","loss",",","penalty","and","dual","will","be","ignored",".","fit_intercept",":","boolean",",","optional","(","default=True",")","Whether","to","calculate","the","intercept","for","this","model",".","If","set","to","false",",","no","intercept","will","be","used","in","calculations","(","i.e",".","data","is","expected","to","be","already","centered",")",".","intercept_scaling",":","float",",","optional","(","default=1",")","When","self.fit_intercept","is","True",",","instance","vector","x","becomes","``","[","x",",","self.intercept_scaling","]","``",",","i.e",".","a","``","synthetic","''","feature","with","constant","value","equals","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",",","'balanced","'","}",",","optional","Set","the","parameter","C","of","class","i","to","``","class_weight","[","i","]","*","C","``","for","SVC",".","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",")",")","``","verbose",":","int",",","(","default=0",")","Enable","verbose","output",".","Note","that","this","setting","takes","advantage","of","a","per-process","runtime","setting","in","liblinear","that",",","if","enabled",",","may","not","work","properly","in","a","multithreaded","context",".","random_state",":","int","seed",",","RandomState","instance",",","or","None","(","default=None",")","The","seed","of","the","pseudo","random","number","generator","to","use","when","shuffling","the","data",".","max_iter",":","int",",","(","default=1000",")","The","maximum","number","of","iterations","to","be","run",".","Attributes","--","--","--","--","--","coef_",":","array",",","shape","=","[","n_features","]","if","n_classes","==","2","else","[","n_classes",",","n_features","]","Weights","assigned","to","the","features","(","coefficients","in","the","primal","problem",")",".","This","is","only","available","in","the","case","of","a","linear","kernel",".","``","coef_","``","is","a","readonly","property","derived","from","``","raw_coef_","``","that","follows","the","internal","memory","layout","of","liblinear",".","intercept_",":","array",",","shape","=","[","1","]","if","n_classes","==","2","else","[","n_classes","]","Constants","in","decision","function",".","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",".","The","underlying","implementation",",","liblinear",",","uses","a","sparse","internal","representation","for","the","data","that","will","incur","a","memory","copy",".","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\/",">","`","__","See","also","--","--","--","--","SVC","Implementation","of","Support","Vector","Machine","classifier","using","libsvm",":","the","kernel","can","be","non-linear","but","its","SMO","algorithm","does","not","scale","to","large","number","of","samples","as","LinearSVC","does",".","Furthermore","SVC","multi-class","mode","is","implemented","using","one","vs","one","scheme","while","LinearSVC","uses","one","vs","the","rest",".","It","is","possible","to","implement","one","vs","the","rest","with","SVC","by","using","the",":","class",":","`","sklearn.multiclass.OneVsRestClassifier","`","wrapper",".","Finally","SVC","can","fit","dense","data","without","memory","copy","if","the","input","is","C-contiguous",".","Sparse","data","will","still","incur","memory","copy","though",".","sklearn.linear_model.SGDClassifier","SGDClassifier","can","optimize","the","same","cost","function","as","LinearSVC","by","adjusting","the","penalty","and","loss","parameters",".","In","addition","it","requires","less","memory",",","allows","incremental","(","online",")","learning",",","and","implements","various","loss","functions","and","regularization","regimes","."]
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 in 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.
  
  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","in","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",".","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 in 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.
  
      Returns
      -------
      self : object
          Returns self.
      """
      # FIXME Remove l1/l2 support in 1.0 -----------------------------------
      msg = (
          "loss='%s' has been deprecated in favor of "
          "loss='%s' as of 0.16. Backward compatibility"
          " for the loss='%s' will be removed in %s"
      )
  
      if self.loss in ("l1", "l2"):
          old_loss = self.loss
          self.loss = {"l1": "hinge", "l2": "squared_hinge"}.get(
              self.loss
          )
          warnings.warn(
              msg % (old_loss, self.loss, old_loss, "1.0"),
              DeprecationWarning,
          )
      # ---------------------------------------------------------------------
  
      if self.C < 0:
          raise ValueError(
              "Penalty term must be positive; got (C=%r)" % self.C
          )
  
      X, y = check_X_y(
          X, y, accept_sparse="csr", dtype=np.float64, order="C"
      )
      check_classification_targets(y)
      self.classes_ = np.unique(y)
  
      self.coef_, self.intercept_, self.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,
          self.multi_class,
          self.loss,
          sample_weight=sample_weight,
      )
  
      if (
          self.multi_class == "crammer_singer"
          and len(self.classes_) == 2
      ):
          self.coef_ = (self.coef_[1] - self.coef_[0]).reshape(1, -1)
          if self.fit_intercept:
              intercept = self.intercept_[1] - self.intercept_[0]
              self.intercept_ = np.array([intercept])
  
      return self
  
imports: import warnings
  import numpy
  from .base import _fit_liblinear, BaseSVC, BaseLibSVM
  from ..base import BaseEstimator, RegressorMixin
  from ..linear_model.base import LinearClassifierMixin, SparseCoefMixin, LinearModel
  from ..feature_selection.from_model import _LearntSelectorMixin
  from ..utils import check_X_y
  from ..utils.validation import _num_samples
  from ..utils.multiclass import check_classification_targets
label_desc: Use image node_id 2 for calling the LinearSVC obj's underlying member method code with example usage: obj.fit(X, y, sample_weight) and returns: self