MLflow සමඟ Spark දිගු කිරීම

හෙලෝ, Khabrovsk පදිංචිකරුවන්. අප දැනටමත් ලියා ඇති පරිදි, මේ මාසයේ OTUS විසින් යන්ත්‍ර ඉගෙනුම් පාඨමාලා දෙකක් එකවර දියත් කරයි, එනම් පදනම и උසස්. මේ සම්බන්ධයෙන්, අපි දිගටම ප්රයෝජනවත් ද්රව්ය බෙදා හදා ගන්නෙමු.

මෙම ලිපියේ අරමුණ භාවිතා කිරීම අපගේ පළමු අත්දැකීම ගැන කතා කිරීමයි ML ප්රවාහය.

අපි සමාලෝචනය ආරම්භ කරන්නෙමු ML ප්රවාහය එහි ලුහුබැඳීමේ සේවාදායකයෙන් සහ අධ්‍යයනයේ සියලුම පුනරාවර්තන සටහන් කරන්න. එවිට අපි UDF භාවිතයෙන් MLflow සමඟ Spark සම්බන්ධ කිරීමේ අපගේ අත්දැකීම් බෙදා ගන්නෙමු.

සන්දර්භය

අපි ඇතුලේ ඇල්ෆා සෞඛ්ය මිනිසුන්ට ඔවුන්ගේ සෞඛ්‍යය සහ යහපැවැත්ම භාර ගැනීමට බලය ලබා දීම සඳහා අපි යන්ත්‍ර ඉගෙනීම සහ කෘතිම බුද්ධිය භාවිතා කරමු. යන්ත්‍ර ඉගෙනුම් ආකෘති අප විසින් වර්ධනය කරන දත්ත විද්‍යා නිෂ්පාදනවල හදවතෙහි පිහිටා ඇත්තේ එබැවිනි, සහ යන්ත්‍ර ඉගෙනුම් ජීවන චක්‍රයේ සියලුම අංග ආවරණය කරන විවෘත මූලාශ්‍ර වේදිකාවක් වන MLflow වෙත අපව ඇදී ගියේ එබැවිනි.

ML ප්රවාහය

MLflow හි ප්‍රධාන පරමාර්ථය වන්නේ දත්ත විද්‍යාඥයින්ට ඕනෑම යන්ත්‍ර ඉගෙනුම් පුස්තකාලයක් සමඟ වැඩ කිරීමට ඉඩ සලසන යන්ත්‍ර ඉගෙනීම මත අමතර ස්ථරයක් සැපයීමයි (h2o, keras, පැනීම, පයිටෝර්ච්, sklearn и ආතන්‍ය ප්‍රවාහය), ඇයගේ කාර්යය ඊළඟ මට්ටමට ගෙන යාම.

MLflow සංරචක තුනක් සපයයි:

• ට්රැකින් - පටිගත කිරීම සහ අත්හදා බැලීම් සඳහා ඉල්ලීම්: කේතය, දත්ත, වින්‍යාසය සහ ප්‍රතිඵල. ආකෘතියක් නිර්මාණය කිරීමේ ක්රියාවලිය නිරීක්ෂණය කිරීම ඉතා වැදගත් වේ.
• ව්යාපෘති - ඕනෑම වේදිකාවක ධාවනය කිරීමට ඇසුරුම් ආකෘතිය (උදා. SageMaker)
• ආකෘති - විවිධ යෙදවුම් මෙවලම් සඳහා ආකෘති ඉදිරිපත් කිරීම සඳහා පොදු ආකෘතියක්.

MLflow (ලියන අවස්ථාවේ ඇල්ෆා වලින්) යනු අත්හදා බැලීම්, නැවත භාවිතා කිරීම සහ යෙදවීම ඇතුළුව යන්ත්‍ර ඉගෙනීමේ ජීවන චක්‍රය කළමනාකරණය කිරීමට ඔබට ඉඩ සලසන විවෘත මූලාශ්‍ර වේදිකාවකි.

MLflow සැකසීම

MLflow භාවිතා කිරීමට ඔබ මුලින්ම ඔබේ සම්පූර්ණ පයිතන් පරිසරය සැකසිය යුතුය, මේ සඳහා අපි භාවිතා කරමු PyEnv (Mac මත Python ස්ථාපනය කිරීමට, පරීක්ෂා කරන්න මෙහි) මේ ආකාරයෙන් අපට අථත්‍ය පරිසරයක් නිර්මාණය කළ හැකි අතර එහිදී එය ක්‍රියාත්මක කිරීමට අවශ්‍ය සියලුම පුස්තකාල ස්ථාපනය කරමු.

