🥇MLflow உடன் நீட்டிக்கும் தீப்பொறி

வணக்கம், கப்ரோவ்ஸ்க் குடியிருப்பாளர்கள். நாங்கள் ஏற்கனவே எழுதியது போல், இந்த மாதம் OTUS ஒரே நேரத்தில் இரண்டு இயந்திர கற்றல் படிப்புகளை அறிமுகப்படுத்துகிறது, அதாவது அடித்தளம் и மேம்படுத்தபட்ட. இது சம்பந்தமாக, பயனுள்ள விஷயங்களை நாங்கள் தொடர்ந்து பகிர்ந்து கொள்கிறோம்.

இந்த கட்டுரையின் நோக்கம் எங்கள் முதல் அனுபவத்தைப் பற்றி பேசுவதாகும் எம்எல்ஃப்ளோ.

மதிப்பாய்வைத் தொடங்குவோம் எம்எல்ஃப்ளோ அதன் கண்காணிப்பு சேவையகத்திலிருந்து மற்றும் ஆய்வின் அனைத்து மறு செய்கைகளையும் பதிவு செய்யவும். UDF ஐப் பயன்படுத்தி MLflow உடன் Spark ஐ இணைக்கும் அனுபவத்தைப் பகிர்ந்து கொள்வோம்.

சூழல்

நாங்கள் உள்ளோம் ஆல்பா ஆரோக்கியம் இயந்திரக் கற்றல் மற்றும் செயற்கை நுண்ணறிவு ஆகியவற்றைப் பயன்படுத்தி, மக்கள் தங்கள் உடல்நலம் மற்றும் நல்வாழ்வைக் கவனித்துக் கொள்ள அதிகாரம் அளிக்கிறோம். அதனால்தான் நாங்கள் உருவாக்கும் தரவு அறிவியல் தயாரிப்புகளின் மையத்தில் இயந்திரக் கற்றல் மாதிரிகள் உள்ளன, அதனால்தான் இயந்திர கற்றல் வாழ்க்கைச் சுழற்சியின் அனைத்து அம்சங்களையும் உள்ளடக்கிய திறந்த மூல தளமான MLflow க்கு நாங்கள் ஈர்க்கப்பட்டோம்.

எம்எல்ஃப்ளோ

MLflow இன் முக்கிய குறிக்கோள், இயந்திர கற்றலின் மேல் கூடுதல் அடுக்கை வழங்குவதாகும், இது தரவு விஞ்ஞானிகளை எந்த இயந்திர கற்றல் நூலகத்திலும் வேலை செய்ய அனுமதிக்கும் (h2o, keras, குதித்தல், பைடார்ச், sklearn и tensorflow), அவளுடைய வேலையை அடுத்த கட்டத்திற்கு எடுத்துச் செல்வது.

MLflow மூன்று கூறுகளை வழங்குகிறது:

கண்காணிப்பு - பதிவுசெய்தல் மற்றும் சோதனைகளுக்கான கோரிக்கைகள்: குறியீடு, தரவு, கட்டமைப்பு மற்றும் முடிவுகள். ஒரு மாதிரியை உருவாக்கும் செயல்முறையை கண்காணிப்பது மிகவும் முக்கியம்.
திட்டங்கள் - எந்த தளத்திலும் இயங்க பேக்கேஜிங் வடிவம் (எ.கா. முனிவர்)
மாதிரிகள் - பல்வேறு வரிசைப்படுத்தல் கருவிகளுக்கு மாதிரிகளை சமர்ப்பிப்பதற்கான பொதுவான வடிவம்.

MLflow (எழுதும் நேரத்தில் ஆல்பாவில்) என்பது ஒரு திறந்த மூல தளமாகும், இது சோதனை, மறுபயன்பாடு மற்றும் வரிசைப்படுத்துதல் உள்ளிட்ட இயந்திர கற்றல் வாழ்க்கைச் சுழற்சியை நிர்வகிக்க உங்களை அனுமதிக்கிறது.

MLflow அமைத்தல்

MLflow ஐப் பயன்படுத்த, முதலில் உங்கள் முழு பைதான் சூழலையும் அமைக்க வேண்டும், இதற்காக நாங்கள் பயன்படுத்துவோம் PyEnv (Mac இல் பைத்தானை நிறுவ, பார்க்கவும் இங்கே) இந்த வழியில் நாம் ஒரு மெய்நிகர் சூழலை உருவாக்க முடியும், அங்கு தொடங்குவதற்கு தேவையான அனைத்து நூலகங்களையும் நிறுவுவோம்.

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

குறிப்பு: UDF போன்ற மாதிரிகளை இயக்க PyArrow ஐப் பயன்படுத்துகிறோம். PyArrow மற்றும் Numpy இன் பதிப்புகள் சரிசெய்யப்பட வேண்டும், ஏனெனில் பிந்தைய பதிப்புகள் ஒன்றுக்கொன்று முரண்பட்டன.

