హలో, ఖబ్రోవ్స్క్ నివాసితులు. మేము ఇప్పటికే వ్రాసినట్లుగా, ఈ నెల OTUS ఒకేసారి రెండు మెషిన్ లెర్నింగ్ కోర్సులను ప్రారంభిస్తోంది, అవి и . ఈ విషయంలో, మేము ఉపయోగకరమైన విషయాలను పంచుకోవడం కొనసాగిస్తాము.
ఈ కథనం యొక్క ఉద్దేశ్యం ఉపయోగించిన మా మొదటి అనుభవం గురించి మాట్లాడటం .
మేము సమీక్షను ప్రారంభిస్తాము దాని ట్రాకింగ్ సర్వర్ నుండి మరియు అధ్యయనం యొక్క అన్ని పునరావృత్తులు లాగ్ చేయండి. అప్పుడు మేము UDFని ఉపయోగించి MLflowతో స్పార్క్‌ని కనెక్ట్ చేసిన మా అనుభవాన్ని పంచుకుంటాము.
సందర్భంలో
మేము ఉన్నాము ప్రజలు వారి ఆరోగ్యం మరియు శ్రేయస్సుపై బాధ్యత వహించడానికి అధికారం కోసం మేము మెషిన్ లెర్నింగ్ మరియు కృత్రిమ మేధస్సును ఉపయోగిస్తాము. అందుకే మేము అభివృద్ధి చేసే డేటా సైన్స్ ఉత్పత్తులకు మెషిన్ లెర్నింగ్ మోడల్‌లు ప్రధానమైనవి, అందుకే మేము మెషీన్ లెర్నింగ్ లైఫ్‌సైకిల్‌లోని అన్ని అంశాలను కవర్ చేసే ఓపెన్ సోర్స్ ప్లాట్‌ఫారమ్ అయిన MLflowకి ఆకర్షితులయ్యాము.
ML ఫ్లో
MLflow యొక్క ప్రధాన లక్ష్యం మెషిన్ లెర్నింగ్ పైన అదనపు పొరను అందించడం, ఇది డేటా శాస్త్రవేత్తలు దాదాపు ఏదైనా మెషీన్ లెర్నింగ్ లైబ్రరీతో పని చేయడానికి అనుమతిస్తుంది (, , , , и ), ఆమె పనిని తదుపరి స్థాయికి తీసుకెళ్లడం.
MLflow మూడు భాగాలను అందిస్తుంది:
- ట్రాకింగ్ - రికార్డింగ్ మరియు ప్రయోగాల కోసం అభ్యర్థనలు: కోడ్, డేటా, కాన్ఫిగరేషన్ మరియు ఫలితాలు. నమూనాను సృష్టించే ప్రక్రియను పర్యవేక్షించడం చాలా ముఖ్యం.
- ప్రాజెక్ట్స్ - ఏదైనా ప్లాట్‌ఫారమ్‌లో అమలు చేయడానికి ప్యాకేజింగ్ ఫార్మాట్ (ఉదా. )
- మోడల్స్ - వివిధ విస్తరణ సాధనాలకు నమూనాలను సమర్పించడానికి ఒక సాధారణ ఆకృతి.
MLflow (వ్రాసే సమయంలో ఆల్ఫాలో) అనేది ఒక ఓపెన్ సోర్స్ ప్లాట్‌ఫారమ్, ఇది ప్రయోగం, పునర్వినియోగం మరియు విస్తరణతో సహా మెషిన్ లెర్నింగ్ జీవితచక్రాన్ని నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది.
MLflowని సెటప్ చేస్తోంది
MLflowని ఉపయోగించడానికి మీరు ముందుగా మీ మొత్తం పైథాన్ వాతావరణాన్ని సెటప్ చేయాలి, దీని కోసం మేము ఉపయోగిస్తాము (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. అదనంగా, మోడల్ కళాఖండాలను ఎక్కడ నిల్వ చేయాలో మీరు నిర్ణయించవచ్చు (లోకల్ హోస్ట్, , , లేదా ) మేము ఆల్ఫా హెల్త్‌లో 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 మరియు మోడల్ క్లయింట్ తప్పనిసరిగా ఆర్టిఫ్యాక్ట్ లొకేషన్‌కు యాక్సెస్ కలిగి ఉండాలని గుర్తుంచుకోండి. అంటే, ట్రాకింగ్ 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 ఈ చిరునామాలో లాంచ్ సమాచారం, లాగ్ మెట్రిక్‌లు మొదలైనవాటిని సృష్టించడానికి/స్వీకరించడానికి స్వయంచాలకంగా ట్రాకింగ్ సర్వర్‌ని సంప్రదిస్తుంది.
మూలం:
మోడల్‌ను సర్వర్‌తో అందించడానికి, మాకు నడుస్తున్న ట్రాకింగ్ సర్వర్ (లాంచ్ ఇంటర్‌ఫేస్ చూడండి) మరియు మోడల్ యొక్క రన్ 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 సర్వ్ ఫంక్షనాలిటీని ఉపయోగించి మోడల్‌లను అందించడానికి, పేర్కొనడం ద్వారా మోడల్ గురించి సమాచారాన్ని స్వీకరించడానికి మాకు ట్రాకింగ్ 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ని ఇన్‌స్టాల్ చేయండి
మూలం:
మేము Spark డేటాఫ్రేమ్‌లకు MLflow మోడల్‌లను ఎలా వర్తింపజేస్తామో చూపించడానికి, PySparkతో కలిసి పని చేయడానికి మేము జూపిటర్ నోట్‌బుక్‌లను సెటప్ చేయాలి.
తాజా స్థిరమైన సంస్కరణను ఇన్‌స్టాల్ చేయడం ద్వారా ప్రారంభించండి :
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 డ్రైవర్‌గా కాన్ఫిగర్ చేయగలిగాము కాబట్టి, ఇప్పుడు మనం 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
పైన పేర్కొన్నట్లుగా, 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ని ఎలా ఉపయోగించాలో గురించి మాట్లాడాము, మొత్తం వైన్ డేటాసెట్‌లో వైన్ నాణ్యత అంచనాలను అమలు చేయడం. మీరు స్కాలా స్పార్క్ నుండి పైథాన్ MLflow మాడ్యూల్‌లను ఉపయోగించాల్సి వస్తే ఏమి చేయాలి?
మేము Scala మరియు Python మధ్య స్పార్క్ సందర్భాన్ని విభజించడం ద్వారా దీనిని కూడా పరీక్షించాము. అంటే, మేము MLflow UDFని పైథాన్‌లో నమోదు చేసాము మరియు దానిని 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 స్పార్క్ మరియు పైస్పార్క్ మధ్య భాగస్వామ్యం చేయబడింది. స్కాలాను ఇష్టపడే మరియు ఉత్పత్తిలో మెషిన్ లెర్నింగ్ మోడల్‌లను అమలు చేయాలనుకునే వారికి ఈ భాగం ఉపయోగకరంగా ఉంటుందని మేము ఆశిస్తున్నాము.
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 కమ్యూనిటీకి ధన్యవాదాలు చెప్పాలనుకుంటున్నాను.
మీరు MLflowతో ఆడుతున్నట్లయితే, మాకు వ్రాయడానికి వెనుకాడకండి మరియు మీరు దీన్ని ఎలా ఉపయోగిస్తున్నారో మాకు చెప్పండి మరియు మీరు దీన్ని ఉత్పత్తిలో ఉపయోగిస్తే ఇంకా ఎక్కువగా.
కోర్సుల గురించి మరింత తెలుసుకోండి:
ఇంకా చదవండి:
మూలం: www.habr.com