Recherche de grille avec MLflow

Recherche De Grille Avec Mlflow



Les hyperparamètres des modèles d'apprentissage automatique sont optimisés à l'aide de l'approche de recherche par grille. Un utilisateur peut comparer rapidement plusieurs paramètres d'hyperparamètres et trouver ceux qui fonctionnent le mieux, car MLflow garde une trace des résultats des expériences de recherche sur grille. Dans MLflow, l'expérience de recherche sur grille peut être partagée rapidement avec d'autres membres de l'équipe. Grâce à MLflow, le modèle le plus efficace d'une expérience de recherche sur grille peut être déployé.

Avantages de la recherche par grille

  • Réglage automatisé des hyperparamètres : La recherche par grille automatise le réglage des hyperparamètres, ce qui permet une exploration systématique sans essais et erreurs manuels.
  • Reproductibilité : la recherche par grille garantit la validité des tests en obtenant de manière reproductible les résultats reproductibles, ce qui améliore la communication et la fiabilité.
  • Une recherche exhaustive: GS trouve efficacement les hyperparamètres optimaux pour un modèle en recherchant de manière exhaustive des combinaisons.
  • Robustesse : La recherche par grille est une technique robuste qui résiste au bruit des données, ce qui réduit le surajustement.
  • Simple à utiliser : La recherche par grille est simple à utiliser et à comprendre, ce qui en fait une méthode viable pour le réglage des hyperparamètres.
  • Comparaisons de modèles : la recherche par grille simplifie la comparaison des modèles et la sélection des mesures d'évaluation.

Inconvénients de la recherche par grille

  • Coût de calcul : La recherche de grille est coûteuse en calcul pour régler un grand nombre d'hyperparamètres.
  • Prend du temps: Les ajustements complexes des hyperparamètres prennent du temps.
  • Pas toujours nécessaire : C’est désormais toujours nécessaire ; la recherche aléatoire est la meilleure alternative.

Exemple : recherche des meilleurs paramètres de modèle pour le système d'admission à l'université

Examinons un exemple de recherche de grille pour le réglage des hyperparamètres dans le cadre d'un système d'admission universitaire en ligne. Dans cet exemple, nous utilisons scikit-learn et un simple classificateur GBC (Gradient Boosting Classifier) ​​pour prévoir la probabilité qu'un étudiant soit accepté dans une université en fonction de facteurs tels que les points GPA, les scores SAT, les scores ACT et les activités extrascolaires. Plusieurs options sont disponibles pour la recherche par grille au lieu de GBC, notamment la régression logistique (LR), SVM (Support Vector Machine), etc.

Générer des données aléatoires pour le système d'admission en ligne à l'aide de MLflow pour la recherche de grille

Les Pandas et les packages aléatoires de Python peuvent être utilisés pour créer un ensemble de données fictif pour le système d'admission. Avec des valeurs aléatoires pour les colonnes APP_NO, GPA, SAT Score, ACT Score, Extracurricular Activities et Admission Status, ce code génère un ensemble de données d'admission synthétique. La variable num_students contrôle le nombre de lignes présentes dans l'ensemble de données.







Le statut d'admission est défini de manière aléatoire sur la base d'un taux d'acceptation de 70 %, et le module aléatoire est utilisé pour produire des valeurs aléatoires pour plusieurs colonnes. À des fins de démonstration, le morceau de code suivant crée un faux ensemble de données d'admission avec des valeurs aléatoires et est enregistré dans le fichier std_admission_dataset.csv :



Extrait de code:



# Importez les bibliothèques Panda et Random
importer des pandas en tant que panda_obj
importer aléatoirement en tant que random_obj

# Définissez le nombre d'enregistrements que l'ensemble de données sur les étudiants doit générer
étudiants_records = 1000

# Créer des listes pour stocker des données
std_application_numbers = [ 'APP-' + str(random_obj.randint( 1000 , 9999 )) pour _ dans la plage (students_records)]
std_gpa = [rond(random_obj.uniform( 2.5 , 4.0 ), 2 ) pour _ dans la plage (students_records)]
std_sat_scores = [random_obj.randint( 900 , 1600 ) pour _ dans la plage (students_records)]
std_act_scores = [random_obj.randint( vingt , 36 ) pour _ dans la plage (students_records)]
std_extra_curriculars = [random_obj.choice([ 'Oui' , 'Non' ]) pour _ dans la plage (students_records)]

# Calculer le statut d'admission en fonction du taux d'acceptation aléatoire
std_admission_status = [ 1 si random_obj.random() < 0,7 autre 0 pour _ dans la plage (students_records)]

