🥇ពង្រីក Spark ជាមួយ MLflow

ជំរាបសួរអ្នកស្រុក Khabrovsk ។ ដូចដែលយើងបានសរសេររួចហើយ នៅខែនេះ OTUS កំពុងចាប់ផ្តើមវគ្គសិក្សាម៉ាស៊ីនពីរក្នុងពេលតែមួយ ពោលគឺ មូលដ្ឋាន и កម្រិតខ្ពស់. ក្នុងន័យនេះ យើងបន្តចែករំលែកសម្ភារៈដែលមានប្រយោជន៍។

គោលបំណងនៃអត្ថបទនេះគឺដើម្បីនិយាយអំពីបទពិសោធន៍ដំបូងរបស់យើងក្នុងការប្រើប្រាស់ លំហូរ.

យើងនឹងចាប់ផ្តើមការពិនិត្យឡើងវិញ លំហូរ ពីម៉ាស៊ីនមេតាមដានរបស់វា ហើយកត់ត្រារាល់ការធ្វើឡើងវិញនៃការសិក្សា។ បន្ទាប់មកយើងនឹងចែករំលែកបទពិសោធន៍របស់យើងក្នុងការភ្ជាប់ Spark ជាមួយ MLflow ដោយប្រើ UDF ។

បរិបទ

យើងស្ថិតនៅក្នុង អាល់ហ្វាសុខភាព យើងប្រើការរៀនតាមម៉ាស៊ីន និងបញ្ញាសិប្បនិមិត្ត ដើម្បីផ្តល់អំណាចដល់មនុស្សឱ្យទទួលខុសត្រូវលើសុខភាព និងសុខុមាលភាពរបស់ពួកគេ។ នោះហើយជាមូលហេតុដែលគំរូនៃការរៀនម៉ាស៊ីនគឺជាចំណុចស្នូលនៃផលិតផលវិទ្យាសាស្ត្រទិន្នន័យដែលយើងបង្កើត ហើយនោះជាមូលហេតុដែលយើងត្រូវបានទាញទៅ MLflow ដែលជាវេទិកាប្រភពបើកចំហដែលគ្របដណ្តប់គ្រប់ទិដ្ឋភាពទាំងអស់នៃវដ្តជីវិតនៃការរៀនម៉ាស៊ីន។

លំហូរ

គោលដៅចម្បងនៃ MLflow គឺដើម្បីផ្តល់នូវស្រទាប់បន្ថែមមួយនៅលើកំពូលនៃការរៀនម៉ាស៊ីន ដែលនឹងអនុញ្ញាតឱ្យអ្នកវិទ្យាសាស្ត្រទិន្នន័យធ្វើការជាមួយស្ទើរតែគ្រប់បណ្ណាល័យរៀនម៉ាស៊ីន (h2o, keras, លាភ, pytorch, sklearn и tensorflow ។), យកការងាររបស់នាងទៅកម្រិតបន្ទាប់។

MLflow ផ្តល់នូវសមាសធាតុបីយ៉ាង៖

ការតាមដាន - ការកត់ត្រា និងសំណើសម្រាប់ការពិសោធន៍៖ កូដ ទិន្នន័យ ការកំណត់រចនាសម្ព័ន្ធ និងលទ្ធផល។ ការត្រួតពិនិត្យដំណើរការនៃការបង្កើតគំរូគឺមានសារៈសំខាន់ណាស់។
គម្រោង - ទម្រង់វេចខ្ចប់ដើម្បីដំណើរការលើវេទិកាណាមួយ (ឧ. SageMaker ។)
ម៉ូដែល - ទម្រង់ទូទៅសម្រាប់ការបញ្ជូនគំរូទៅកាន់ឧបករណ៍ដាក់ពង្រាយផ្សេងៗ។

MLflow (ជាអាល់ហ្វានៅពេលសរសេរ) គឺជាវេទិកាប្រភពបើកចំហដែលអនុញ្ញាតឱ្យអ្នកគ្រប់គ្រងវដ្តនៃការសិក្សារបស់ម៉ាស៊ីន រួមទាំងការពិសោធន៍ ការប្រើប្រាស់ឡើងវិញ និងការដាក់ឱ្យប្រើប្រាស់។

ការដំឡើង MLflow

