วิธีตั้งค่าและบันทึกการทดลองแมชชีนเลิร์นนิงบนเซิร์ฟเวอร์ติดตาม MLFlow ระยะไกลด้วย Azure Machine Learning

1. บทนำ

เวิร์กโฟลว์แมชชีนเลิร์นนิงทั่วไปเกี่ยวข้องกับขั้นตอนต่างๆ เช่น การประมวลผลข้อมูลล่วงหน้า การปรับไฮเปอร์พารามิเตอร์ และการประเมินโมเดล นักวิทยาศาสตร์ข้อมูลอาจจำเป็นต้องทดลองโดยใช้ไฮเปอร์พารามิเตอร์ อัลกอริธึมแบบจำลอง และขั้นตอนก่อนการประมวลผลร่วมกัน เพื่อให้ได้ผลลัพธ์ที่ต้องการ การบันทึกไฮเปอร์พารามิเตอร์ อัลกอริธึมโมเดล ผลลัพธ์ และสิ่งประดิษฐ์ของโมเดลเป็นสิ่งสำคัญเพื่อให้แน่ใจว่าการทดลองแมชชีนเลิร์นนิงสามารถทำซ้ำได้ งานที่น่ากังวลนี้สามารถทำให้ง่ายขึ้นด้วยเครื่องมือ MLOps เช่น MLFlow

MLFlow[1] เป็นแพลตฟอร์มโอเพ่นซอร์สสำหรับจัดการวงจรการใช้งาน ML รวมถึงการทดลอง การทำซ้ำ การปรับใช้ และการลงทะเบียนโมเดลส่วนกลาง MLFlow มี 4 องค์ประกอบที่แตกต่างกัน:

  1. การติดตาม MLFlow: บันทึกและสืบค้นการทดลอง: โค้ด ข้อมูล การกำหนดค่า และผลลัพธ์
  2. โปรเจ็กต์ MLFlow: จัดแพ็กเกจโค้ดวิทยาศาสตร์ข้อมูลในรูปแบบเพื่อทำซ้ำการทำงานบนแพลตฟอร์มใดก็ได้
  3. โมเดล MLFlow: ปรับใช้โมเดลการเรียนรู้ของเครื่องในสภาพแวดล้อมการให้บริการที่หลากหลาย
  4. Model Registry: จัดเก็บ ใส่คำอธิบายประกอบ ค้นหา และจัดการโมเดลในพื้นที่เก็บข้อมูลส่วนกลาง

เราสามารถโฮสต์เซิร์ฟเวอร์การติดตาม MLFlow บนเครื่องเสมือนบนคลาวด์ เช่น AWS EC2 หรือ Azure VM อย่างไรก็ตามขั้นตอนการตั้งค่าเซิร์ฟเวอร์และที่เก็บสิ่งประดิษฐ์อาจเป็นเรื่องที่น่าเบื่อ อีกทางเลือกหนึ่งคือใช้โซลูชัน MLFlow ที่มีการจัดการ เช่น Azure Machine Learning

Azure Machine Learning เป็นส่วนหนึ่งของแพลตฟอร์มการประมวลผลบนคลาวด์ Azure ของ Microsoft ซึ่งช่วยให้นักวิทยาศาสตร์ข้อมูลและวิศวกรจัดการเวิร์กโฟลว์การเรียนรู้ของเครื่อง[2] พื้นที่ทำงาน Azure Machine Learning ทุกแห่งมาพร้อมกับเซิร์ฟเวอร์ MLFlow ที่กำหนดค่าไว้ล่วงหน้า เราจะใช้คุณสมบัติการติดตาม MLFlow เพื่อบันทึกพารามิเตอร์ ผลลัพธ์ และสิ่งประดิษฐ์จากการทดลองการเรียนรู้ของเครื่องของเราลงในเซิร์ฟเวอร์ MLFLow ที่โฮสต์โดยบริการ Azure Machine Learning

