code: def boost_params(
      self, current_models, results_path, total_time_limit
  ):
      model_selection_time_limit = (
          None if total_time_limit is None else 0.1 * total_time_limit
      )
      df_models, algorithms = self.df_models_algorithms(
          current_models, time_limit=model_selection_time_limit
      )
      best_model = None
      for i in range(df_models.shape[0]):
          if df_models["model_type"].iloc[i] in [
              "Ensemble",
              "Neural Network",
              "Nearest Neighbors",
          ]:
              continue
          if "RandomFeature" in df_models["model"].iloc[i].get_name():
              continue
          best_model = df_models["model"].iloc[i]
          break
      if best_model is None:
          return []
  
      # load predictions
      oof = best_model.get_out_of_folds()
  
      predictions = oof[
          [c for c in oof.columns if c.startswith("prediction")]
      ]
      y = oof["target"]
  
      if self._ml_task == MULTICLASS_CLASSIFICATION:
          oh = OneHotEncoder(sparse=False)
          y_encoded = oh.fit_transform(np.array(y).reshape(-1, 1))
          residua = np.sum(
              np.abs(np.array(y_encoded) - np.array(predictions)),
              axis=1,
          )
      else:
          residua = np.abs(np.array(y) - np.array(predictions).ravel())
  
      df_preds = pd.DataFrame(
          {
              "res": residua,
              "lp": range(residua.shape[0]),
              "target": np.array(y),
          }
      )
  
      df_preds = df_preds.sort_values(by="res", ascending=True)
      df_preds["order"] = range(residua.shape[0])
      df_preds["order"] = (df_preds["order"]) / residua.shape[
          0
      ] / 5.0 + 0.9
      df_preds = df_preds.sort_values(by="lp", ascending=True)
  
      sample_weight_path = os.path.join(
          results_path, best_model.get_name() + "_sample_weight.data"
      )
      dump_data(
          sample_weight_path,
          pd.DataFrame({"sample_weight": df_preds["order"]}),
      )
  
      generated_params = []
  
      params = copy.deepcopy(best_model.params)
  
      params["validation_strategy"][
          "sample_weight_path"
      ] = sample_weight_path
      params["injected_sample_weight"] = True
      params["name"] += "_BoostOnErrors"
      params["status"] = "initialized"
      params["final_loss"] = None
      params["train_time"] = None
      params["data_type"] = "boost_on_error"
      if "model_architecture_json" in params["learner"]:
          del params["learner"]["model_architecture_json"]
      if self._optuna_time_budget is not None:
          params["optuna_time_budget"] = self._optuna_time_budget
          params["optuna_init_params"] = self._optuna_init_params
          params["optuna_verbose"] = self._optuna_verbose
  
      unique_params_key = MljarTuner.get_params_key(params)
  
      if unique_params_key not in self._unique_params_keys:
          generated_params += [params]
  
      return generated_params
  
imports: import copy
  import json
  import logging
  import os
  import numpy
  import pandas
  from sklearn.preprocessing import OneHotEncoder
  from supervised.algorithms.catboost import catboost_eval_metric
  from supervised.algorithms.lightgbm import lightgbm_eval_metric
  from supervised.algorithms.registry import BINARY_CLASSIFICATION, MULTICLASS_CLASSIFICATION, REGRESSION, AlgorithmsRegistry
  from supervised.algorithms.xgboost import xgboost_eval_metric
  from supervised.preprocessing.label_encoder import LabelEncoder
  from supervised.preprocessing.preprocessing_categorical import PreprocessingCategorical
  from supervised.tuner.hill_climbing import HillClimbing
  from supervised.tuner.preprocessing_tuner import PreprocessingTuner
  from supervised.tuner.random_parameters import RandomParameters
  from supervised.utils.config import LOG_LEVEL
  from supervised.utils.utils import dump_data, load_data
label_desc: Use image node_id 34 for calling the MljarTuner obj's underlying member method code with example usage: obj.boost_params(current_models, results_path, total_time_limit) and returns: generated_params, list