MLflow સાથે સ્પાર્ક વિસ્તરે છે

હેલો, ખાબ્રોવસ્ક રહેવાસીઓ. અમે પહેલેથી જ લખ્યું છે તેમ, આ મહિને OTUS એક સાથે બે મશીન લર્નિંગ કોર્સ શરૂ કરી રહ્યું છે, એટલે કે પાયો и અદ્યતન. આ સંદર્ભે, અમે ઉપયોગી સામગ્રી શેર કરવાનું ચાલુ રાખીએ છીએ.

આ લેખનો હેતુ અમારા ઉપયોગના પ્રથમ અનુભવ વિશે વાત કરવાનો છે MLflow.

અમે સમીક્ષા શરૂ કરીશું MLflow તેના ટ્રેકિંગ સર્વરમાંથી અને અભ્યાસના તમામ પુનરાવર્તનોને લોગ કરો. પછી અમે UDF નો ઉપયોગ કરીને MLflow સાથે Spark ને કનેક્ટ કરવાનો અમારો અનુભવ શેર કરીશું.

સંદર્ભ

અમે અંદર છીએ આલ્ફા આરોગ્ય અમે મશીન લર્નિંગ અને આર્ટિફિશિયલ ઇન્ટેલિજન્સનો ઉપયોગ લોકોને તેમના સ્વાસ્થ્ય અને સુખાકારીની જવાબદારી લેવા માટે સશક્ત બનાવવા માટે કરીએ છીએ. એટલા માટે મશીન લર્નિંગ મૉડલ્સ અમે વિકસિત કરીએ છીએ તે ડેટા સાયન્સ પ્રોડક્ટ્સના હાર્દમાં છે, અને તેથી જ અમે MLflow, એક ઓપન સોર્સ પ્લેટફોર્મ કે જે મશીન લર્નિંગ લાઇફસાઇકલના તમામ પાસાઓને આવરી લે છે, તરફ આકર્ષાયા હતા.

MLflow

MLflowનું મુખ્ય ધ્યેય મશીન લર્નિંગની ટોચ પર એક વધારાનું સ્તર પૂરું પાડવાનું છે જે ડેટા વૈજ્ઞાનિકોને લગભગ કોઈપણ મશીન લર્નિંગ લાઇબ્રેરી સાથે કામ કરવાની મંજૂરી આપશે (h2O, કેરા, mleap, પીટોર્ચ, sklearn и ટેન્સફોર્લો), તેણીના કાર્યને આગલા સ્તર પર લઈ જઈ રહ્યા છે.

MLflow ત્રણ ઘટકો પ્રદાન કરે છે:

• ટ્રેકિંગ - રેકોર્ડિંગ અને પ્રયોગો માટેની વિનંતીઓ: કોડ, ડેટા, ગોઠવણી અને પરિણામો. મોડેલ બનાવવાની પ્રક્રિયાનું નિરીક્ષણ કરવું ખૂબ જ મહત્વપૂર્ણ છે.
• પ્રોજેક્ટ્સ - કોઈપણ પ્લેટફોર્મ પર ચલાવવા માટે પેકેજિંગ ફોર્મેટ (દા.ત. સેજમેકર)
• મોડલ્સ - વિવિધ ડિપ્લોયમેન્ટ ટૂલ્સ પર મોડલ્સ સબમિટ કરવા માટેનું સામાન્ય ફોર્મેટ.

MLflow (લેખવાના સમયે આલ્ફામાં) એક ઓપન સોર્સ પ્લેટફોર્મ છે જે તમને પ્રયોગ, પુનઃઉપયોગ અને જમાવટ સહિત મશીન લર્નિંગ લાઇફસાઇકલનું સંચાલન કરવાની મંજૂરી આપે છે.

MLflow સેટ કરી રહ્યું છે

MLflow નો ઉપયોગ કરવા માટે તમારે પહેલા તમારા સમગ્ર પાયથોન પર્યાવરણને સેટ કરવાની જરૂર છે, આ માટે અમે ઉપયોગ કરીશું PyEnv (મેક પર પાયથોન ઇન્સ્ટોલ કરવા માટે, તપાસો અહીં). આ રીતે આપણે વર્ચ્યુઅલ વાતાવરણ બનાવી શકીએ છીએ જ્યાં આપણે તેને ચલાવવા માટે જરૂરી બધી લાઇબ્રેરીઓ ઇન્સ્ટોલ કરીશું.