ในบทความนี้ เราจะแสดงวิธีการ

  1. ตั้งค่าเซิร์ฟเวอร์การติดตาม MLFlow ระยะไกลบน Azure Machine Learning
  2. ฝึกอบรมโมเดลในพื้นที่โดยใช้ scikit-learn
  3. บันทึกพารามิเตอร์โมเดลภายในเครื่อง ผลลัพธ์ และส่วนต่างๆ ลงในเซิร์ฟเวอร์การติดตาม MLFlow ระยะไกล
  4. ดึงโมเดลที่ได้รับการฝึกอบรมจากเซิร์ฟเวอร์ติดตาม MLFlow สำหรับการให้คะแนนแบบแบตช์ออฟไลน์

2. ตั้งค่า

ในส่วนนี้ เราจะดูวิธีตั้งค่าบริการ Azure และสภาพแวดล้อมการฝึกโมเดล

2.1. สร้างบัญชี Azure

เซิร์ฟเวอร์การติดตามจะโฮสต์อยู่บน Azure Machine Learning และด้วยเหตุนี้ เราจึงจำเป็นต้องมี "บัญชี Azure" บัญชีใหม่จะได้รับเครดิต Azure มูลค่า $200 ใน 30 วันแรกและฟรี 12 เดือนสำหรับบริการที่เลือก

2.2. ตั้งค่าพื้นที่ทำงาน Azure ML

1. สร้างกลุ่มทรัพยากร

กลุ่มทรัพยากรคือคอนเทนเนอร์ที่เก็บทรัพยากรที่เกี่ยวข้องสำหรับโซลูชัน Azure[3]

  • ไปที่ https://portal.azure.com/
  • ค้นหา “กลุ่มทรัพยากร” ใต้ Azure Services หรือผ่านแถบค้นหา

  • สร้างกลุ่มทรัพยากรใหม่

  • กรอกรายละเอียด เช่น การสมัครสมาชิก ชื่อกลุ่มทรัพยากร และภูมิภาค

<แข็งแกร่ง>2. สร้างพื้นที่ทำงาน Azure ML

พื้นที่ทำงานเป็นทรัพยากรระดับบนสุดสำหรับ Azure Machine Learning ซึ่งเป็นสถานที่รวมศูนย์ในการทำงานกับสิ่งประดิษฐ์ทั้งหมดที่คุณสร้างขึ้นเมื่อคุณใช้ Azure Machine Learning พื้นที่ทำงานจะเก็บประวัติของการฝึกซ้อมทั้งหมด รวมถึงบันทึก ตัวชี้วัด เอาท์พุต และสแน็ปช็อตของสคริปต์ของคุณ คุณใช้ข้อมูลนี้เพื่อพิจารณาว่าการฝึกซ้อมวิ่งใดทำให้เกิดโมเดลที่ดีที่สุด[4]

  • ค้นหา “การเรียนรู้ของเครื่อง” ภายใต้ Azure Services หรือผ่านแถบค้นหา

  • คลิกที่สร้าง

  • เติมในช่องว่าง. กลุ่มทรัพยากรคือกลุ่มที่เราสร้างขึ้นในขั้นตอนก่อนหน้า

  • เซิร์ฟเวอร์การติดตาม MLFlow จะถูกสร้างขึ้นโดยอัตโนมัติโดยเป็นส่วนหนึ่งของพื้นที่ทำงาน Azure ML

2.3. ตั้งค่าสภาพแวดล้อมการฝึกอบรม

เราจะใช้สภาพแวดล้อมการฝึกอบรมในพื้นที่ (เช่น บนพีซีหรือแล็ปท็อปของคุณ)

ไอดี

ฉันใช้ Jupyter Notebook ใน Visual Studio Code คุณสามารถใช้ IDE ใด ๆ ก็ได้

สภาพแวดล้อมคอนดา

ตรวจสอบให้แน่ใจว่าติดตั้ง miniconda3 บนเครื่องของคุณแล้ว สร้างสภาพแวดล้อม conda python 3.7 จากอินเทอร์เฟซบรรทัดคำสั่งของคุณ ชื่อสภาพแวดล้อมเป็นชื่อที่กำหนดเอง ฉันตั้งชื่อเป็น general

