Explication détaillée de trois méthodes d'analyse des paramètres en Python

Cet article vous apporte des connaissances pertinentes sur Python. Il organise principalement les problèmes liés à trois méthodes d'analyse des paramètres. La première option consiste à utiliser argparse, qui est un module Python populaire spécifiquement utilisé pour l'analyse de lignes de commandes. lisez un fichier JSON, où nous pouvons placer tous les hyperparamètres ; la troisième méthode, la moins connue, consiste à utiliser un fichier YAML, jetons-y un coup d'œil, j'espère que cela sera utile à tout le monde.

【Recommandation associée : Tutoriel vidéo Python3】

L'objectif principal de ce que nous partageons aujourd'hui est d'améliorer l'efficacité du code en utilisant la ligne de commande et les fichiers de configuration en Python

C'est parti !

Nous utilisons l'apprentissage automatique Pour pratiquer le processus de réglage des paramètres, vous avez le choix entre trois façons. La première option est d'utiliser argparse, qui est un module Python populaire dédié à l'analyse en ligne de commande ; l'autre est de lire un fichier JSON où l'on peut mettre tous les hyperparamètres ; la troisième est également moins connue. La solution est d'utiliser des fichiers YAML ! Curieux, commençons !

Prérequis

Dans le code ci-dessous, j'utiliserai Visual Studio Code, un environnement de développement Python intégré très efficace. La beauté de cet outil est qu'il prend en charge tous les langages de programmation en installant des extensions, intègre le terminal et permet de travailler avec un grand nombre de scripts Python et de notebooks Jupyter

ensembles de données en même temps, en utilisant l'ensemble de données Shared Bicycle sur Kaggle

en utilisant argparse

Comme le montre l'image ci-dessus, nous avons une structure standard pour organiser notre petit projet :

• Un dossier nommé data qui contient notre ensemble de données
• fichier train.py
• pour spécifier les hyperparamètres, fichier options.py

Tout d'abord, nous pouvons créer un fichier train.py dans lequel nous avons la procédure de base pour importer les données, entraîner le modèle sur les données d'entraînement et l'évaluer sur l'ensemble de test :

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error

from options import train_options

df = pd.read_csv('data\hour.csv')
print(df.head())
opt = train_options()

X=df.drop(['instant','dteday','atemp','casual','registered','cnt'],axis=1).values
y =df['cnt'].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

if opt.normalize == True:
    scaler = StandardScaler()
    X = scaler.fit_transform(X)
    
rf = RandomForestRegressor(n_estimators=opt.n_estimators,max_features=opt.max_features,max_depth=opt.max_depth)
model = rf.fit(X_train,y_train)
y_pred = model.predict(X_test)
rmse = np.sqrt(mean_squared_error(y_pred, y_test))
mae = mean_absolute_error(y_pred, y_test)
print("rmse: ",rmse)
print("mae: ",mae)

Dans le code, nous avons également importé la fonction train_options contenu dans le fichier options.py. Ce dernier fichier est un fichier Python à partir duquel on peut modifier les hyperparamètres considérés dans train.py :

import argparse

def train_options():
    parser = argparse.ArgumentParser()
    parser.add_argument("--normalize", default=True, type=bool, help='maximum depth')
    parser.add_argument("--n_estimators", default=100, type=int, help='number of estimators')
    parser.add_argument("--max_features", default=6, type=int, help='maximum of features',)
    parser.add_argument("--max_depth", default=5, type=int,help='maximum depth')
    opt = parser.parse_args()
    return opt

Dans cet exemple, nous utilisons la bibliothèque argparse, très populaire lors de l'analyse des arguments de ligne de commande. Tout d’abord, nous initialisons l’analyseur, puis nous pouvons ajouter les paramètres auxquels nous souhaitons accéder.

Voici un exemple d'exécution de code :

python train.py

Pour modifier les valeurs par défaut des hyperparamètres, il existe deux manières. La première option consiste à définir différentes valeurs par défaut dans le fichier options.py. Une autre option consiste à transmettre la valeur de l'hyperparamètre depuis la ligne de commande :

python train.py --n_estimators 200

Nous devons spécifier le nom de l'hyperparamètre que nous voulons modifier et la valeur correspondante.

python train.py --n_estimators 200 --max_depth 7

Utilisation de fichiers JSON

Comme auparavant, nous pouvons conserver une structure de fichiers similaire. Dans ce cas, nous remplaçons le fichier options.py par un fichier JSON. Autrement dit, nous souhaitons préciser les valeurs des hyperparamètres dans un fichier JSON et les transmettre au fichier train.py. Les fichiers JSON peuvent constituer une alternative rapide et intuitive à la bibliothèque argparse, exploitant les paires clé-valeur pour stocker les données. Ensuite, nous créons un fichier options.json qui contient les données que nous devons transmettre ultérieurement à un autre code.

{
"normalize":true,
"n_estimators":100,
"max_features":6,
"max_depth":5 
}

Comme vous pouvez le voir ci-dessus, il ressemble beaucoup à un dictionnaire Python. Mais contrairement à un dictionnaire, il contient des données au format texte/chaîne. De plus, il existe certains types de données courants avec une syntaxe légèrement différente. Par exemple, les valeurs booléennes sont faux/vrai, alors que Python reconnaît Faux/Vrai. D'autres valeurs possibles dans JSON sont les tableaux, qui sont représentés sous forme de listes Python à l'aide de crochets.

La beauté de travailler avec des données JSON en Python est qu'elles peuvent être converties en dictionnaire Python via la méthode de chargement :

f = open("options.json", "rb")
parameters = json.load(f)

Pour accéder à un élément spécifique, il suffit de citer son nom de clé entre crochets :

if parameters["normalize"] == True:
    scaler = StandardScaler()
    X = scaler.fit_transform(X)
rf=RandomForestRegressor(n_estimators=parameters["n_estimators"],max_features=parameters["max_features"],max_depth=parameters["max_depth"],random_state=42)
model = rf.fit(X_train,y_train)
y_pred = model.predict(X_test)

Utiliser les fichiers YAML

La dernière option est de profiter du potentiel de YAML. Comme pour les fichiers JSON, on lit le fichier YAML en code Python comme un dictionnaire pour accéder aux valeurs des hyperparamètres. YAML est un langage de représentation de données lisible par l'homme dans lequel les hiérarchies sont représentées à l'aide de caractères à double espace au lieu de parenthèses comme dans les fichiers JSON. Ci-dessous, nous montrons ce que contiendra le fichier options.yaml :

normalize: True 
n_estimators: 100
max_features: 6
max_depth: 5

Dans train.py, nous ouvrons le fichier options.yaml, qui sera toujours converti en dictionnaire Python à l'aide de la méthode de chargement, cette fois importé de la bibliothèque yaml :

import yaml
f = open('options.yaml','rb')
parameters = yaml.load(f, Loader=yaml.FullLoader)

Comme précédemment, nous pouvons accéder à la valeur de l'hyperparamètre en utilisant la syntaxe requise pour un dictionnaire.

Réflexions finales

Les profils se compilent très rapidement, alors que argparse nécessite d'écrire une ligne de code pour chaque argument que nous voulons ajouter.

Nous devons donc choisir la manière la plus appropriée en fonction de nos différentes situations

Par exemple, si nous devons ajouter des commentaires aux paramètres, JSON ne convient pas car il n'autorise pas les commentaires, tandis que YAML et argparse peuvent être très adaptés.

【Recommandation associée : Tutoriel vidéo Python3】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!