Spark-ის გაფართოება MLflow-ით

გამარჯობა ხაბროვსკის მცხოვრებლებო. როგორც უკვე დავწერეთ, ამ თვეში OTUS იწყებს ერთდროულად მანქანური სწავლების ორ კურსს, კერძოდ ბაზა и მოწინავე. ამასთან დაკავშირებით ჩვენ ვაგრძელებთ სასარგებლო მასალის გაზიარებას.

ამ სტატიის მიზანია ვისაუბროთ ჩვენს პირველ გამოცდილებაზე MLflow.

ჩვენ დავიწყებთ განხილვას MLflow მისი თვალთვალის სერვერიდან და დაარეგისტრირეთ კვლევის ყველა გამეორება. შემდეგ ჩვენ გაგიზიარებთ ჩვენს გამოცდილებას Spark-თან MLflow-თან დაკავშირების შესახებ UDF-ის გამოყენებით.

კონტექსტი

ჩვენ ვართ შემოსული ალფა ჯანმრთელობა ჩვენ ვიყენებთ მანქანათმცოდნეობას და ხელოვნურ ინტელექტს, რათა მივცეთ ხალხს უფლება, აიღონ პასუხისმგებლობა მათ ჯანმრთელობასა და კეთილდღეობაზე. სწორედ ამიტომ არის მანქანური სწავლების მოდელები ჩვენს მიერ შემუშავებული მონაცემთა მეცნიერების პროდუქტების ცენტრში და სწორედ ამიტომ მიგვიზიდა MLflow, ღია კოდის პლატფორმა, რომელიც მოიცავს მანქანათმცოდნეობის სასიცოცხლო ციკლის ყველა ასპექტს.

MLflow

MLflow-ის მთავარი მიზანია უზრუნველყოს დამატებითი ფენა მანქანური სწავლის თავზე, რომელიც საშუალებას მისცემს მონაცემთა მეცნიერებს იმუშაონ თითქმის ნებისმიერ მანქანათმცოდნეობის ბიბლიოთეკასთან (H2o, კერას, მილიპი, პიტორჩი, სკლეერნი и tensorflow), გადაიყვანს მის მუშაობას შემდეგ დონეზე.

MLflow უზრუნველყოფს სამ კომპონენტს:

• შეტყობინებები - ჩაწერა და ექსპერიმენტების მოთხოვნა: კოდი, მონაცემები, კონფიგურაცია და შედეგები. მოდელის შექმნის პროცესის მონიტორინგი ძალიან მნიშვნელოვანია.
• პროექტები - შეფუთვის ფორმატი ნებისმიერ პლატფორმაზე გასაშვებად (მაგ. SageMaker)
• მოდელები – საერთო ფორმატი მოდელების სხვადასხვა განლაგების ინსტრუმენტებზე წარდგენისთვის.

MLflow (წერის დროს ალფაში) არის ღია კოდის პლატფორმა, რომელიც საშუალებას გაძლევთ მართოთ მანქანათმცოდნეობის სასიცოცხლო ციკლი, ექსპერიმენტების, ხელახალი გამოყენებისა და განლაგების ჩათვლით.

MLflow-ის დაყენება

MLflow-ის გამოსაყენებლად ჯერ უნდა დააყენოთ მთელი თქვენი Python გარემო, ამისთვის ჩვენ გამოვიყენებთ PyEnv (მაკზე პითონის დასაყენებლად, შეამოწმეთ აქ). ამ გზით ჩვენ შეგვიძლია შევქმნათ ვირტუალური გარემო, სადაც დავაყენებთ მის გასაშვებად საჭირო ყველა ბიბლიოთეკას.

```
pyenv install 3.7.0
pyenv global 3.7.0 # Use Python 3.7
mkvirtualenv mlflow # Create a Virtual Env with Python 3.7
workon mlflow
```

მოდით დავაყენოთ საჭირო ბიბლიოთეკები.