கண்காணிப்பு UI ஐத் தொடங்கவும்

MLflow கண்காணிப்பு பைதான் மற்றும் பயன்படுத்தி சோதனைகளை பதிவு செய்து வினவ அனுமதிக்கிறது நவக்கிரகங்களும் API. கூடுதலாக, மாதிரி கலைப்பொருட்களை எங்கு சேமிப்பது என்பதை நீங்கள் தீர்மானிக்கலாம் (லோக்கல் ஹோஸ்ட், அமேசான் S3, Azure Blob சேமிப்பு, Google கிளவுட் ஸ்டோரேஜ் அல்லது SFTP சேவையகம்) ஆல்பா ஹெல்த் நிறுவனத்தில் AWSஐப் பயன்படுத்துவதால், எங்களின் கலைப்பொருள் சேமிப்பு 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 இல் பயன்படுத்தலாம், ஏனெனில் எங்களுக்கு மாதிரிக்கான பாதை மட்டுமே தேவை.

குறிப்பு: டிராக்கிங் UI மற்றும் மாடல் கிளையன்ட் கலைப்பொருள் இருப்பிடத்திற்கான அணுகலைக் கொண்டிருக்க வேண்டும் என்பதை நினைவில் கொள்ளவும். அதாவது, டிராக்கிங் UI ஒரு EC2 நிகழ்வில் இருந்தாலும், உள்நாட்டில் MLflow ஐ இயக்கும் போது, கலைப்பொருள் மாதிரிகளை எழுத இயந்திரம் S3க்கு நேரடி அணுகலைப் பெற்றிருக்க வேண்டும்.

கண்காணிப்பு UI கலைப்பொருட்களை S3 வாளியில் சேமிக்கிறது

இயங்கும் மாதிரிகள்

கண்காணிப்பு சேவையகம் இயங்கியவுடன், நீங்கள் மாதிரிகளுக்கு பயிற்சி அளிக்க ஆரம்பிக்கலாம்.

உதாரணமாக, MLflow உதாரணத்திலிருந்து ஒயின் மாற்றத்தைப் பயன்படுத்துவோம் ஸ்க்லேர்ன்.

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

நாங்கள் ஏற்கனவே விவாதித்தபடி, மாதிரி அளவுருக்கள், அளவீடுகள் மற்றும் கலைப்பொருட்களை பதிவு செய்ய MLflow உங்களை அனுமதிக்கிறது. இந்த அம்சம் மிகவும் பயனுள்ளதாக இருக்கிறது, ஏனெனில் இந்த வழியில் நாம் கண்காணிப்பு சேவையகத்தைத் தொடர்புகொள்வதன் மூலம் சிறந்த மாதிரியை மீண்டும் உருவாக்க முடியும் அல்லது கமிட்களின் git ஹாஷ் பதிவுகளைப் பயன்படுத்தி தேவையான மறு செய்கையை எந்த குறியீடு நிகழ்த்தியது என்பதைப் புரிந்து கொள்ளலாம்.

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 சேவையகம்” கட்டளையைப் பயன்படுத்தி தொடங்கப்பட்டது, ரன்களைக் கண்காணிப்பதற்கும் உள்ளூர் கோப்பு முறைமையில் தரவை எழுதுவதற்கும் REST API உள்ளது. "MLFLOW_TRACKING_URI" என்ற சூழல் மாறியைப் பயன்படுத்தி கண்காணிப்பு சேவையக முகவரியை நீங்கள் குறிப்பிடலாம் மற்றும் வெளியீட்டுத் தகவல், பதிவு அளவீடுகள் போன்றவற்றை உருவாக்க/பெற, MLflow கண்காணிப்பு API தானாகவே கண்காணிப்பு சேவையகத்தை இந்த முகவரியில் தொடர்பு கொள்ளும்.

ஆதாரம்: ஆவணம்// கண்காணிப்பு சேவையகத்தை இயக்குகிறது

மாதிரியை சேவையகத்துடன் வழங்க, எங்களுக்கு இயங்கும் கண்காணிப்பு சேவையகம் (வெளியீட்டு இடைமுகத்தைப் பார்க்கவும்) மற்றும் மாதிரியின் ரன் ஐடி தேவை.

ஐடியை இயக்கவும்

# 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 சர்வ் செயல்பாட்டைப் பயன்படுத்தி மாடல்களை வழங்க, மாடலைப் பற்றிய தகவல்களை வெறுமனே குறிப்பிடுவதன் மூலம் பெற, கண்காணிப்பு UIக்கான அணுகல் நமக்குத் தேவைப்படும். --run_id.

மாடல் ட்ராக்கிங் சர்வரைத் தொடர்பு கொண்டவுடன், புதிய மாடல் எண்ட்பாயிண்ட்டைப் பெறலாம்.

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

