Spark paplašināšana ar MLflow

Sveiki, Habrovskas iedzīvotāji. Kā jau rakstījām, šomēnes OTUS uzsāk uzreiz divus mašīnmācības kursus, proti bāze и uzlabotas. Šajā sakarā mēs turpinām dalīties ar noderīgu materiālu.

Šī raksta mērķis ir pastāstīt par mūsu pirmo pieredzi, izmantojot MLflow.

Mēs sāksim pārskatīšanu MLflow no sava izsekošanas servera un reģistrēt visas pētījuma iterācijas. Pēc tam mēs dalīsimies pieredzē par Spark savienošanu ar MLflow, izmantojot UDF.

Konteksts

Mes esam ieksa Alfa veselība Mēs izmantojam mašīnmācīšanos un mākslīgo intelektu, lai dotu cilvēkiem iespēju uzņemties atbildību par savu veselību un labklājību. Tāpēc mašīnmācīšanās modeļi ir mūsu izstrādāto datu zinātnes produktu pamatā, un tāpēc mūs piesaistīja MLflow — atvērtā pirmkoda platforma, kas aptver visus mašīnmācīšanās dzīves cikla aspektus.

MLflow

MLflow galvenais mērķis ir nodrošināt papildu slāni mašīnmācībai, kas ļautu datu zinātniekiem strādāt ar gandrīz jebkuru mašīnmācīšanās bibliotēku (h2o, keras, mleap, pitors, sklearn и tensora plūsma), paceļot viņas darbu uz nākamo līmeni.

MLflow nodrošina trīs komponentus:

• Izsekošana – eksperimentu ierakstīšana un pieprasījumi: kods, dati, konfigurācija un rezultāti. Modeļa izveides procesa uzraudzība ir ļoti svarīga.
• AKTIVITĀTES – Iepakojuma formāts, kas darbojas jebkurā platformā (piem. SageMaker)
• Modeļi – kopīgs formāts modeļu iesniegšanai dažādiem izvietošanas rīkiem.

MLflow (rakstīšanas laikā alfa versijā) ir atvērtā pirmkoda platforma, kas ļauj pārvaldīt mašīnmācīšanās dzīves ciklu, tostarp eksperimentēšanu, atkārtotu izmantošanu un izvietošanu.

MLflow iestatīšana

Lai izmantotu MLflow, vispirms ir jāiestata visa Python vide, ko mēs izmantosim PyEnv (Lai instalētu Python operētājsistēmā Mac, pārbaudiet šeit). Tādā veidā mēs varam izveidot virtuālo vidi, kurā instalēsim visas tās palaišanai nepieciešamās bibliotēkas.

```
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
```

Instalēsim vajadzīgās bibliotēkas.

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

Piezīme. Mēs izmantojam PyArrow, lai palaistu tādus modeļus kā UDF. PyArrow un Numpy versijas bija jālabo, jo pēdējās versijas konfliktēja viena ar otru.

Palaidiet izsekošanas lietotāja saskarni

MLflow izsekošana ļauj reģistrēt eksperimentus un veikt vaicājumus, izmantojot Python un ATPŪTA API. Turklāt varat noteikt, kur glabāt modeļu artefaktus (localhost, Amazon S3, Azure Blob krātuve, Google Cloud Storage vai SFTP serveris). Tā kā Alpha Health izmantojam AWS, mūsu artefaktu krātuve būs S3.

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

MLflow iesaka izmantot pastāvīgu failu krātuvi. Failu krātuve ir vieta, kur serveris glabās palaišanas un eksperimentu metadatus. Startējot serveri, pārliecinieties, vai tas norāda uz pastāvīgo failu krātuvi. Šeit mēs vienkārši izmantosim eksperimentu /tmp.

Atcerieties, ka, ja mēs vēlamies izmantot mlflow serveri veco eksperimentu veikšanai, tiem ir jāatrodas failu krātuvē. Tomēr pat bez tā mēs varētu tos izmantot UDF, jo mums ir nepieciešams tikai ceļš uz modeli.

Piezīme. Ņemiet vērā, ka izsekošanas lietotāja saskarnei un modeļa klientam ir jābūt piekļuvei artefakta atrašanās vietai. Tas nozīmē, ka neatkarīgi no tā, ka izsekošanas lietotāja saskarne atrodas EC2 instancē, lokāli palaižot MLflow, iekārtai ir jābūt tiešai piekļuvei S3, lai rakstītu artefaktu modeļus.

Izsekošanas lietotāja saskarne artefaktus glabā S3 segmentā

Skriešanas modeļi

Tiklīdz darbojas izsekošanas serveris, varat sākt apmācīt modeļus.

Kā piemēru mēs izmantosim vīna modifikāciju no MLflow piemēra Sklearn.

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

Kā mēs jau apspriedām, MLflow ļauj reģistrēt modeļa parametrus, metriku un artefaktus, lai varētu izsekot, kā tie attīstās iterāciju laikā. Šī funkcija ir ārkārtīgi noderīga, jo tādā veidā mēs varam reproducēt labāko modeli, sazinoties ar izsekošanas serveri vai saprotot, kurš kods veica nepieciešamo iterāciju, izmantojot git jaukšanas žurnālus.

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")

Vīna atkārtojumi

Servera daļa modelim