```
pip install mlflow==0.7.0 
            Cython==0.29  
            numpy==1.14.5 
            pandas==0.23.4 
            pyarrow==0.11.0
```

შენიშვნა: ჩვენ ვიყენებთ PyArrow-ს ისეთი მოდელების გასაშვებად, როგორიცაა UDF. PyArrow-ისა და Numpy-ის ვერსიები უნდა გამოსწორებულიყო, რადგან ეს უკანასკნელი ვერსიები ეწინააღმდეგებოდა ერთმანეთს.

გაუშვით თვალთვალის UI

MLflow Tracking საშუალებას გვაძლევს ჩავწეროთ და შევიკითხოთ ექსპერიმენტები Python-ის და დასვენება API. გარდა ამისა, შეგიძლიათ განსაზღვროთ სად შეინახოთ მოდელის არტეფაქტები (localhost, Amazon S3, Azure Blob Storage, Google Cloud Storage ან SFTP სერვერი). ვინაიდან ჩვენ ვიყენებთ AWS-ს Alpha Health-ში, ჩვენი არტეფაქტის საცავი იქნება S3.

# Running a Tracking Server
mlflow server 
    --file-store /tmp/mlflow/fileStore 
    --default-artifact-root s3://<bucket>/mlflow/artifacts/ 
    --host localhost
    --port 5000

MLflow რეკომენდაციას უწევს ფაილების მუდმივი შენახვის გამოყენებას. ფაილის შენახვა არის ადგილი, სადაც სერვერი შეინახავს გაშვებულ და ექსპერიმენტის მეტამონაცემებს. სერვერის გაშვებისას, დარწმუნდით, რომ ის მიუთითებს ფაილების მუდმივ მაღაზიაზე. აქ ექსპერიმენტისთვის ჩვენ უბრალოდ გამოვიყენებთ /tmp.

გახსოვდეთ, რომ თუ გვსურს გამოვიყენოთ mlflow სერვერი ძველი ექსპერიმენტების გასაშვებად, ისინი უნდა იყოს წარმოდგენილი ფაილების საცავში. თუმცა, ამის გარეშეც ჩვენ შეგვეძლო მათი გამოყენება UDF-ში, რადგან ჩვენ გვჭირდება მხოლოდ გზა მოდელისკენ.

შენიშვნა: გაითვალისწინეთ, რომ Tracking UI-ს და მოდელის კლიენტს უნდა ჰქონდეთ წვდომა არტეფაქტის მდებარეობაზე. ანუ, მიუხედავად იმისა, რომ Tracking UI მდებარეობს EC2 ინსტანციაში, MLflow ლოკალურად გაშვებისას, მანქანას უნდა ჰქონდეს პირდაპირი წვდომა S3-ზე არტეფაქტის მოდელების დასაწერად.

Tracking UI ინახავს არტეფაქტებს S3 თაიგულში

გაშვებული მოდელები

როგორც კი Tracking სერვერი მუშაობს, შეგიძლიათ დაიწყოთ მოდელების ტრენინგი.

მაგალითად, ჩვენ გამოვიყენებთ ღვინის მოდიფიკაციას MLflow მაგალითიდან Sklearn.

MLFLOW_TRACKING_URI=http://localhost:5000 python wine_quality.py 
  --alpha 0.9
  --l1_ration 0.5
  --wine_file ./data/winequality-red.csv

როგორც უკვე განვიხილეთ, MLflow საშუალებას გაძლევთ დაარეგისტრიროთ მოდელის პარამეტრები, მეტრიკა და არტეფაქტები, რათა თვალყური ადევნოთ თუ როგორ ვითარდებიან ისინი განმეორებით. ეს ფუნქცია ძალზე სასარგებლოა, რადგან ამ გზით ჩვენ შეგვიძლია საუკეთესო მოდელის რეპროდუცირება Tracking სერვერთან დაკავშირებით ან იმის გაგებით, თუ რომელი კოდი ასრულებდა საჭირო გამეორებას კომითების git hash ჟურნალების გამოყენებით.