# Créez un dictionnaire pour contenir les données des étudiants
données_std = {

'APPLICATION_NON' : std_application_numbers,

'GPA' : std_gpa,

'SAT_Score' : std_sat_scores,

'ACT_Score' : std_act_scores,

'Activités extra-scolaires' : std_extra_curriculaires,

'Statut_d'admission' : std_admission_status

}

# Créer un DataFrame DataFrame_Student à partir du dictionnaire
DataFrame_Student = panda_obj.DataFrame (std_data)

# Enregistrez le DataFrame DataFrame_Student dans un fichier CSV nommé std_admission_dataset.csv
DataFrame_Student.to_csv( 'std_admission_dataset.csv' , indice=Faux)
imprimer( « Exportation réussie des données des étudiants vers un fichier CSV ! » )

Exécution du code :

Utilisez la commande Python pour compiler le code, puis utilisez la commande pip pour installer un module spécifique si vous rencontrez une erreur de module. Utilisez la commande pip3 install pour installer la bibliothèque donnée si Python est la version 3.X ou supérieure.





Exécution réussie :



Exemple de capture d'écran de données :

Étape 1 : Importer les bibliothèques

  • La bibliothèque MLflow pour le suivi des expériences d'apprentissage automatique
  • La bibliothèque Pandas pour gérer le traitement et l'analyse des données, ainsi que le package mlflow.sklearn pour intégrer les modèles Scikit-Learn
  • La quatrième ligne importe la bibliothèque « avertissements » pour supprimer les erreurs
  • La classe ParameterGrid pour la recherche de grille dans le module sklearn.model_selection
  • GridSearchCV et GradientBoostingClassifier de sklearn.model_selection et ensemble, respectivement, pour les modèles de classificateur de recherche de grille et d'amélioration de gradient
  • Les fonctions precision_score et classification_report du module sklearn.metrics pour calculer la précision du modèle et générer des rapports de classification
  • Le code importe le module du système d'exploitation et définit la variable d'environnement GIT_PYTHON_REFRESH sur quiet.

Extrait de code:

# Étape I Importer les bibliothèques requises
importer mlflow
importer mlflow.sklearn
importer les avertissements en tant qu'avertissement
importer des pandas en tant que panda_obj
à partir de sklearn.model_selection importer train_test_split en tant que tts, ParameterGrid en tant que pg, GridSearchCV en tant que gscv
importez-nous
à partir de sklearn.ensemble, importez GradientBoostingClassifier en tant que GBC
à partir de sklearn.metrics, importez précision_score en tant qu'acs, classification_report en tant que cr
os.environ[ 'GIT_PYTHON_REFRESH' ] = 'calme'

Étape 2 : Définir l'URI de suivi

L'URI de suivi du serveur MLflow est défini à l'aide de la fonction mlflow.set_tracking_uri(), garantissant une machine locale sur le port 5000 pour les expériences et les modèles.

mlflow.set_tracking_uri( 'http://localhost:5000' )

Étape 3 : Charger et préparer l'ensemble de données d'admission

Importez la bibliothèque Pandas en tant que panda_obj pour la manipulation et l'analyse des données. La fonction read_csv() est appliquée pour charger l'ensemble de données d'admission. Le chemin d'accès à l'ensemble de données est le seul argument requis par la fonction read_csv(). Le chemin d'accès à l'ensemble de données dans cette instance est std_admission_dataset.csv. En utilisant la fonction read_csv(), l'ensemble de données est chargé dans un Pandas DataFrame.

La colonne Admission_Status du DataFrame std_admissions_data est d'abord supprimée par le code. Puisque cette colonne contient la variable cible, le prétraitement n'est pas nécessaire.

Ensuite, le code crée deux nouvelles variables : « F » et « t ». Les caractéristiques sont contenues dans la variable « F », tandis que la variable cible est contenue dans la variable « t ».

Les données sont ensuite distribuées dans des ensembles de tests et de formation. Ceci est accompli en utilisant la fonction tts() du package sklearn.model_selection. Les fonctionnalités, la variable cible, la taille du test et l'état aléatoire sont les quatre arguments requis par la fonction tts(). Le paramètre test_size stipule la partie des données utilisée à des fins de test. Étant donné que la taille du test dans ce cas est définie sur 0,2, 20 % des données seront utilisées pour le test.

L'option random_state spécifie la graine du générateur de nombres aléatoires. Ceci est fait pour garantir que les données sont séparées de manière aléatoire. Les ensembles de formation et de test sont désormais stockés dans les variables F_training, F_testing, t_training et t_testing. Ces ensembles peuvent être utilisés pour évaluer et entraîner les modèles d'apprentissage automatique.

Extrait de code:

# Étape 3 : Charger l'ensemble de données d'admission
std_admissions_data = panda_obj.read_csv( 'std_admission_dataset.csv' )

