class_docstr: Support-vector machine (SVM) classifier.
  
  :param kernel: the kernel function to be used.
  :type kernel: str, {'linear', 'poly', 'rbf', 'sigmoid'}, default='linear'
  
  :param max_iteration_count: the maximum number of iterations.
  :type max_iteration_count: int, default=1000
  
  :param error_weight: the error weight relative to the regularization function.
  :type error_weight: float, default=1.0
  
  :param degree: the degree for the gaussian kernel.
  :type degree: int, default=1
  
  :param gamma: the kernel coefficient for `poly`, `rbf`, `sigmoid`.
  :type gamma: float, default=1.0
  
  :param coeff0: the kernel free term for `poly`, `sigmoid`.
  :type coeff0: float, default=1.0
  
  :param tolerance: the algorithm precision.
  :type tolerance: float, default=0.1
  
  :param thread_count: The number of processing threads to be used while training the model.
  :type thread_count: int, default=1
  
  :param multiclass_mode: determines how to handle multi-class classification
  :type multiclass_mode: str, ['one_vs_all', 'one_vs_one'], default='one_vs_all'
code: def __init__(
      self,
      kernel="linear",
      max_iteration_count=1000,
      error_weight=1.0,
      degree=1,
      gamma=1.0,
      coeff0=1.0,
      tolerance=0.1,
      thread_count=1,
      multiclass_mode="one_vs_all",
  ):
      if (
          kernel != "linear"
          and kernel != "poly"
          and kernel != "rbf"
          and kernel != "sigmoid"
      ):
          raise ValueError(
              "The `kernel` must be one of: `linear`, `poly`, `rbf`, `sigmoid`."
          )
      if max_iteration_count <= 0:
          raise ValueError("The `max_iteration_count` must be > 0.")
      if error_weight <= 0:
          raise ValueError("The `error_weight` must be >= 0.")
  
      if thread_count <= 0:
          raise ValueError("The `thread_count` must be > 0.")
      if (
          multiclass_mode != "one_vs_all"
          and multiclass_mode != "one_vs_one"
      ):
          raise ValueError(
              "The `multiclass_mode` must be one of: `one_vs_all`, `one_vs_one`."
          )
  
      super().__init__(
          kernel,
          float(error_weight),
          int(max_iteration_count),
          int(degree),
          float(gamma),
          float(coeff0),
          float(tolerance),
          int(thread_count),
          multiclass_mode,
      )
  
file_path: neoml/NeoML/Python/neoml/SVM.py
imports: import numpy
  from .Utils import convert_data, get_data
  from scipy.sparse import csr_matrix, issparse
  import neoml.PythonWrapper
label_desc: Use image node_id 1 to create a new SvmClassifier object from inherited base classes: PythonWrapper with example: obj = SvmClassifier(kernel, max_iteration_count, error_weight, degree, gamma, coeff0, tolerance, thread_count, multiclass_mode)