with mlflow.start_run():

    ... model ...

    mlflow.log_param("source", wine_path)
    mlflow.log_param("alpha", alpha)
    mlflow.log_param("l1_ratio", l1_ratio)

    mlflow.log_metric("rmse", rmse)
    mlflow.log_metric("r2", r2)
    mlflow.log_metric("mae", mae)

    mlflow.set_tag('domain', 'wine')
    mlflow.set_tag('predict', 'quality')
    mlflow.sklearn.log_model(lr, "model")

ღვინის გამეორებები

სერვერის ნაწილი მოდელისთვის

MLflow თვალთვალის სერვერს, რომელიც გაშვებულია "mlflow server" ბრძანების გამოყენებით, აქვს REST API გაშვებების თვალყურის დევნებისთვის და მონაცემების ადგილობრივ ფაილურ სისტემაში ჩასაწერად. თქვენ შეგიძლიათ მიუთითოთ თვალთვალის სერვერის მისამართი გარემოს ცვლადის „MLFLOW_TRACKING_URI“ გამოყენებით და MLflow თვალთვალის API ავტომატურად დაუკავშირდება თვალთვალის სერვერს ამ მისამართზე, რათა შექმნას/მიიღოს გაშვების ინფორმაცია, ჟურნალის მეტრიკა და ა.შ.

წყარო: Docs// თრექინგ სერვერის გაშვება

მოდელის სერვერის უზრუნველსაყოფად, ჩვენ გვჭირდება გაშვებული თვალთვალის სერვერი (იხ. გაშვების ინტერფეისი) და მოდელის Run ID.

გაუშვით ID

# Serve a sklearn model through 127.0.0.0:5005
MLFLOW_TRACKING_URI=http://0.0.0.0:5000 mlflow sklearn serve 
  --port 5005  
  --run_id 0f8691808e914d1087cf097a08730f17 
  --model-path model

MLflow სერვისის ფუნქციის გამოყენებით მოდელების მოსამსახურებლად, ჩვენ დაგვჭირდება წვდომა Tracking UI-ზე, რათა მივიღოთ ინფორმაცია მოდელის შესახებ უბრალოდ მითითებით --run_id.

როგორც კი მოდელი დაუკავშირდება Tracking სერვერს, ჩვენ შეგვიძლია მივიღოთ ახალი მოდელის საბოლოო წერტილი.

# Query Tracking Server Endpoint
curl -X POST 
  http://127.0.0.1:5005/invocations 
  -H 'Content-Type: application/json' 
  -d '[
	{
		"fixed acidity": 3.42, 
		"volatile acidity": 1.66, 
		"citric acid": 0.48, 
		"residual sugar": 4.2, 
		"chloridessssss": 0.229, 
		"free sulfur dsioxide": 19, 
		"total sulfur dioxide": 25, 
		"density": 1.98, 
		"pH": 5.33, 
		"sulphates": 4.39, 
		"alcohol": 10.8
	}
]'

> {"predictions": [5.825055635303461]}

გაშვებული მოდელები Spark-დან

