Tiga cara untuk menghuraikan parameter dalam Python

Jom!

Kami menggunakan proses pelarasan parameter dalam pembelajaran mesin untuk berlatih. Pilihan pertama adalah menggunakan argparse, yang merupakan modul Python yang popular khusus untuk menghurai baris arahan yang lain adalah untuk membaca fail JSON di mana kita boleh meletakkan semua hyperparameters juga kurang diketahui Penyelesaiannya adalah dengan menggunakan fail YAML; Ingin tahu, mari mulakan!

Prasyarat

Dalam kod di bawah, saya akan menggunakan Kod Visual Studio, persekitaran pembangunan Python bersepadu yang sangat cekap. Keindahan alat ini ialah ia menyokong setiap bahasa pengaturcaraan dengan memasang sambungan, menyepadukan terminal dan membolehkan bekerja dengan sejumlah besar skrip Python dan buku nota Jupyter secara serentak.

• https://www.kaggle.com/datasets/lakshmi25npathi/bike-sharing-dataset

Gunakan argparse

Seperti yang ditunjukkan dalam gambar di atas, kami mempunyai struktur standard untuk mengatur projek kecil kami:

• Folder bernama data yang mengandungi dataset kami
• fail train.py
• fail options.py untuk menentukan hiperparameter

Pertama, kita boleh mencipta fail train.py di mana kita mempunyai data yang diimport, data latihan Prosedur asas untuk melatih model dan menilai pada set ujian:

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('datahour.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)

Dalam kod, kami turut mengimport fungsi train_options yang terkandung dalam fail options.py. Fail terakhir ialah fail Python yang daripadanya kita boleh menukar hiperparameter yang dipertimbangkan dalam 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

Dalam contoh ini, kami menggunakan perpustakaan argparse, yang sangat popular apabila menghuraikan argumen baris arahan. Mula-mula, kita memulakan penghurai, kemudian, kita boleh menambah parameter yang ingin kita akses.

Berikut ialah contoh kod berjalan:

python train.py

Untuk menukar nilai lalai hiperparameter, terdapat dua cara. Pilihan pertama ialah menetapkan nilai lalai yang berbeza dalam fail options.py. Pilihan lain ialah menghantar nilai hiperparameter daripada baris arahan:

python train.py --n_estimators 200

Kita perlu menentukan nama hiperparameter yang ingin kita ubah dan nilai yang sepadan.

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

Menggunakan fail JSON

Seperti sebelum ini, kami boleh menyimpan struktur fail yang serupa. Dalam kes ini, kami menggantikan fail options.py dengan fail JSON. Dalam erti kata lain, kami ingin menentukan nilai hiperparameter dalam fail JSON dan menghantarnya ke fail train.py. Fail JSON boleh menjadi alternatif yang pantas dan intuitif kepada perpustakaan argparse, memanfaatkan pasangan nilai kunci untuk menyimpan data. Seterusnya kami mencipta fail options.json yang mengandungi data yang perlu kami hantar ke kod lain kemudian.

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

Seperti yang anda lihat di atas, ia sangat serupa dengan kamus Python. Tetapi tidak seperti kamus, ia mengandungi data dalam format teks/rentetan. Selain itu, terdapat beberapa jenis data biasa dengan sintaks yang sedikit berbeza. Sebagai contoh, nilai Boolean adalah palsu/benar, manakala Python mengiktiraf False/True. Nilai lain yang mungkin dalam JSON ialah tatasusunan, yang diwakili sebagai senarai Python menggunakan kurungan segi empat sama.

Keindahan bekerja dengan data JSON dalam Python ialah ia boleh ditukar menjadi kamus Python melalui kaedah muat:

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

Untuk mengakses item tertentu, kita hanya perlu memetiknya dalam kurungan persegi Nama utama:

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)

Menggunakan fail YAML

Pilihan terakhir ialah memanfaatkan potensi YAML. Seperti fail JSON, kami membaca fail YAML dalam kod Python sebagai kamus untuk mengakses nilai hiperparameter. YAML ialah bahasa perwakilan data yang boleh dibaca manusia di mana hierarki diwakili menggunakan aksara ruang dua kali bukannya kurungan seperti dalam fail JSON. Di bawah ini kami menunjukkan apakah fail options.yaml akan mengandungi:

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

Dalam train.py, kami membuka fail options.yaml, yang akan sentiasa ditukar kepada kamus Python menggunakan kaedah muat, kali ini daripada perpustakaan yaml Diimport dalam:

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

Seperti sebelum ini, kita boleh mengakses nilai hiperparameter menggunakan sintaks yang diperlukan untuk kamus.

Fikiran Akhir

Fail konfigurasi disusun dengan sangat cepat, manakala argparse memerlukan menulis baris kod untuk setiap hujah yang ingin kami tambahkan.

Jadi kita harus memilih kaedah yang paling sesuai mengikut situasi kita yang berbeza

Sebagai contoh, jika kita perlu menambah ulasan pada parameter, JSON tidak sesuai kerana ia tidak membenarkan ulasan, dan YAML dan argparse mungkin sesuai.

Atas ialah kandungan terperinci Tiga cara untuk menghuraikan parameter dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!