#command line
conda create -n general python=3.7

เปิดใช้งานสภาพแวดล้อม conda เราจะทำงานพัฒนาทั้งหมดของเราในสภาพแวดล้อมนี้

#command line
conda activate general

แพ็คเกจ Python

ตรวจสอบให้แน่ใจว่าได้ติดตั้งแพ็คเกจต่อไปนี้ในสภาพแวดล้อม Conda

azureml-core
azureml-mlflow
pandas
numpy
scikit-learn
mlflow

การกำหนดค่าพื้นที่ทำงาน Azure Machine Learning

ดาวน์โหลดการกำหนดค่าพื้นที่ทำงาน Azure Machine Learning

ไฟล์กำหนดค่าอยู่ในรูปแบบ JSON และมีข้อมูลต่อไปนี้:

# config.json
{
    "subscription_id": "your-subscription-id",
    "resource_group": "your-resource-group-name",
    "workspace_name": "your-workspace-name"
}

เราจะต้องใช้ข้อมูลนี้เพื่อเชื่อมต่อกับพื้นที่ทำงาน AML สำหรับการบันทึกการทดลอง

โครงสร้างโครงการ

ด้านล่างนี้คือไดเร็กทอรีในเครื่องสำหรับโปรเจ็กต์ปัจจุบัน

  • train.ipynb: มีการประมวลผลข้อมูลและรหัสการฝึกอบรม
  • inference.ipynb: มีรหัสการให้คะแนนแบบแบตช์ออฟไลน์
  • config.json: การกำหนดค่าพื้นที่ทำงาน Azure ML

3. train.ipynb

นำเข้าแพ็คเกจ

import mlflow
from azureml.core import Workspace
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer
from sklearn.impute import SimpleImputer

ตั้งค่าพื้นที่ทำงาน

ws = Workspace.from_config()

หลังจากเรียกใช้เซลล์นี้ คุณอาจได้รับ URL เพื่อดำเนินการตรวจสอบสิทธิ์เว็บ นี่เป็นสิ่งจำเป็นสำหรับการเชื่อมต่อกับพื้นที่ทำงาน Azure Machine Learning เมื่อเสร็จแล้วคุณสามารถกลับไปที่ IDE และดำเนินการขั้นตอนต่อไปได้

ตั้งค่า URI การติดตาม

URI การติดตาม MLFlow คือที่อยู่ที่เราสามารถค้นหาเซิร์ฟเวอร์การติดตาม MLFlow เราตั้งค่า URI การติดตามเพื่อให้ MLFlow ทราบว่าจะบันทึกการทดลองที่ไหนด้วย

mlflow.set_tracking_uri(ws.get_mlflow_tracking_uri())

URI การติดตามมีรูปแบบ

azureml://<region>.api.azureml.ms/mlflow/v1.0/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<aml-workspace>?

คุณยังสามารถค้นหา URI การติดตามเดียวกันได้ในพื้นที่ทำงาน Azure Machine Learning

ตั้งค่าการทดสอบ MLFlow

รหัสด้านล่างกำหนดชื่อของการทดสอบ MLFlow การทดลอง MLFlow เป็นวิธีหนึ่งในการจัดการการทดสอบต่างๆ การทดสอบประกอบด้วยการรันหลายครั้ง โดยแต่ละครั้งการรันเป็นการดำเนินการตามโค้ดการฝึกของคุณ เราสามารถกำหนดพารามิเตอร์ ผลลัพธ์ และส่วนต่างๆ ที่จะจัดเก็บไว้สำหรับการรันแต่ละครั้ง หากไม่มีชื่อการทดสอบ จะมีการสร้างการทดสอบใหม่ มิฉะนั้นจะบันทึกการเรียกใช้ลงในการทดสอบที่มีอยู่โดยใช้ชื่อเดียวกัน

experiment_name = 'diabetes'
mlflow.set_experiment(experiment_name)

การประมวลผลข้อมูลล่วงหน้า

มาโหลดข้อมูลและทำการแยกการทดสอบรถไฟกัน