იმისდა მიუხედავად, რომ Tracking სერვერი საკმარისად ძლიერია მოდელებს რეალურ დროში ემსახურება, მოამზადებს მათ და გამოიყენებს სერვერის ფუნქციონირებას (წყარო: mlflow // docs // მოდელები # ლოკალური), Spark-ის გამოყენება (სამყარო ან ნაკადი) კიდევ უფრო მძლავრი გადაწყვეტაა განაწილების გამო.

წარმოიდგინეთ, რომ თქვენ უბრალოდ გააკეთეთ ტრენინგი ოფლაინში და შემდეგ გამოიყენეთ გამომავალი მოდელი თქვენს ყველა მონაცემზე. აქ ანათებს Spark და MLflow.

დააინსტალირეთ PySpark + Jupyter + Spark

წყარო: დაიწყეთ PySpark - Jupyter

იმის საჩვენებლად, თუ როგორ ვიყენებთ MLflow მოდელებს Spark მონაცემთა ჩარჩოებზე, ჩვენ უნდა დავაყენოთ Jupyter ნოუთბუქები PySpark-თან ერთად მუშაობისთვის.

დაიწყეთ უახლესი სტაბილური ვერსიის ინსტალაციით Apache Spark:

cd ~/Downloads/
tar -xzf spark-2.4.3-bin-hadoop2.7.tgz
mv ~/Downloads/spark-2.4.3-bin-hadoop2.7 ~/
ln -s ~/spark-2.4.3-bin-hadoop2.7 ~/spark̀

დააინსტალირეთ PySpark და Jupyter ვირტუალურ გარემოში:

pip install pyspark jupyter

გარემოს ცვლადების დაყენება:

export SPARK_HOME=~/spark
export PATH=$SPARK_HOME/bin:$PATH
export PYSPARK_DRIVER_PYTHON=jupyter
export PYSPARK_DRIVER_PYTHON_OPTS="notebook --notebook-dir=${HOME}/Projects/notebooks"

რომელმაც დაადგინა notebook-dir, ჩვენ შეგვიძლია შევინახოთ ჩვენი ნოუთბუქები სასურველ საქაღალდეში.

იუპიტერის გაშვება PySpark-დან

ვინაიდან ჩვენ შევძელით იუპიტერის, როგორც PySpark დრაივერის კონფიგურაცია, ახლა შეგვიძლია Jupyter ნოუთბუქის გაშვება PySpark-ის კონტექსტში.

(mlflow) afranzi:~$ pyspark
[I 19:05:01.572 NotebookApp] sparkmagic extension enabled!
[I 19:05:01.573 NotebookApp] Serving notebooks from local directory: /Users/afranzi/Projects/notebooks
[I 19:05:01.573 NotebookApp] The Jupyter Notebook is running at:
[I 19:05:01.573 NotebookApp] http://localhost:8888/?token=c06252daa6a12cfdd33c1d2e96c8d3b19d90e9f6fc171745
[I 19:05:01.573 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[C 19:05:01.574 NotebookApp]

    Copy/paste this URL into your browser when you connect for the first time,
    to login with a token:
        http://localhost:8888/?token=c06252daa6a12cfdd33c1d2e96c8d3b19d90e9f6fc171745

როგორც ზემოთ აღინიშნა, MLflow უზრუნველყოფს S3-ში მოდელის არტეფაქტების აღრიცხვის ფუნქციას. როგორც კი შერჩეული მოდელი გვექნება ხელში, გვაქვს შესაძლებლობა მოდულის გამოყენებით შემოვიტანოთ იგი UDF-ად mlflow.pyfunc.

import mlflow.pyfunc

model_path = 's3://<bucket>/mlflow/artifacts/1/0f8691808e914d1087cf097a08730f17/artifacts/model'
wine_path = '/Users/afranzi/Projects/data/winequality-red.csv'
wine_udf = mlflow.pyfunc.spark_udf(spark, model_path)

df = spark.read.format("csv").option("header", "true").option('delimiter', ';').load(wine_path)
columns = [ "fixed acidity", "volatile acidity", "citric acid",
            "residual sugar", "chlorides", "free sulfur dioxide",
            "total sulfur dioxide", "density", "pH",
            "sulphates", "alcohol"
          ]
          
df.withColumn('prediction', wine_udf(*columns)).show(100, False)

PySpark - ღვინის ხარისხის პროგნოზების გამოტანა

ამ მომენტამდე, ჩვენ ვისაუბრეთ იმაზე, თუ როგორ გამოვიყენოთ PySpark MLflow-ით, ღვინის ხარისხის პროგნოზების გაშვება ღვინის მთელ მონაცემთა ბაზაზე. მაგრამ რა მოხდება, თუ დაგჭირდებათ Python MLflow მოდულების გამოყენება Scala Spark-ისგან?

ჩვენ ესეც გამოვცადეთ Spark კონტექსტის გაყოფით Scala-სა და Python-ს შორის. ანუ, ჩვენ დავარეგისტრირეთ MLflow UDF პითონში და გამოვიყენეთ იგი Scala-დან (დიახ, ალბათ არა საუკეთესო გამოსავალი, მაგრამ რაც გვაქვს).

Scala Spark + MLflow

ამ მაგალითს დავამატებთ თორე კერნელი არსებულ იუპიტერში.

დააინსტალირეთ Spark + Toree + Jupyter

pip install toree
jupyter toree install --spark_home=${SPARK_HOME} --sys-prefix
jupyter kernelspec list
```
```
Available kernels:
  apache_toree_scala    /Users/afranzi/.virtualenvs/mlflow/share/jupyter/kernels/apache_toree_scala
  python3               /Users/afranzi/.virtualenvs/mlflow/share/jupyter/kernels/python3
```

როგორც თანდართული ნოუთბუქიდან ხედავთ, UDF გაზიარებულია Spark-სა და PySpark-ს შორის. ვიმედოვნებთ, რომ ეს ნაწილი სასარგებლო იქნება მათთვის, ვისაც უყვარს Scala და სურს მანქანური სწავლების მოდელების წარმოებაში დანერგვა.

import org.apache.spark.sql.functions.col
import org.apache.spark.sql.types.StructType
import org.apache.spark.sql.{Column, DataFrame}
import scala.util.matching.Regex

val FirstAtRe: Regex = "^_".r
val AliasRe: Regex = "[\s_.:@]+".r

def getFieldAlias(field_name: String): String = {
    FirstAtRe.replaceAllIn(AliasRe.replaceAllIn(field_name, "_"), "")
}

def selectFieldsNormalized(columns: List[String])(df: DataFrame): DataFrame = {
    val fieldsToSelect: List[Column] = columns.map(field =>
        col(field).as(getFieldAlias(field))
    )
    df.select(fieldsToSelect: _*)
}

def normalizeSchema(df: DataFrame): DataFrame = {
    val schema = df.columns.toList
    df.transform(selectFieldsNormalized(schema))
}

FirstAtRe = ^_
AliasRe = [s_.:@]+

getFieldAlias: (field_name: String)String
selectFieldsNormalized: (columns: List[String])(df: org.apache.spark.sql.DataFrame)org.apache.spark.sql.DataFrame
normalizeSchema: (df: org.apache.spark.sql.DataFrame)org.apache.spark.sql.DataFrame
Out[1]:
[s_.:@]+
In [2]:
val winePath = "~/Research/mlflow-workshop/examples/wine_quality/data/winequality-red.csv"
val modelPath = "/tmp/mlflow/artifactStore/0/96cba14c6e4b452e937eb5072467bf79/artifacts/model"

winePath = ~/Research/mlflow-workshop/examples/wine_quality/data/winequality-red.csv
modelPath = /tmp/mlflow/artifactStore/0/96cba14c6e4b452e937eb5072467bf79/artifacts/model
Out[2]:
/tmp/mlflow/artifactStore/0/96cba14c6e4b452e937eb5072467bf79/artifacts/model
In [3]:
val df = spark.read
              .format("csv")
              .option("header", "true")
              .option("delimiter", ";")
              .load(winePath)
              .transform(normalizeSchema)

df = [fixed_acidity: string, volatile_acidity: string ... 10 more fields]
Out[3]:
[fixed_acidity: string, volatile_acidity: string ... 10 more fields]
In [4]:
%%PySpark
import mlflow
from mlflow import pyfunc

model_path = "/tmp/mlflow/artifactStore/0/96cba14c6e4b452e937eb5072467bf79/artifacts/model"
wine_quality_udf = mlflow.pyfunc.spark_udf(spark, model_path)

spark.udf.register("wineQuality", wine_quality_udf)
Out[4]:
<function spark_udf.<locals>.predict at 0x1116a98c8>
In [6]:
df.createOrReplaceTempView("wines")
In [10]:
%%SQL
SELECT 
    quality,
    wineQuality(
        fixed_acidity,
        volatile_acidity,
        citric_acid,
        residual_sugar,
        chlorides,
        free_sulfur_dioxide,
        total_sulfur_dioxide,
        density,
        pH,
        sulphates,
        alcohol
    ) AS prediction
FROM wines
LIMIT 10
Out[10]:
+-------+------------------+
|quality|        prediction|
+-------+------------------+
|      5| 5.576883967129615|
|      5|  5.50664776916154|
|      5| 5.525504822954496|
|      6| 5.504311247097457|
|      5| 5.576883967129615|
|      5|5.5556903912725755|
|      5| 5.467882654744997|
|      7| 5.710602976324739|
|      7| 5.657319539336507|
|      5| 5.345098606538708|
+-------+------------------+

In [17]:
spark.catalog.listFunctions.filter('name like "%wineQuality%").show(20, false)

+-----------+--------+-----------+---------+-----------+
|name       |database|description|className|isTemporary|
+-----------+--------+-----------+---------+-----------+
|wineQuality|null    |null       |null     |true       |
+-----------+--------+-----------+---------+-----------+

შემდეგი ნაბიჯები

მიუხედავად იმისა, რომ MLflow არის ალფა ვერსიაში წერის დროს, ის საკმაოდ პერსპექტიულად გამოიყურება. მხოლოდ რამდენიმე მანქანათმცოდნეობის ჩარჩოს გაშვების და ერთი ბოლო წერტილიდან მათი მოხმარების შესაძლებლობა სარეკომენდაციო სისტემებს გადაჰყავს შემდეგ დონეზე.

გარდა ამისა, MLflow აახლოებს მონაცემთა ინჟინერებსა და მონაცემთა მეცნიერების სპეციალისტებს, აყალიბებს მათ შორის საერთო ფენას.

MLflow-ის ამ გამოკვლევის შემდეგ, ჩვენ დარწმუნებული ვართ, რომ წინ წავალთ და გამოვიყენებთ მას ჩვენი Spark მილსადენებისა და სარეკომენდაციო სისტემებისთვის.

კარგი იქნებოდა ფაილური სისტემის ნაცვლად ფაილების შენახვის მონაცემთა ბაზასთან სინქრონიზაცია. ამან უნდა მოგვცეს მრავალი საბოლოო წერტილი, რომელსაც შეუძლია გამოიყენოს ერთი და იგივე ფაილის საცავი. მაგალითად, გამოიყენეთ მრავალი მაგალითი Presto и Athena იგივე Glue metastore-ით.

შეჯამებისთვის, მინდა მადლობა გადავუხადო MLFlow საზოგადოებას, რომ უფრო საინტერესო გახადა ჩვენი მუშაობა მონაცემებთან.

თუ თქვენ თამაშობთ MLflow-თან, ნუ მოგერიდებათ მოგვწეროთ და გვითხარით, როგორ იყენებთ მას და მით უმეტეს, თუ იყენებთ მას წარმოებაში.

შეიტყვეთ მეტი კურსების შესახებ:
მანქანათმცოდნეობა. ძირითადი კურსი
მანქანათმცოდნეობა. მოწინავე კურსი

Წაიკითხე მეტი:

• რისკები და გაფრთხილება ძირითადი კომპონენტის ანალიზის გამოყენებისას ზედამხედველობითი სწავლის პრობლემებზე
• მანქანური სწავლების მოდელის დაყენება Docker-ით - ნაწილი 1
• მანქანური სწავლების მოდელის დაყენება Docker-ით - ნაწილი 2

წყარო: www.habr.com