code: def get_not_so_random_params(self, models_cnt, current_models):
      model_types = [
          "Xgboost",
          "LightGBM",
          "CatBoost",
          "Random Forest",
          "Extra Trees",
          "Neural Network",
          "Nearest Neighbors",
      ]
  
      generated_params = {m: [] for m in model_types}
  
      for model_type in model_types:
          if model_type not in self._algorithms:
              continue
  
          if self.skip_if_rows_cols_limit(model_type):
              continue
          # minus 1 because already have 1 default
          for i in range(self._start_random_models - 1):
              logger.info(
                  f"Generate not-so-random parameters for {model_type} (#{models_cnt+1})"
              )
              params = self._get_model_params(model_type, seed=i + 1)
              if params is None:
                  continue
  
              params["name"] = self.get_model_name(
                  model_type, models_cnt + 1
              )
              params["status"] = "initialized"
              params["final_loss"] = None
              params["train_time"] = None
              params["data_type"] = "original"
              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
  
              if self._fairness_metric is not None:
                  swp, name_suffix = self.get_fairness_sample_weight(
                      current_models, model_type
                  )
                  if swp is not None:
                      params["validation_strategy"][
                          "sample_weight_path"
                      ] = swp
                      params["injected_sample_weight"] = True
                  if name_suffix is not None:
                      params["name"] += name_suffix
  
              unique_params_key = MljarTuner.get_params_key(params)
              if unique_params_key not in self._unique_params_keys:
                  generated_params[model_type] += [params]
                  models_cnt += 1
  
      """
          return_params = []
          for i in range(100):
              total = 0
              for m in ["Xgboost", "LightGBM", "CatBoost"]:
                  if generated_params[m]:
                      return_params += [generated_params[m].pop(0)]
                  total += len(generated_params[m])
              if total == 0:
                  break
  
          rest_params = []
          for m in [
              "Random Forest",
              "Extra Trees",
              "Neural Network",
              "Nearest Neighbors",
          ]:
              rest_params += generated_params[m]
          if rest_params:
              np.random.shuffle(rest_params)
              return_params += rest_params
          """
      return_params = []
      for i in range(100):
          total = 0
          for m in [
              "LightGBM",
              "Xgboost",
              "CatBoost",
              "Random Forest",
              "Extra Trees",
              "Neural Network",
              "Nearest Neighbors",
          ]:
              if generated_params[m]:
                  return_params += [generated_params[m].pop(0)]
              total += len(generated_params[m])
          if total == 0:
              break
  
      return return_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 19 for calling the MljarTuner obj's underlying member method code with example usage: obj.get_not_so_random_params(models_cnt, current_models) and returns: return_params