Difference between optuna (optuna.samplers.RandomSampler) and sklearn (RandomizedSearchCV) - scikit-learn

Question

I would like to use the RandomSearch sample from optuna and I notice that compared to the RandomSearchCV block from sklearn there are big differences in terms of calculation time.
The model is a LightGBM classifier. Do you understand where it can come from?
Code optuna : (1200 seconds)
def fit_random_search_optuna(trial,data,targets) :
params_fixed = {
"is_unbalance" : trial.set_user_attr("is_unbalance",True),
"objective": trial.set_user_attr("objective","binary"),
"verbosity": trial.set_user_attr("verbosity",1),
'bagging_freq': trial.set_user_attr("bagging_freq",1),
'n_jobs' : trial.set_user_attr("n_jobs",-1),
'boosting' : trial.set_user_attr('boosting','gbdt'),
}
params_search = {
'lambda_l2': trial.suggest_loguniform('lambda_l2', 1e-8, 10.0),
'num_leaves': trial.suggest_int('num_leaves', 32, 256),
'feature_fraction': trial.suggest_uniform('feature_fraction', 0.3, 0.8),
'bagging_fraction': trial.suggest_uniform('bagging_fraction', 0.7, 1),
'min_data_in_leaf': trial.suggest_int('min_data_in_leaf', 4, 50),
'num_iterations' : trial.suggest_int('num_iterations',8,250),
'max_bin' : trial.suggest_int('max_bin',10,50),
'learning_rate' : trial.suggest_float('learning_rate', 0.005, 0.1, log = True),
}
params = {**trial.params, **trial.user_attrs}
score = 0
cv = 3
shape = data.shape[0]
list_indexs = np.arange(shape)
kfold = KFold(n_splits=cv,shuffle=True,random_state=42)
indexs = [(indexs_train,indexs_validation) for (indexs_train,indexs_validation) in kfold.split(list_indexs)]
###### INDEX FOR CROSS VAL
for num_cv, (index_train, index_validation) in enumerate(indexs) :
## GET GOOD INDEXS
data_train, data_validation = data.iloc[index_train], data.iloc[index_validation]
target_train, target_validation = targets.iloc[index_train], targets.iloc[index_validation]
## SET LIGHTGBM AND TRAIN SET
model = lgb.LGBMClassifier()
model.set_params(**params)
model.fit(data_train, target_train)
## PREDICTION ON VALIDATION SET
pred_probas = model.predict_proba(data_validation)[:,1]
score+=sklearn.metrics.roc_auc_score(y_score=pred_probas, y_true=target_validation)
return score/cv
## CREATION OF OPTUNA STUDY AND OPTIMIZATION
study = optuna.create_study(direction='maximize', sampler=optuna.samplers.RandomSampler())
objective = lambda trial : fit_random_search_optuna(trial, data, targets)
n_jobs_for_random_search=1
study.optimize(objective, n_trials=100, n_jobs = n_jobs_for_random_search)
Code random search : For the same dataset the duration is about 400 seconds
def fit_random_search_sklearn(data, targets) :
params_fixed = {
"is_unbalance" : [True],
"objective": ["binary"],
"verbosity": [1],
'bagging_freq': [1],
'n_jobs' : [-1],
'boosting' : ['gbdt'],
}
params_search = {
'lambda_l2': loguniform( 1e-8, 10.0),
'num_leaves': np.arange(32, 256),
'feature_fraction': uniform(0.3, 0.8),
'bagging_fraction': uniform(0.7, 1),
'min_data_in_leaf': np.arange(4, 50),
'num_iterations' : np.arange(8,250),
'max_bin' : np.arange(10,50),
'learning_rate' : loguniform( 0.005, 0.1),
}
params = {**params_fixed, **params_search}
model = lgb.LGBMClassifier()
n_jobs_for_random_search = 1
random_search = RandomizedSearchCV(model, param_distributions=params,n_iter = 100,
n_jobs = n_jobs_for_random_search, random_state = 42,
cv = 3, scoring = 'roc_auc', refit = False)
random_search.fit(data, targets)
return random_search.best_params_