```
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 ලුහුබැඳීම මගින් Python සහ භාවිතා කර අත්හදා බැලීම් ලොග් කිරීමට සහ විමසීමට අපට ඉඩ සලසයි රෙස්ට් API. මීට අමතරව, ඔබට ආකෘති කෞතුක වස්තු ගබඩා කළ යුතු ස්ථානය තීරණය කළ හැකිය (localhost, ඇමේසන් S3, Azure Blob ගබඩාව, Google වළාකුළු ගබඩාව හෝ SFTP සේවාදායකය) අපි Alpha Health හි 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 සේවාදායකය භාවිතා කිරීමට අවශ්‍ය නම්, ඒවා ගොනු ගබඩාවේ තිබිය යුතු බව මතක තබා ගන්න. කෙසේ වෙතත්, මෙය නොමැතිව වුවද අපට ඒවා යූඩීඑෆ් හි භාවිතා කළ හැකිය, මන්ද අපට අවශ්‍ය වන්නේ ආකෘතියට යන මාර්ගය පමණි.

සටහන: ලුහුබැඳීමේ 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 හැෂ් ලොග් භාවිතයෙන් අවශ්‍ය පුනරාවර්තනය සිදු කළේ කුමන කේතයද යන්න තේරුම් ගැනීමෙන් හොඳම ආකෘතිය ප්‍රතිනිෂ්පාදනය කළ හැකි බැවිනි.

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 විසින් දියත් කිරීමේ තොරතුරු, ලොග් ප්‍රමිතික ආදිය සෑදීමට/ලබා ගැනීමට මෙම ලිපිනයෙහි ඇති ට්‍රැකින් සර්වර් වෙත ස්වයංක්‍රීයව සම්බන්ධ වේ.

මූලාශ්රය: Docs// ලුහුබැඳීමේ සේවාදායකයක් ධාවනය කිරීම

සේවාදායකයක් සමඟ ආකෘතිය සැපයීම සඳහා, අපට ධාවන ලුහුබැඳීමේ සේවාදායකයක් අවශ්‍ය වේ (දියත් කිරීමේ අතුරුමුහුණත බලන්න) සහ ආකෘතියේ ධාවන හැඳුනුම්පත.

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 සේවා ක්‍රියාකාරීත්වය භාවිතා කරමින් ආකෘති සැපයීම සඳහා, නිශ්චය කිරීමෙන් ආකෘතිය පිළිබඳ තොරතුරු ලබාගැනීමට අපට ට්‍රැකින් 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 // models # local), Spark (batch හෝ streaming) භාවිතය බෙදා හැරීම හේතුවෙන් ඊටත් වඩා බලවත් විසඳුමකි.

ඔබ හුදෙක් නොබැඳි පුහුණුව සිදු කර පසුව ඔබේ සියලු දත්ත වලට ප්‍රතිදාන ආකෘතිය යෙදුවා යැයි සිතන්න. Spark සහ MLflow දිලිසෙන ස්ථානය මෙයයි.

PySpark + Jupyter + Spark ස්ථාපනය කරන්න

මූලාශ්රය: ආරම්භ කරන්න PySpark - Jupyter

අපි Spark දත්ත රාමු වලට MLflow මාදිලි යොදන ආකාරය පෙන්වීමට, 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 දියත් කිරීම

අපට බ්‍රහස්පති PySpark ධාවකයක් ලෙස වින්‍යාස කිරීමට හැකි වූ බැවින්, දැන් අපට 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)

PySpark - වයින් තත්ත්ව අනාවැකි නිකුත් කිරීම

මෙම අවස්ථාව දක්වා, අපි MLflow සමඟ PySpark භාවිතා කරන්නේ කෙසේද යන්න ගැන කතා කර ඇත, සම්පූර්ණ වයින් දත්ත කට්ටලය මත වයින් තත්ත්ව අනාවැකි ධාවනය කරයි. නමුත් ඔබට Scala Spark වෙතින් Python MLflow මොඩියුල භාවිතා කිරීමට අවශ්‍ය නම් කුමක් කළ යුතුද?

Scala සහ Python අතර Spark සන්දර්භය බෙදීමෙන් අපි මෙයද පරීක්‍ෂා කළෙමු. එනම්, අපි 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 и ඇතීනා එකම Glue metastore සමඟ.

සාරාංශගත කිරීම සඳහා, දත්ත සමඟ අපගේ කාර්යය වඩාත් සිත්ගන්නාසුළු කිරීමට MLFlow ප්‍රජාවට ස්තුති කිරීමට මම කැමතියි.

ඔබ MLflow සමඟ සෙල්ලම් කරන්නේ නම්, අපට ලිවීමට පසුබට නොවන්න, ඔබ එය භාවිතා කරන ආකාරය අපට කියන්න, ඊටත් වඩා ඔබ එය නිෂ්පාදනයේදී භාවිතා කරන්නේ නම්.

පාඨමාලා ගැන වැඩි විස්තර දැනගන්න:
යන්ත්‍ර ඉගෙනීම. මූලික පාඨමාලාව
යන්ත්‍ර ඉගෙනීම. උසස් පාඨමාලාව

තවත් කියවන්න:

• අධීක්ෂණ ඉගෙනුම් ගැටළු සඳහා ප්‍රධාන සංරචක විශ්ලේෂණය යෙදීමේ අවදානම් සහ අනතුරු ඇඟවීම්
• ඩොකර් සමඟ යන්ත්‍ර ඉගෙනුම් ආකෘතියක් යෙදවීම - 1 කොටස
• ඩොකර් සමඟ යන්ත්‍ර ඉගෙනුම් ආකෘතියක් යෙදවීම - 2 කොටස

මූලාශ්රය: www.habr.com