Optimiser LightGBM avec Optuna – Comment faire facilement ?

Si tes en pleine compétition de ML, ou simplement en entreprise, tu peux utiliser Optuna pour optimiser ton modèle LightGBM.

Selon moi, LightGBM est une des meilleurs librairies de Machine Learning en ce moment.

Elle a permis d’établir de nombreux record dans les compétitions de ML.

Si tu ne connais pas encore cette librairie, je t’invite à lire notre article sur le sujet.

C’est un très bon tutoriel pour débuter.

Maintenant si tu es ici… c’est sûrement que tu veux aller plus loin.

Peut-être que ton modèle n’a pas atteint les performances que tu souhaitais.

Ou peut-être encore qu’il a dépasser toutes tes attentes.

Qu’une petite voix dans ta tête c’est demander « Jusqu’où peut-aller mon modèle ? »

Alors tu peux essayer de modifier toi même tes hyperparamètres.

Le problème ? C’est que ça risque de te prendre des heures.

Et au final, tu ne sais même pas si tu arriveras à améliorer ton modèle.

Une meilleure solution existe :

Optuna

Optuna est une librairie d’optimisation automatique de modèle de Machine Learning.

Soyons un peu plus précis.

Ce n’est pas vraiment automatique.

La librairie a besoin d’input de ta part pour optimiser ton modèle.

Voilà le principe : tu donne à Optuna un espace de recherche. Elle s’occupe de faire des tests sur ton modèle.

Par exemple tu veux explorer l’hyperparamètre learning_rate.

Dans ce cas tu lui donne un espace de recherche: « Optuna fait des tests sur le learning rate, en lui donnant des valeurs entre 0.0001 et 0.1 ».

Optuna prend ta requête et fait des tests.

Tu peux même lui demander d’explorer plusieurs hyperparamètres à la fois.

Si tu veux avoir un guide complet sur Optuna et des explications détaillées, c’est par ici.

Optimiser LightGBM avec Optuna

C’est très facile d’utiliser Optuna.

Notamment avec les bibliothèques de base : scikit-learn, Keras, PyTorch.

Mais quand on veut l’utiliser des bibliothèques plus techniques, c’est tout de suite plus compliqué

Considérons que tu as déjà tes données : X_train, X_val, X_test, y_train, y_val, y_test.

Tout d’abord, je t’invite à installer les deux librairies qui nous intéressent :

!pip install lightgbm
!pip install optuna

Ensuite importe LGBM et charge tes données dans des Datasets LGBM (C’est comme ça que la librairie pourra les interpréter) :

import lightgbm as lgb

lgb_train = lgb.Dataset(X_train, y_train)
lgb_val = lgb.Dataset(X_val, y_val, reference=lgb_train)

Ensuite, il faut créer une fonction.

Cette fonction c’est l’objectif que Optuna va optimiser.

Là le code va DÉPENDRE DE TON OBJECTIF.

Si tu veux maximiser la précision tu devras faire comme suit :

def objective(trial):
    # Define hyperparameters
    params = {
        'objective': 'binary',
        'learning_rate': trial.suggest_loguniform('learning_rate', 1e-5, 1e-2),
        'num_leaves': trial.suggest_int('num_leaves', 2, 128),
        'scale_pos_weight': trial.suggest_int('scale_pos_weight', 1, 10),
        'metric': 'accuracy'  # use accuracy as the evaluation metric
    }
    
    # Train model
    model = lgb.train(params, lgb_train, valid_sets=lgb_val, early_stopping_rounds=10)
    
    # Return accuracy on validation set
    return model.best_score['valid_0']['accuracy']

Si, à l’inverse, tu veux minimiser une loss , c’est ce code que tu devras prendre :

def objective(trial):
    # Define hyperparameters
    params = {
        'objective': 'binary',
        'learning_rate': trial.suggest_loguniform('learning_rate', 1e-5, 1e-2),
        'num_leaves': trial.suggest_int('num_leaves', 2, 128),
        'scale_pos_weight': trial.suggest_int('scale_pos_weight', 1, 10)
    }
    
    # Train model
    model = lgb.train(params, lgb_train, valid_sets=lgb_val, early_stopping_rounds=10)
    
    # Return loss on validation set
    return model.best_score['valid_0']['binary_logloss']

C’est dans la variable params que tu indique les hyperparamètres que tu souhaites optimiser.

Tu peux trouver la liste des hyperparamètres pour les modèles LigthGBM sur la documentation officielle.

Une dernière étape crucial est d’initialiser Optuna.

À ce moment tu dois lui indiquer si tu souhaites minimiser ou maximiser.

Si tu veut optimiser la précision choisis la maximisation :

import optuna

study = optuna.create_study(direction='maximize')

Sinon choisis la minimisation :

import lightgbm as lgbimport optuna

study = optuna.create_study(direction='minimize')

Il ne te reste plus qu’à lancer l’optimisation de LightGBM avec Optuna.

Ici on indique la fonction objectif et le nombre de test à effectuer :

study.optimize(objective, n_trials=100)

L’optimisation peut prendre du temps.

Une fois qu’elle est finie, je t’invite à récupérer les meilleurs hyperparamètres trouvés par Optuna :

best_params = study.best_params

Ensuite tu peux construire un modèle à partir de ces paramètres :

model = lgb.train(best_params, lgb_train, valid_sets=lgb_val)

Et utiliser ton modèle sur de nouvelles données :

y_pred = model.predict(X_test, num_iteration=model.best_iteration)

C’est tout pour cet article.

Bonne chance pour ton optimisation !🔥

Et n’oublies pas que d’autres méthodes existent si tu veux améliorer tes modèles :

• Normaliser tes données
• La Cross-Validation
• La Data Augmentation
• Les méthodes d’ensemble

À bientôt sur Inside Machine Learning 😉