code: def fit(self, X, y):
      import sklearn.svm
  
      # Calculate the size of the kernel cache (in MB) for sklearn's LibSVM.
      # The cache size is calculated as 2/3 of the available memory
      # (which is calculated as the memory limit minus the used memory)
      try:
          # Retrieve memory limits imposed on the process
          soft, hard = resource.getrlimit(resource.RLIMIT_AS)
  
          if soft > 0:
              # Convert limit to units of megabytes
              soft /= 1024 * 1024
  
              # Retrieve memory used by this process
              maxrss = (
                  resource.getrusage(resource.RUSAGE_SELF)[2] / 1024
              )
  
              # In MacOS, the MaxRSS output of resource.getrusage in bytes;
              # on other platforms, it's in kilobytes
              if sys.platform == "darwin":
                  maxrss = maxrss / 1024
  
              cache_size = (soft - maxrss) / 1.5
  
              if cache_size < 0:
                  cache_size = 200
          else:
              cache_size = 200
      except Exception:
          cache_size = 200
  
      self.C = float(self.C)
      self.epsilon = float(self.epsilon)
      self.tol = float(self.tol)
      self.shrinking = check_for_bool(self.shrinking)
      self.degree = int(self.degree)
      self.gamma = float(self.gamma)
      if check_none(self.coef0):
          self.coef0 = 0.0
      else:
          self.coef0 = float(self.coef0)
      self.verbose = int(self.verbose)
      self.max_iter = int(self.max_iter)
  
      self.estimator = sklearn.svm.SVR(
          kernel=self.kernel,
          C=self.C,
          epsilon=self.epsilon,
          tol=self.tol,
          shrinking=self.shrinking,
          degree=self.degree,
          gamma=self.gamma,
          coef0=self.coef0,
          cache_size=cache_size,
          verbose=self.verbose,
          max_iter=self.max_iter,
      )
      self.scaler = sklearn.preprocessing.StandardScaler(copy=True)
  
      # Convert y to be at least 2d for the scaler
      # [1,1,1] -> [[1], [1], [1]]
      if y.ndim == 1:
          y = y.reshape((-1, 1))
  
      y_scaled = self.scaler.fit_transform(y)
  
      # Flatten: [[0], [0], [0]] -> [0, 0, 0]
      if y_scaled.ndim == 2 and y_scaled.shape[1] == 1:
          y_scaled = y_scaled.flatten()
  
      self.estimator.fit(X, y_scaled)
  
      return self
  
file_path: auto-sklearn/autosklearn/pipeline/components/regression/libsvm_svr.py
imports: from typing import Optional
  import resource
  import sys
  from ConfigSpace.conditions import EqualsCondition, InCondition
  from ConfigSpace.configuration_space import ConfigurationSpace
  from ConfigSpace.hyperparameters import CategoricalHyperparameter, UniformFloatHyperparameter, UniformIntegerHyperparameter, UnParametrizedHyperparameter
  from autosklearn.askl_typing import FEAT_TYPE_TYPE
  from autosklearn.pipeline.components.base import AutoSklearnRegressionAlgorithm
  from autosklearn.pipeline.constants import DENSE, PREDICTIONS, SPARSE, UNSIGNED_DATA
  from autosklearn.util.common import check_for_bool, check_none
label_desc: Use image node_id 2 for calling the LibSVM_SVR obj's underlying member method code with example usage: obj.fit(X, y) and returns: self