Detaillierte Erläuterung der drei Methoden zum Parsen von Parametern in Python

Dieser Artikel vermittelt Ihnen relevantes Wissen über Python. Die erste Option ist die Verwendung von argparse, einem beliebten Python-Modul, das speziell für das Parsen von Befehlen verwendet wird Lesen Sie eine JSON-Datei, in der wir alle Hyperparameter platzieren können. Die dritte und weniger bekannte Methode ist die Verwendung einer YAML-Datei. Schauen wir sie uns an. Ich hoffe, sie ist für alle hilfreich.

【Verwandte Empfehlung: Python3-Video-Tutorial】

Der Hauptzweck dessen, was wir heute teilen, besteht darin, die Effizienz des Codes durch die Verwendung der Befehlszeile und Konfigurationsdateien in Python zu verbessern

Los geht's!

Wir verwenden maschinelles Lernen. Um den Parameteranpassungsprozess zu üben, stehen drei Möglichkeiten zur Auswahl. Die erste Möglichkeit besteht darin, argparse zu verwenden, ein beliebtes Python-Modul zum Parsen von Befehlszeilen. Die andere besteht darin, eine JSON-Datei zu lesen, in die wir alle Hyperparameter einfügen können. Die dritte Möglichkeit besteht darin, YAML-Dateien zu verwenden. Neugierig, fangen wir an!

Voraussetzungen

Im folgenden Code verwende ich Visual Studio Code, eine sehr effiziente integrierte Python-Entwicklungsumgebung. Das Schöne an diesem Tool ist, dass es jede Programmiersprache durch die Installation von Erweiterungen unterstützt, das Terminal integriert und die gleichzeitige Arbeit mit einer großen Anzahl von Python-Skripten und Jupyter-Notebooks

Datensätzen ermöglicht, indem es den Shared Bicycle Dataset auf Kaggle

verwendet argparse

Wie im Bild oben gezeigt, haben wir eine Standardstruktur zum Organisieren unseres kleinen Projekts:

• Ein Ordner mit dem Namen data, der unseren Datensatz enthält
• train.py-Datei
• zur Angabe der Hyperparameter-Optionen.py-Datei

Zuerst können wir eine Datei train.py erstellen, in der wir die grundlegende Vorgehensweise zum Importieren der Daten, zum Trainieren des Modells anhand der Trainingsdaten und zum Auswerten am Testsatz haben:

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)

Im Code haben wir auch die train_options importiert Funktion, die in der Datei „options.py“ enthalten ist. Bei der letztgenannten Datei handelt es sich um eine Python-Datei, aus der wir die in train.py berücksichtigten Hyperparameter ändern können:

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

In diesem Beispiel verwenden wir die argparse-Bibliothek, die beim Parsen von Befehlszeilenargumenten sehr beliebt ist. Zuerst initialisieren wir den Parser und können dann die Parameter hinzufügen, auf die wir zugreifen möchten.

Hier ist ein Beispiel für die Ausführung des Codes:

python train.py

Um die Standardwerte von Hyperparametern zu ändern, gibt es zwei Möglichkeiten. Die erste Möglichkeit besteht darin, in der Datei „options.py“ unterschiedliche Standardwerte festzulegen. Eine andere Möglichkeit besteht darin, den Hyperparameterwert über die Befehlszeile zu übergeben:

python train.py --n_estimators 200

Wir müssen den Namen des Hyperparameters, den wir ändern möchten, und den entsprechenden Wert angeben.

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

Verwendung von JSON-Dateien

Wie zuvor können wir eine ähnliche Dateistruktur beibehalten. In diesem Fall ersetzen wir die Datei „options.py“ durch eine JSON-Datei. Mit anderen Worten: Wir wollen die Werte der Hyperparameter in einer JSON-Datei angeben und sie an die train.py-Datei übergeben. JSON-Dateien können eine schnelle und intuitive Alternative zur argparse-Bibliothek sein und Schlüssel-Wert-Paare zum Speichern von Daten nutzen. Als Nächstes erstellen wir eine Datei „options.json“, die die Daten enthält, die wir später an anderen Code übergeben müssen.

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

Wie Sie oben sehen können, ist es einem Python-Wörterbuch sehr ähnlich. Aber im Gegensatz zu einem Wörterbuch enthält es Daten im Text-/String-Format. Darüber hinaus gibt es einige gängige Datentypen mit leicht unterschiedlicher Syntax. Boolesche Werte sind beispielsweise falsch/wahr, während Python Falsch/Wahr erkennt. Weitere mögliche Werte in JSON sind Arrays, die mittels eckiger Klammern als Python-Listen dargestellt werden.

Das Schöne an der Arbeit mit JSON-Daten in Python ist, dass sie über die Lademethode in ein Python-Wörterbuch konvertiert werden können:

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

Um auf ein bestimmtes Element zuzugreifen, müssen wir nur seinen Schlüsselnamen in eckigen Klammern angeben:

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)

Verwendung von YAML-Dateien

Die letzte Möglichkeit besteht darin, das Potenzial von YAML zu nutzen. Wie bei JSON-Dateien lesen wir die YAML-Datei im Python-Code als Wörterbuch, um auf die Werte der Hyperparameter zuzugreifen. YAML ist eine für Menschen lesbare Datendarstellungssprache, in der Hierarchien mithilfe von doppelten Leerzeichen anstelle von Klammern wie in JSON-Dateien dargestellt werden. Unten zeigen wir, was die Datei „options.yaml“ enthalten wird:

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

In train.py öffnen wir die Datei „options.yaml“, die immer mit der Load-Methode in ein Python-Wörterbuch konvertiert wird, dieses Mal aus der Yaml-Bibliothek importiert:

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

Wie zuvor können wir mithilfe der für ein Wörterbuch erforderlichen Syntax auf den Wert des Hyperparameters zugreifen.

Abschließende Gedanken

Profile lassen sich sehr schnell kompilieren, wohingegen argparse das Schreiben einer Codezeile für jedes Argument erfordert, das wir hinzufügen möchten.

Deshalb sollten wir je nach Situation die am besten geeignete Methode wählen.

Wenn wir beispielsweise Kommentare zu Parametern hinzufügen müssen, ist JSON nicht geeignet, da es keine Kommentare zulässt, während YAML und argparse möglicherweise sehr gut geeignet sind.

【Verwandte Empfehlungen: Python3-Video-Tutorial】

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der drei Methoden zum Parsen von Parametern in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!