MLflow izsekošanas serverim, kas palaists, izmantojot komandu “mlflow server”, ir REST API, lai izsekotu darbības un ierakstītu datus vietējā failu sistēmā. Varat norādīt izsekošanas servera adresi, izmantojot vides mainīgo “MLFLOW_TRACKING_URI”, un MLflow izsekošanas API automātiski sazināsies ar izsekošanas serveri šajā adresē, lai izveidotu/saņemtu palaišanas informāciju, žurnāla metriku utt.

Avots: Dokumenti// Izsekošanas servera palaišana

Lai modelim nodrošinātu ar serveri, mums ir nepieciešams darbojošs izsekošanas serveris (skatiet palaišanas saskarni) un modeļa palaišanas ID.

Palaist 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

Lai apkalpotu modeļus, izmantojot MLflow apkalpošanas funkcionalitāti, mums būs nepieciešama piekļuve izsekošanas lietotāja saskarnei, lai saņemtu informāciju par modeli, vienkārši norādot --run_id.

Kad modelis sazinās ar izsekošanas serveri, mēs varam iegūt jaunu modeļa galapunktu.

# 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]}

Skriešanas modeļi no Spark

Neskatoties uz to, ka izsekošanas serveris ir pietiekami jaudīgs, lai apkalpotu modeļus reāllaikā, apmācītu tos un izmantotu servera funkcionalitāti (avots: mlflow // dokumenti // modeļi # lokāli), Spark izmantošana (paketē vai straumēšana) ir vēl jaudīgāks risinājums izplatīšanas dēļ.

Iedomājieties, ka jūs vienkārši veicāt apmācību bezsaistē un pēc tam lietojāt izvades modeli visiem saviem datiem. Šeit spīd Spark un MLflow.

Instalējiet PySpark + Jupyter + Spark

Avots: Darba sākšana PySpark — Jupyter

Lai parādītu, kā mēs izmantojam MLflow modeļus Spark datu rāmjiem, mums ir jāiestata Jupyter piezīmjdatori, lai tie darbotos kopā ar PySpark.

Sāciet ar jaunākās stabilās versijas instalēšanu 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̀

Instalējiet PySpark un Jupyter virtuālajā vidē:

pip install pyspark jupyter

Iestatiet vides mainīgos:

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"

Noteicis notebook-dir, mēs varam saglabāt savas piezīmju grāmatiņas vēlamajā mapē.

Jupyter palaišana no PySpark

Tā kā mēs varējām konfigurēt Jupiteru kā PySpark draiveri, tagad mēs varam palaist Jupyter piezīmjdatoru PySpark kontekstā.

(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

Kā minēts iepriekš, MLflow nodrošina funkciju modeļa artefaktu reģistrēšanai S3. Tiklīdz izvēlētais modelis ir mūsu rokās, mums ir iespēja to importēt kā UDF, izmantojot moduli 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 — vīna kvalitātes prognozes

Līdz šim mēs esam runājuši par to, kā izmantot PySpark ar MLflow, veicot vīna kvalitātes prognozes visā vīna datu kopā. Bet ko darīt, ja jums ir jāizmanto Python MLflow moduļi no Scala Spark?

Mēs arī to pārbaudījām, sadalot Spark kontekstu starp Scala un Python. Tas ir, mēs reģistrējām MLflow UDF programmā Python un izmantojām to no Scala (jā, iespējams, tas nav labākais risinājums, bet tas, kas mums ir).

Scala Spark + MLflow

Šim piemēram mēs pievienosim Toree kodols esošajā Jupiterā.

Instalējiet 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
```

Kā redzat pievienotajā piezīmju grāmatiņā, UDF tiek koplietots starp Spark un PySpark. Mēs ceram, ka šī daļa būs noderīga tiem, kam patīk Scala un kuri vēlas ražošanā izmantot mašīnmācīšanās modeļus.

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       |
+-----------+--------+-----------+---------+-----------+

Nākamās darbības

Lai gan rakstīšanas laikā MLflow ir Alpha versijā, tas izskatās diezgan daudzsološi. Tikai iespēja palaist vairākas mašīnmācīšanās ietvaras un patērēt tās no viena galapunkta paceļ ieteikumu sistēmas uz nākamo līmeni.

Turklāt MLflow tuvina datu inženierus un datu zinātnes speciālistus, veidojot tiem kopīgu slāni.

Pēc šīs MLflow izpētes esam pārliecināti, ka virzīsimies uz priekšu un izmantosim to saviem Spark cauruļvadiem un ieteikumu sistēmām.

Būtu jauki failu krātuvi sinhronizēt ar datu bāzi, nevis failu sistēmu. Tam vajadzētu iegūt vairākus galapunktus, kas var izmantot vienu un to pašu failu krātuvi. Piemēram, izmantojiet vairākus gadījumus Presto и Athena ar to pašu Glue metastore.

Rezumējot, es vēlos pateikties MLFlow kopienai, kas padarīja mūsu darbu ar datiem interesantāku.

Ja spēlējaties ar MLflow, nevilcinieties un pastāstiet mums, kā to izmantojat, un vēl jo vairāk, ja to izmantojat ražošanā.

Uzzini vairāk par kursiem:
Mašīnmācība. Pamatkurss
Mašīnmācība. Padziļināts kurss

Lasīt vairāk:

• Riski un piesardzības pasākumi, piemērojot galveno komponentu analīzi uzraudzītām mācīšanās problēmām
• Mašīnmācīšanās modeļa izvietošana ar Docker — 1. daļa
• Mašīnmācīšanās modeļa izvietošana ar Docker — 2. daļa

Avots: www.habr.com