ដើម្បីប្រើ MLflow អ្នកត្រូវរៀបចំបរិស្ថាន Python ទាំងមូលរបស់អ្នកជាមុនសិន សម្រាប់ការនេះយើងនឹងប្រើ PyEnv (ដើម្បីដំឡើង Python នៅលើ 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
```

ចំណាំ៖ យើងប្រើ PyArrow ដើម្បីដំណើរការម៉ូដែលដូចជា UDF ជាដើម។ កំណែរបស់ PyArrow និង Numpy ចាំបាច់ត្រូវបានជួសជុល ពីព្រោះកំណែចុងក្រោយមានជម្លោះជាមួយគ្នា។

បើកដំណើរការ UI តាមដាន

ការតាមដាន MLflow អនុញ្ញាតឱ្យយើងកត់ត្រា និងសាកសួរការពិសោធន៍ដោយប្រើ Python និង សម្រាក API លើសពីនេះ អ្នកអាចកំណត់កន្លែងដែលត្រូវរក្សាទុកវត្ថុបុរាណគំរូ (localhost, Amazon S3, ការផ្ទុក Azure Blob, 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 ដោយហេតុថាយើងគ្រាន់តែត្រូវការផ្លូវទៅកាន់គំរូប៉ុណ្ណោះ។

ចំណាំ៖ សូមចងចាំថាការតាមដាន UI និងអតិថិជនគំរូត្រូវតែមានសិទ្ធិចូលទៅកាន់ទីតាំងវត្ថុបុរាណ។ នោះគឺដោយមិនគិតពីការពិតដែលថា Tracking UI ស្ថិតនៅក្នុងឧទាហរណ៍ EC2 នៅពេលដំណើរការ MLflow ក្នុងស្រុក ម៉ាស៊ីនត្រូវតែមានសិទ្ធិចូលប្រើដោយផ្ទាល់ទៅកាន់ S3 ដើម្បីសរសេរគំរូវត្ថុបុរាណ។

ការតាមដាន UI រក្សាទុកវត្ថុបុរាណនៅក្នុងធុង S3

ម៉ូដែលដែលកំពុងដំណើរការ

ដរាបណាម៉ាស៊ីនមេតាមដានកំពុងដំណើរការ អ្នកអាចចាប់ផ្តើមបណ្តុះបណ្តាលគំរូ។

ជាឧទាហរណ៍ យើងនឹងប្រើការកែប្រែស្រាពីឧទាហរណ៍ 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 អនុញ្ញាតឱ្យអ្នកកត់ត្រាប៉ារ៉ាម៉ែត្រគំរូ រង្វាស់ និងវត្ថុបុរាណ ដូច្នេះអ្នកអាចតាមដានពីរបៀបដែលពួកវាវិវឌ្ឍលើការធ្វើម្តងទៀត។ លក្ខណៈពិសេសនេះមានប្រយោជន៍ខ្លាំងណាស់ ពីព្រោះវិធីនេះយើងអាចបង្កើតគំរូល្អបំផុតឡើងវិញដោយទាក់ទងទៅម៉ាស៊ីនមេតាមដាន ឬការយល់ដឹងអំពីកូដណាមួយដែលអនុវត្តការទាមទារឡើងវិញដោយប្រើ git hash logs of commits។

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” ហើយ API តាមដាន MLflow នឹងទាក់ទងដោយស្វ័យប្រវត្តិទៅម៉ាស៊ីនមេតាមដានតាមអាសយដ្ឋាននេះ ដើម្បីបង្កើត/ទទួលព័ត៌មាននៃការបើកដំណើរការ កំណត់ហេតុម៉ែត្រ។ល។

ប្រភព: ឯកសារ// កំពុងដំណើរការម៉ាស៊ីនមេតាមដាន

ដើម្បីផ្តល់ម៉ូដែលជាមួយម៉ាស៊ីនមេ យើងត្រូវការម៉ាស៊ីនមេតាមដានដែលកំពុងដំណើរការ (សូមមើលចំណុចប្រទាក់ចាប់ផ្តើម) និងលេខសម្គាល់ដំណើរការនៃគំរូ។

ដំណើរការលេខសម្គាល់

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

ម៉ូដែលដែលកំពុងដំណើរការពី Spark

ទោះបីជាការពិតដែលថាម៉ាស៊ីនមេតាមដានមានថាមពលគ្រប់គ្រាន់ដើម្បីបម្រើម៉ូដែលក្នុងពេលវេលាជាក់ស្តែងក៏ដោយ បណ្តុះបណ្តាលពួកគេ និងប្រើប្រាស់មុខងារម៉ាស៊ីនមេ (ប្រភព៖ mlflow // docs // ម៉ូដែល # ក្នុងស្រុក) ដោយប្រើ Spark (បាច់ ឬស្ទ្រីម) គឺជាដំណោះស្រាយដ៏មានឥទ្ធិពលជាងមុន ដោយសារការចែកចាយរបស់វា។

ស្រមៃថាអ្នកគ្រាន់តែធ្វើការហ្វឹកហ្វឺនក្រៅបណ្តាញ ហើយបន្ទាប់មកអនុវត្តគំរូលទ្ធផលទៅនឹងទិន្នន័យរបស់អ្នកទាំងអស់។ នេះគឺជាកន្លែងដែល Spark និង MLflow ភ្លឺ។

ដំឡើង PySpark + Jupyter + Spark

ប្រភព: ចាប់ផ្តើម PySpark - Jupyter

ដើម្បីបង្ហាញពីរបៀបដែលយើងអនុវត្តគំរូ MLflow ទៅ Spark dataframes យើងត្រូវរៀបចំ Jupyter notebooks ដើម្បីធ្វើការរួមគ្នាជាមួយ 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យើងអាចរក្សាទុកសៀវភៅកត់ត្រារបស់យើងក្នុងថតឯកសារដែលចង់បាន។

បើកដំណើរការ Jupyter ពី PySpark

ដោយសារយើងអាចកំណត់រចនាសម្ព័ន្ធ Jupiter ជាកម្មវិធីបញ្ជា PySpark ឥឡូវនេះយើងអាចដំណើរការ Jupyter notebook នៅក្នុងបរិបទនៃ 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 នៅក្នុង Python ហើយបានប្រើវាពី Scala (បាទ ប្រហែលជាមិនមែនជាដំណោះស្រាយដ៏ល្អបំផុត ប៉ុន្តែអ្វីដែលយើងមាន)។

Scala Spark + MLflow

សម្រាប់ឧទាហរណ៍នេះយើងនឹងបន្ថែម ខឺណែល Toree ចូលទៅក្នុងភពព្រហស្បតិ៍ដែលមានស្រាប់។

ដំឡើង 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 pipelines និងប្រព័ន្ធណែនាំរបស់យើង។

វាជាការល្អក្នុងការធ្វើសមកាលកម្មការផ្ទុកឯកសារជាមួយមូលដ្ឋានទិន្នន័យជំនួសឱ្យប្រព័ន្ធឯកសារ។ នេះគួរតែផ្តល់ឱ្យយើងនូវចំណុចបញ្ចប់ជាច្រើនដែលអាចប្រើកន្លែងផ្ទុកឯកសារដូចគ្នា។ ឧទាហរណ៍ ប្រើឧទាហរណ៍ច្រើន។ Presto и Athena ជាមួយ Glue metastore ដូចគ្នា។

ដើម្បីសង្ខេប ខ្ញុំចង់និយាយអរគុណដល់សហគមន៍ MLFlow សម្រាប់ការធ្វើឱ្យការងាររបស់យើងជាមួយនឹងទិន្នន័យកាន់តែគួរឱ្យចាប់អារម្មណ៍។

ប្រសិនបើអ្នកកំពុងលេងជាមួយ MLflow សូមកុំស្ទាក់ស្ទើរក្នុងការសរសេរមកកាន់យើង ហើយប្រាប់យើងពីរបៀបដែលអ្នកប្រើវា ហើយថែមទាំងដូច្នេះទៀតប្រសិនបើអ្នកប្រើវានៅក្នុងផលិតកម្ម។

ស្វែងយល់បន្ថែមអំពីវគ្គសិក្សា៖
ការរៀនម៉ាស៊ីន។ វគ្គសិក្សាមូលដ្ឋាន
ការរៀនម៉ាស៊ីន។ វគ្គសិក្សាកម្រិតខ្ពស់

អានបន្ថែម:

ប្រភព: www.habr.com

ពង្រីក Spark ជាមួយ MLflow