ஸ்பார்க்கிலிருந்து இயங்கும் மாதிரிகள்

கண்காணிப்பு சேவையகம் நிகழ்நேரத்தில் மாதிரிகளை வழங்குவதற்கும், அவற்றைப் பயிற்றுவிப்பதற்கும், சேவையக செயல்பாட்டைப் பயன்படுத்துவதற்கும் போதுமான சக்தி வாய்ந்தது என்ற போதிலும் (ஆதாரம்: mlflow // டாக்ஸ் // மாதிரிகள் # உள்ளூர்), ஸ்பார்க்கின் பயன்பாடு (தொகுதி அல்லது ஸ்ட்ரீமிங்) விநியோகம் காரணமாக இன்னும் சக்திவாய்ந்த தீர்வாகும்.

நீங்கள் வெறுமனே பயிற்சியை ஆஃப்லைனில் செய்துவிட்டு, உங்கள் எல்லா தரவுகளுக்கும் வெளியீட்டு மாதிரியைப் பயன்படுத்துகிறீர்கள் என்று கற்பனை செய்து பாருங்கள். இங்குதான் ஸ்பார்க் மற்றும் எம்எல்ஃப்ளோ பிரகாசிக்கின்றன.

PySpark + Jupyter + Spark ஐ நிறுவவும்

ஆதாரம்: தொடங்குங்கள் PySpark - Jupyter

ஸ்பார்க் டேட்டாஃப்ரேம்களுக்கு எம்எல்ஃப்ளோ மாடல்களை எப்படிப் பயன்படுத்துகிறோம் என்பதைக் காட்ட, பைஸ்பார்க்குடன் இணைந்து செயல்பட ஜூபிடர் நோட்புக்குகளை அமைக்க வேண்டும்.

சமீபத்திய நிலையான பதிப்பை நிறுவுவதன் மூலம் தொடங்கவும் அப்பாச்சி ஸ்பார்க்:

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 இலிருந்து Jupyter ஐ அறிமுகப்படுத்துகிறது

ஜூபிடரை பைஸ்பார்க் டிரைவராக உள்ளமைக்க முடிந்ததால், இப்போது பைஸ்பார்க்கின் சூழலில் ஜூபிடர் நோட்புக்கை இயக்கலாம்.

(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

மேலே குறிப்பிட்டுள்ளபடி, S3 இல் மாதிரி கலைப்பொருட்களை பதிவு செய்வதற்கான அம்சத்தை MLflow வழங்குகிறது. தேர்ந்தெடுக்கப்பட்ட மாதிரி நம் கைகளில் கிடைத்தவுடன், தொகுதியைப் பயன்படுத்தி 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)

பைஸ்பார்க் - ஒயின் தரக் கணிப்புகளை வெளியிடுகிறது

இது வரை, MLflow உடன் PySpark ஐ எவ்வாறு பயன்படுத்துவது என்பது பற்றி நாங்கள் பேசினோம், முழு ஒயின் தரவுத்தொகுப்பில் ஒயின் தர கணிப்புகளை இயக்குகிறது. ஆனால் நீங்கள் Scala Spark இலிருந்து Python MLflow தொகுதிகளைப் பயன்படுத்த வேண்டும் என்றால் என்ன செய்வது?

Scala மற்றும் Python இடையே Spark சூழலைப் பிரித்து இதையும் சோதித்தோம். அதாவது, MLflow UDF ஐ Python இல் பதிவு செய்து, Scala இலிருந்து பயன்படுத்தினோம் (ஆம், சிறந்த தீர்வு அல்ல, ஆனால் நம்மிடம் இருப்பது).

ஸ்கலா ஸ்பார்க் + 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 இடையே பகிரப்படுகிறது. ஸ்கலாவை விரும்புவோருக்கும், இயந்திர கற்றல் மாதிரிகளை உற்பத்தியில் பயன்படுத்த விரும்புவோருக்கும் இந்தப் பகுதி பயனுள்ளதாக இருக்கும் என நம்புகிறோம்.

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 சமூகத்திற்கு நன்றி சொல்ல விரும்புகிறேன்.

நீங்கள் MLflow உடன் விளையாடுகிறீர்கள் என்றால், தயங்காமல் எங்களுக்கு எழுதவும், நீங்கள் அதை எப்படிப் பயன்படுத்துகிறீர்கள் என்பதை எங்களிடம் கூறவும், இன்னும் அதிகமாக நீங்கள் அதை தயாரிப்பில் பயன்படுத்தினால்.

படிப்புகளைப் பற்றி மேலும் அறிய:
இயந்திர வழி கற்றல். அடிப்படை படிப்பு
இயந்திர வழி கற்றல். மேம்பட்ட படிப்பு

மேலும் படிக்க:

ஆதாரம்: www.habr.com

MLflow உடன் ஸ்பார்க்கை நீட்டித்தல்