# Prétraiter les données et les diviser en fonctionnalités (F) et cible (t)
F = std_admissions_data.drop([ 'Statut_d'admission' ], axe= 1 )
t = std_admissions_data[ 'Statut_d'admission' ]

# Convertir les variables catégorielles en variables numériques à l'aide d'un encodage à chaud
F = panda_obj.get_dummies(F)
F_training, F_testing, t_training, t_testing = tts(F, t, test_size= 0,2 , état_aléatoire = 42 )

Étape 4 : définir le nom de l'expérience MLflow

adm_experiment_name = 'Expérience_d'admission_universitaire'
mlflow.set_experiment(adm_experiment_name)

Étape 5 : Définir le classificateur d’amplification de dégradé

Le modèle de classificateur d'amplification de gradient est désormais stocké dans la variable gbc_obj. L'ensemble de données d'admission peut être utilisé pour tester et entraîner ce modèle. La valeur de l'argument random_state est 42. Cela garantit que le modèle est formé en utilisant exactement la même graine de générateur de nombres aléatoires, ce qui rend les résultats reproductibles.

gbc_obj = GBC(état_random= 42 )

Étape 6 : Définir la grille d’hyperparamètres

Le code crée initialement le dictionnaire param_grid. Les hyperparamètres ajustés via la recherche par grille sont contenus dans ce dictionnaire. Trois clés composent le dictionnaire param_grid : n_estimators, learning_rate et max_degree. Ce sont les hyperparamètres du modèle de classificateur augmentant le gradient. Le nombre d'arbres dans le modèle est spécifié par l'hyperparamètre n_estimators. Le taux d'apprentissage du modèle est spécifié via l'hyperparamètre learning_rate. L'hyperparamètre max_degree définit la profondeur la plus élevée possible des arbres du modèle.

Extrait de code:

param_grid = {

'n_estimateurs' :[ 100 , 150 , 200 ],

'taux d'apprentissage' :[ 0,01 , 0,1 , 0,2 ],

'profondeur max' :[ 4 , 5 , 6 ]

}

Étape 7 : Effectuer la recherche de grille avec le suivi MLflow

Le code parcourt ensuite le dictionnaire param_grid. Pour chaque ensemble d'hyperparamètres du dictionnaire, le code effectue les opérations suivantes :

  • Démarre une nouvelle exécution MLflow
  • Convertit les hyperparamètres en liste s'ils ne sont pas déjà une liste
  • Enregistre les hyperparamètres dans MLflow
  • Entraîne un modèle de recherche de grille avec les hyperparamètres spécifiés
  • Obtient le meilleur modèle de la recherche par grille
  • Fait des prédictions sur les données de test en utilisant le meilleur modèle
  • Calcule la précision du modèle
  • Imprime le rapport sur les hyperparamètres, la précision et la classification
  • Enregistre la précision et le modèle dans MLflow

Extrait de code:

avec warn.catch_warnings() :
warn.filterwarnings( 'ignorer' , catégorie=UserWarning, module= '.*distutil.*' )
pour les paramètres dans pg(param_grid) :
avec mlflow.start_run(run_name= 'Exécution Admissions_Statut' ) :
# Convertir des valeurs uniques en listes
params = {clé : [valeur] sinon isinstance (valeur, liste) sinon valeur pour la clé, valeur dans params.items()}
mlflow.log_params(params)
grille_search = gscv(gbc_obj, param_grid=params, cv= 5 )
grille_search.fit (F_training, t_training)
std_best_model = grille_search.best_estimator_
model_predictions = std_best_model.predict (F_testing)
model_accuracy_score = acs(t_testing, model_predictions)
imprimer( 'Hyperparamètres :' , paramètres)
imprimer( 'Précision:' , model_accuracy_score)
# Ignorer explicitement le UndefinedMetricWarning
avec warn.catch_warnings() :
warn.filterwarnings( 'ignorer' , catégorie=Avertissement)
imprimer( « Rapport de classement : » )
print(cr(t_testing, model_predictions, zero_division= 1 ))
mlflow.log_metric( 'précision' , model_accuracy_score)
mlflow.sklearn.log_model(std_best_model, 'gb_classifier_model' )

Étape 8 : Exécuter le programme à l’aide de Python

Voici le résultat sur le serveur MLflow :

Conclusion

L'outil de recherche de grille de MLflow automatise le réglage, le suivi des résultats et la modification des hyperparamètres dans les modèles d'apprentissage automatique. Il aide à déterminer les hyperparamètres idéaux et garantit des résultats fiables, mais peut être coûteux en termes de calcul pour des expériences approfondies sur les hyperparamètres.