class_docstr: This class defines the certain operation implementation for the sklearn operations
  defined in operation repository
  
  Args:
      operation_type: ``str`` of the operation defined in operation or
          data operation repositories
  
          .. details:: possible operations:
  
              - ``xgbreg``-> XGBRegressor
              - ``adareg``-> AdaBoostRegressor
              - ``gbr``-> GradientBoostingRegressor
              - ``dtreg``-> DecisionTreeRegressor
              - ``treg``-> ExtraTreesRegressor
              - ``rfr``-> RandomForestRegressor
              - ``linear``-> SklearnLinReg
              - ``ridge``-> SklearnRidgeReg
              - ``lasso``-> SklearnLassoReg
              - ``svr``-> SklearnSVR
              - ``sgdr``-> SklearnSGD
              - ``lgbmreg``-> LGBMRegressor
              - ``xgboost``-> XGBClassifier
              - ``logit``-> SklearnLogReg
              - ``bernb``-> SklearnBernoulliNB
              - ``multinb``-> SklearnMultinomialNB
              - ``dt``-> DecisionTreeClassifier
              - ``rf``-> RandomForestClassifier
              - ``mlp``-> MLPClassifier
              - ``lgbm``-> LGBMClassifier
              - ``kmeans``-> SklearnKmeans
  
      params: hyperparameters to fit the operation with
docstr: This method is used for operation training with the data provided
  
  Args:
      train_data: data used for operation training
  
  Returns:
      trained Sklearn operation
docstr_tok: ["This","method","is","used","for","operation","training","with","the","data","provided","Args",":","train_data",":","data","used","for","operation","training","Returns",":","trained","Sklearn","operation"]
code: def fit(self, train_data: InputData):
      """This method is used for operation training with the data provided
  
      Args:
          train_data: data used for operation training
  
      Returns:
          trained Sklearn operation
      """
  
      warnings.filterwarnings("ignore", category=RuntimeWarning)
  
      operation_implementation = self.operation_impl(
          **self.params_for_fit.to_dict()
      )
  
      # If model doesn't support multi-output and current task is ts_forecasting
      current_task = train_data.task.task_type
      models_repo = OperationTypesRepository()
      non_multi_models = models_repo.suitable_operation(
          task_type=current_task, tags=["non_multi"]
      )
      is_model_not_support_multi = (
          self.operation_type in non_multi_models
      )
  
      # Multi-output task or not
      is_multi_target = is_multi_output_task(train_data)
      with ImplementationRandomStateHandler(
          implementation=operation_implementation
      ):
          if is_model_not_support_multi and is_multi_target:
              # Manually wrap the regressor into multi-output model
              operation_implementation = convert_to_multivariate_model(
                  operation_implementation, train_data
              )
          else:
              operation_implementation.fit(
                  train_data.features, train_data.target
              )
      return operation_implementation
  
imports: import warnings
  from abc import abstractmethod
  from typing import Optional
  import numpy
  from golem.core.log import default_log
  from lightgbm.sklearn import LGBMClassifier, LGBMRegressor
  from sklearn.cluster import KMeans
  from sklearn.ensemble import AdaBoostRegressor, ExtraTreesRegressor, GradientBoostingRegressor, RandomForestClassifier, RandomForestRegressor
  from sklearn.linear_model import Lasso, LinearRegression, LogisticRegression, Ridge, SGDRegressor
  from sklearn.multioutput import MultiOutputClassifier, MultiOutputRegressor
  from sklearn.naive_bayes import BernoulliNB, MultinomialNB
  from sklearn.neural_network import MLPClassifier
  from sklearn.svm import LinearSVR
  from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
  from xgboost import XGBClassifier, XGBRegressor
  from fedot.core.data.data import InputData, OutputData
  from fedot.core.operations.operation_parameters import OperationParameters
  from fedot.core.repository.dataset_types import DataTypesEnum
  from fedot.core.repository.operation_types_repository import OperationTypesRepository, get_operation_type_from_id
  from fedot.core.repository.tasks import TaskTypesEnum
  from fedot.utilities.custom_errors import AbstractMethodNotImplementError
  from fedot.utilities.random import ImplementationRandomStateHandler
label_desc: Use image node_id 2 for calling the SkLearnEvaluationStrategy obj's underlying member method code with example usage: obj.fit(train_data) and returns: operation_implementation