```
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 અને નો ઉપયોગ કરીને પ્રયોગોને લોગ અને ક્વેરી કરવાની મંજૂરી આપે છે REST API. વધુમાં, તમે નક્કી કરી શકો છો કે મોડેલ આર્ટિફેક્ટ્સ ક્યાં સંગ્રહિત કરવી (લોકલહોસ્ટ, એમેઝોન S3, એઝ્યુર બ્લોબ સ્ટોરેજ, ગૂગલ મેઘ સ્ટોરેજ અથવા 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 સર્વરનો ઉપયોગ કરવા માગીએ છીએ, તો તે ફાઇલ સ્ટોરેજમાં હાજર હોવા જોઈએ. જો કે, આ વિના પણ અમે તેનો ઉપયોગ 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 તમને મોડલ પેરામીટર્સ, મેટ્રિક્સ અને આર્ટિફેક્ટ્સને લૉગ કરવાની મંજૂરી આપે છે જેથી કરીને તમે ટ્રૅક કરી શકો કે તેઓ પુનરાવર્તનો પર કેવી રીતે વિકસિત થાય છે. આ સુવિધા અત્યંત ઉપયોગી છે કારણ કે આ રીતે અમે ટ્રેકિંગ સર્વરનો સંપર્ક કરીને અથવા કમિટ્સના ગિટ હેશ લોગનો ઉપયોગ કરીને કયા કોડે જરૂરી પુનરાવર્તન કર્યું છે તે સમજીને શ્રેષ્ઠ મોડલનું પુનઃઉત્પાદન કરી શકીએ છીએ.

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” નો ઉપયોગ કરીને ટ્રેકિંગ સર્વર સરનામું નિર્દિષ્ટ કરી શકો છો અને 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 // docs // models # local), વિતરણને કારણે સ્પાર્ક (બેચ અથવા સ્ટ્રીમિંગ) નો ઉપયોગ વધુ શક્તિશાળી ઉકેલ છે.

કલ્પના કરો કે તમે ફક્ત ઑફલાઇન તાલીમ કરી અને પછી તમારા બધા ડેટા પર આઉટપુટ મોડેલ લાગુ કર્યું. આ તે છે જ્યાં સ્પાર્ક અને 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

ઉપર સૂચવ્યા મુજબ, 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 - આઉટપુટિંગ વાઇનની ગુણવત્તાની આગાહીઓ

આ બિંદુ સુધી, અમે MLflow સાથે PySpark નો ઉપયોગ કેવી રીતે કરવો તે વિશે વાત કરી છે, સમગ્ર વાઇન ડેટાસેટ પર વાઇનની ગુણવત્તાની આગાહીઓ ચાલી રહી છે. પરંતુ જો તમારે સ્કેલા સ્પાર્કમાંથી પાયથોન એમએલફ્લો મોડ્યુલોનો ઉપયોગ કરવાની જરૂર હોય તો શું?

અમે સ્કેલા અને પાયથોન વચ્ચે સ્પાર્ક સંદર્ભને વિભાજિત કરીને પણ આનું પરીક્ષણ કર્યું છે. એટલે કે, અમે 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 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 પાઇપલાઇન્સ અને ભલામણકર્તા સિસ્ટમો માટે કરીશું.

ફાઇલ સિસ્ટમને બદલે ડેટાબેઝ સાથે ફાઇલ સ્ટોરેજને સિંક્રનાઇઝ કરવું સરસ રહેશે. આનાથી અમને બહુવિધ અંતિમ બિંદુઓ મળવા જોઈએ જે સમાન ફાઇલ સ્ટોરેજનો ઉપયોગ કરી શકે. ઉદાહરણ તરીકે, બહુવિધ ઉદાહરણોનો ઉપયોગ કરો પ્રેસ્ટો и એથેના સમાન ગુંદર મેટાસ્ટોર સાથે.

સારાંશ માટે, હું ડેટા સાથેના અમારા કાર્યને વધુ રસપ્રદ બનાવવા માટે MLFlow સમુદાયનો આભાર કહેવા માંગુ છું.

જો તમે MLflow સાથે રમી રહ્યાં છો, તો અમને લખવામાં અચકાશો નહીં અને અમને જણાવો કે તમે તેનો ઉપયોગ કેવી રીતે કરો છો, અને તેથી પણ વધુ જો તમે ઉત્પાદનમાં તેનો ઉપયોગ કરો છો.

અભ્યાસક્રમો વિશે વધુ જાણો:
મશીન લર્નિંગ. મૂળભૂત અભ્યાસક્રમ
મશીન લર્નિંગ. એડવાન્સ કોર્સ

વધુ વાંચો:

• નિરીક્ષિત શીખવાની સમસ્યાઓ માટે મુખ્ય ઘટક વિશ્લેષણ લાગુ કરવાના જોખમો અને સાવચેતીઓ
• ડોકર સાથે મશીન લર્નિંગ મોડલ જમાવવું – ભાગ 1
• ડોકર સાથે મશીન લર્નિંગ મોડલ જમાવવું – ભાગ 2

સોર્સ: www.habr.com