code: def _fit(self, X, y, sample_weight, module, queue):
      if hasattr(self, "decision_function_shape"):
          if self.decision_function_shape not in ("ovr", "ovo", None):
              raise ValueError(
                  f"decision_function_shape must be either 'ovr' or 'ovo', "
                  f"got {self.decision_function_shape}."
              )
  
      if y is None:
          if self._get_tags()["requires_y"]:
              raise ValueError(
                  f"This {self.__class__.__name__} estimator "
                  f"requires y to be passed, but the target y is None."
              )
      X, y = _check_X_y(
          X,
          y,
          dtype=[np.float64, np.float32],
          force_all_finite=True,
          accept_sparse="csr",
      )
      y = self._validate_targets(y, X.dtype)
      sample_weight = self._get_sample_weight(X, y, sample_weight)
  
      self._sparse = sp.issparse(X)
  
      if self.kernel == "linear":
          self._scale_, self._sigma_ = 1.0, 1.0
          self.coef0 = 0.0
      else:
          self._scale_, self._sigma_ = self._compute_gamma_sigma(
              self.gamma, X
          )
  
      policy = _get_policy(queue, X, y, sample_weight)
      params = self._get_onedal_params(X)
      result = module.train(
          policy, params, *to_table(X, y, sample_weight)
      )
  
      if self._sparse:
          self.dual_coef_ = sp.csr_matrix(from_table(result.coeffs).T)
          self.support_vectors_ = sp.csr_matrix(
              from_table(result.support_vectors)
          )
      else:
          self.dual_coef_ = from_table(result.coeffs).T
          self.support_vectors_ = from_table(result.support_vectors)
  
      self.intercept_ = from_table(result.biases).ravel()
      self.support_ = (
          from_table(result.support_indices).ravel().astype("int")
      )
      self.n_features_in_ = X.shape[1]
      self.shape_fit_ = X.shape
  
      if getattr(self, "classes_", None) is not None:
          indices = y.take(self.support_, axis=0)
          self._n_support = np.array(
              [
                  np.sum(indices == i)
                  for i, _ in enumerate(self.classes_)
              ]
          )
      self._gamma = self._scale_
  
      self._onedal_model = result.model
      return self
  
imports: from abc import ABCMeta, abstractmethod
  from enum import Enum
  from numbers import Number, Real
  import numpy
  from scipy import sparse
  from sklearn.base import BaseEstimator
  from daal4py.sklearn._utils import sklearn_check_version
  from onedal import _backend
  from ..common._estimator_checks import _check_is_fitted
  from ..common._mixin import ClassifierMixin, RegressorMixin
  from ..common._policy import _get_policy
  from ..datatypes import from_table, to_table
  from ..utils import _check_array, _check_n_features, _check_X_y, _column_or_1d, _validate_targets
label_desc: Use image node_id 6 for calling the BaseSVM obj's underlying member method code with example usage: obj._fit(X, y, sample_weight, module, queue) and returns: self