input_path = 'path/to/data.csv'
df = pd.read_csv(input_path, sep = ',')
y = df.pop('Outcome')
X = df
X_train, X_test, y_train, y_test = train_test_split(X, y)

เราสร้าง scikit-learn FunctionTransformer เพื่อค้นหาค่า “0” ในคอลัมน์ที่เลือกและแทนที่ด้วย “NaN”

def replace_zeros(x):
		
		x = x.copy()
    x[['Glucose','BloodPressure','SkinThickness','Insulin','BMI']] = x[['Glucose','BloodPressure','SkinThickness','Insulin','BMI']].replace(0,np.NaN)
    return x
ft_replace_zeros = FunctionTransformer(replace_zeros)

สร้างไปป์ไลน์ scikit-learn

rf_clf = RandomForestClassifier()
num_imputer = SimpleImputer()
pipe = Pipeline([('replace_zeros', ft_replace_zeros), ('fillna', num_imputer), ('clf', rf_clf)])

ขั้นตอนเหล่านี้คือขั้นตอนในไปป์ไลน์ scikit-Learn:

  • replace_zeros: แทนที่ค่า “0” ทั้งหมดด้วยค่า “NaN” โดยใช้ UDF และ scikit-learn's FunctionTransformer
  • fillna: เติมค่าที่หายไปด้วยค่าเฉลี่ยของคอลัมน์โดยใช้ scikit-learn's SimpleImputer
  • clf: ตัวแยกประเภทฟอเรสต์แบบสุ่ม

การปรับไฮเปอร์พารามิเตอร์

mlflow.sklearn.autolog(max_tuning_runs=None)
param_grid = {'clf__n_estimators': [1,2,3], 'clf__max_depth':[2,3,4]}
clf = GridSearchCV(pipe, param_grid = param_grid, scoring = ['roc_auc', 'precision', 'recall', 'f1', 'accuracy'], refit = 'roc_auc')
clf.fit(X_train, y_train)

รหัสข้างต้นทำสิ่งต่อไปนี้:

  1. การทดลองบันทึก: การเรียก mlflow.sklearn.autolog() ก่อนโค้ดการฝึกจะทำให้สามารถบันทึกพารามิเตอร์ เมตริก และโมเดลได้โดยอัตโนมัติ MLFlow มอบ autolog ให้กับเฟรมเวิร์กแมชชีนเลิร์นนิงยอดนิยม เช่น scikit-learn, TensorFlow, XGBoost เป็นต้น
  2. สร้างตารางพารามิเตอร์ param_grid ด้วยพารามิเตอร์ที่เราต้องการทดลองด้วย
  3. ดำเนินการ GridSearchCV เพื่อค้นหาพารามิเตอร์ที่เหมาะสมที่สุด การรวมกันของไฮเปอร์พารามิเตอร์ที่กำหนดใน param_grid แต่ละค่าจะถูกใช้สำหรับการตรวจสอบข้าม ผลลัพธ์ เมตริก และอาร์ติแฟกต์จะถูกบันทึกลงใน MLFlow

เราสามารถดูผลลัพธ์ของการรันบนพื้นที่ทำงาน Azure Machine Learning (https://ml.azure.com/) → การทดลอง การบันทึกอัตโนมัติ GridsearchCV สร้างการรันพาเรนต์ด้วยการรันลูกที่ซ้อนกัน ไฮเปอร์พารามิเตอร์แต่ละชุดจะถูกบันทึกไว้ในการรันลูกที่แยกจากกัน

รายละเอียดการรันลูกสามารถดูได้ในพาเรนต์รัน

พารามิเตอร์ ผลลัพธ์ และแบบจำลองของการรันรองที่ดีที่สุดจะถูกบันทึกไว้ภายใต้การรันพาเรนต์ด้วย รูปภาพด้านล่างแสดงไฟล์โมเดลจาก Best Child Run run_id ที่ขีดเส้นใต้ด้วยสีแดงคือตัวระบุเฉพาะสำหรับการรันซึ่งสร้างตัวประมาณค่าที่ดีที่สุด

4. inference.ipynb

ส่วนนี้แสดงวิธีการโหลดแบบจำลองจาก Azure Machine Learning MLFlow Experiment โดยอิงจาก run_id และใช้แบบจำลองสำหรับการให้คะแนนแบบแบตช์ออฟไลน์ การให้คะแนนจะดำเนินการบนคอมพิวเตอร์ในเครื่อง (เช่น พีซีหรือแล็ปท็อป) ส่วนนี้ถือว่าสภาพแวดล้อมการอนุมานมีการขึ้นต่อกันเหมือนกับสภาพแวดล้อมการฝึกอบรม

นำเข้าไลบรารี

import mlflow
from azureml.core import Workspace
import pandas as pd

กำหนดค่าพื้นที่ทำงาน Azure ML และ MLFlow

ws = Workspace.from_config()
mlflow.set_tracking_uri(ws.get_mlflow_tracking_uri())

โหลดโมเดล

โมเดลสามารถดึงข้อมูลจาก MLFlow ได้โดยใช้ therun_id

run_id = '15059f88-d2a8-4c7e-966a-e0a755c97a6e'
model = mlflow.sklearn.load_model(f'runs:/{run_id}/best_estimator', './')

พารามิเตอร์สำหรับ mlflow.sklearn.load_model() คือ:

  • model_uri: ตำแหน่งในรูปแบบ URI ของโมเดล MLflow เส้นทางไปยังโมเดลมีรูปแบบ runs:/<mlflow_run_id>/run-relative/path/to/model
  • dst_path – เส้นทางของระบบไฟล์ในเครื่องสำหรับดาวน์โหลดแบบจำลอง ไดเร็กทอรีนี้ต้องมีอยู่แล้ว หากไม่ได้ระบุ เส้นทางเอาต์พุตในเครื่องจะถูกสร้างขึ้น

เมื่อเราดำเนินการ mlflow.sklearn.load_model() โฟลเดอร์ best_estimator ที่มี model.pkl และไฟล์อ้างอิง เช่น conda.yaml, requirements.txt และ MLmodel จะถูกดาวน์โหลดไปยังไดเรกทอรีภายในเครื่องที่กำหนดไว้ใน dst_path

โมเดลที่โหลด (model.pkl) เป็นออบเจ็กต์ไปป์ไลน์ scikit-learn ที่ติดตั้งไว้ นี่เป็นไปป์ไลน์เดียวกับที่เราสร้างขึ้นในขั้นตอนการฝึกอบรม

Pipeline(steps=[('replace_zeros',
                 FunctionTransformer(func=<function replace_zeros at 0x000001EBEF3F0AF8>)),
                ('fillna', SimpleImputer()),
                ('clf', RandomForestClassifier(max_depth=3, n_estimators=3))])

คาดการณ์ข้อมูลใหม่

new_data = pd.read_csv('/path/to/new_data.csv', sep = ',')
model.predict_proba(new_data) 
#OR
model.predict(new_data)

5. สรุป

ในบทความนี้ เราได้พูดคุยถึงแรงจูงใจในการติดตามการทดลองแมชชีนเลิร์นนิงโดยใช้ MLFlow บน Azure Machine Learning และตรวจสอบวิธีการ:

  1. ตั้งค่าเซิร์ฟเวอร์การติดตาม MLFlow ระยะไกลบน Azure Machine Learning
  2. ฝึกอบรมโมเดลในพื้นที่โดยใช้ scikit-learn
  3. บันทึกพารามิเตอร์โมเดล ผลลัพธ์ และส่วนต่างๆ ลงใน MLFlow
  4. ดึงโมเดลที่ได้รับการฝึกอบรมจากเซิร์ฟเวอร์ติดตาม MLFlow สำหรับการให้คะแนนแบบแบตช์ออฟไลน์

อ้างอิง

[1] MLFlow

[2] การเรียนรู้ของเครื่อง Azure

[3] กลุ่มทรัพยากร

[4] พื้นที่ทำงาน Azure Machine Learning