🥇MLflow ഉപയോഗിച്ച് സ്പാർക്ക് നീട്ടുന്നു

ഹലോ, ഖബ്രോവ്സ്ക് നിവാസികൾ. ഞങ്ങൾ ഇതിനകം എഴുതിയതുപോലെ, ഈ മാസം OTUS ഒരേസമയം രണ്ട് മെഷീൻ ലേണിംഗ് കോഴ്സുകൾ സമാരംഭിക്കുന്നു, അതായത് അടിസ്ഥാനം и പുരോഗമിച്ചത്. ഇക്കാര്യത്തിൽ, ഞങ്ങൾ ഉപയോഗപ്രദമായ മെറ്റീരിയൽ പങ്കിടുന്നത് തുടരുന്നു.

ഈ ലേഖനത്തിന്റെ ഉദ്ദേശ്യം ഞങ്ങളുടെ ആദ്യ അനുഭവത്തെക്കുറിച്ച് സംസാരിക്കുക എന്നതാണ് എംഎൽഫ്ലോ.

ഞങ്ങൾ അവലോകനം ആരംഭിക്കും എംഎൽഫ്ലോ അതിന്റെ ട്രാക്കിംഗ് സെർവറിൽ നിന്ന് പഠനത്തിന്റെ എല്ലാ ആവർത്തനങ്ങളും ലോഗ് ചെയ്യുക. തുടർന്ന് യു ഡി എഫ് ഉപയോഗിച്ച് സ്പാർക്കിനെ എം എൽഫ്ലോയുമായി ബന്ധിപ്പിച്ച അനുഭവം ഞങ്ങൾ പങ്കിടും.

സന്ദർഭം

ഞങ്ങൾ അകത്താണ് ആൽഫ ഹെൽത്ത് ആളുകളെ അവരുടെ ആരോഗ്യത്തിന്റെയും ക്ഷേമത്തിന്റെയും ചുമതല ഏറ്റെടുക്കാൻ പ്രാപ്തരാക്കാൻ ഞങ്ങൾ മെഷീൻ ലേണിംഗും ആർട്ടിഫിഷ്യൽ ഇന്റലിജൻസും ഉപയോഗിക്കുന്നു. അതുകൊണ്ടാണ് ഞങ്ങൾ വികസിപ്പിക്കുന്ന ഡാറ്റാ സയൻസ് ഉൽപ്പന്നങ്ങളുടെ ഹൃദയഭാഗത്ത് മെഷീൻ ലേണിംഗ് മോഡലുകൾ ഉള്ളത്, അതുകൊണ്ടാണ് ഞങ്ങൾ മെഷീൻ ലേണിംഗ് ലൈഫ് സൈക്കിളിന്റെ എല്ലാ വശങ്ങളും ഉൾക്കൊള്ളുന്ന ഒരു ഓപ്പൺ സോഴ്‌സ് പ്ലാറ്റ്‌ഫോമായ MLflow-ലേക്ക് ആകർഷിക്കപ്പെട്ടത്.

എംഎൽഫ്ലോ

MLflow ന്റെ പ്രധാന ലക്ഷ്യം, മെഷീൻ ലേണിംഗിന് മുകളിൽ ഒരു അധിക ലെയർ നൽകുക എന്നതാണ്, അത് മിക്കവാറും എല്ലാ മെഷീൻ ലേണിംഗ് ലൈബ്രറിയിലും പ്രവർത്തിക്കാൻ ഡാറ്റ ശാസ്ത്രജ്ഞരെ അനുവദിക്കും (ഹ്ക്സനുമ്ക്സൊ, keras, ചാടിവീഴുക, പൈറ്റോർച്ച്, sclearn и ടെൻസർഫ്ലോ), അവളുടെ ജോലി അടുത്ത ഘട്ടത്തിലേക്ക് കൊണ്ടുപോകുന്നു.

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 എന്നിവയുടെ പതിപ്പുകൾ പരിഹരിക്കേണ്ടതുണ്ട്, കാരണം പിന്നീടുള്ള പതിപ്പുകൾ പരസ്പരം വൈരുദ്ധ്യമുള്ളവയാണ്.

ട്രാക്കിംഗ് യുഐ സമാരംഭിക്കുക

MLflow ട്രാക്കിംഗ് പൈത്തൺ ഉപയോഗിച്ച് പരീക്ഷണങ്ങൾ ലോഗ് ചെയ്യാനും അന്വേഷിക്കാനും അനുവദിക്കുന്നു REST API. കൂടാതെ, മോഡൽ ആർട്ടിഫാക്റ്റുകൾ എവിടെ സൂക്ഷിക്കണമെന്ന് നിങ്ങൾക്ക് നിർണ്ണയിക്കാനാകും (ലോക്കൽഹോസ്റ്റ്, ആമസോൺ S3, അസൂർ ബ്ലോബ് സംഭരണം, 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 സെർവർ ഉപയോഗിക്കണമെങ്കിൽ, അവ ഫയൽ സ്റ്റോറേജിൽ ഉണ്ടായിരിക്കണമെന്ന് ഓർമ്മിക്കുക. എന്നിരുന്നാലും, ഇത് കൂടാതെ തന്നെ ഞങ്ങൾക്ക് അവരെ യു.ഡി.എഫിൽ ഉപയോഗിക്കാം, കാരണം ഞങ്ങൾക്ക് മാതൃകയിലേക്കുള്ള പാത മാത്രമേ ആവശ്യമുള്ളൂ.

ശ്രദ്ധിക്കുക: ട്രാക്കിംഗ് യുഐക്കും മോഡൽ ക്ലയന്റിനും ആർട്ടിഫാക്‌റ്റ് ലൊക്കേഷനിലേക്ക് ആക്‌സസ് ഉണ്ടായിരിക്കണമെന്ന് ഓർമ്മിക്കുക. അതായത്, ട്രാക്കിംഗ് യുഐ ഒരു 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 നിങ്ങളെ അനുവദിക്കുന്നു, അതുവഴി ആവർത്തനങ്ങളിൽ അവ എങ്ങനെ വികസിക്കുന്നു എന്ന് നിങ്ങൾക്ക് ട്രാക്ക് ചെയ്യാം. ഈ സവിശേഷത വളരെ ഉപയോഗപ്രദമാണ്, കാരണം ട്രാക്കിംഗ് സെർവറുമായി ബന്ധപ്പെടുന്നതിലൂടെയോ അല്ലെങ്കിൽ കമ്മിറ്റുകളുടെ ജിറ്റ് ഹാഷ് ലോഗുകൾ ഉപയോഗിച്ച് ഏത് കോഡാണ് ആവശ്യമായ ആവർത്തനം നടത്തിയത് എന്ന് മനസിലാക്കുന്നതിലൂടെയോ നമുക്ക് മികച്ച മോഡൽ പുനർനിർമ്മിക്കാൻ കഴിയും.

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 സെർവ് ഫംഗ്‌ഷണാലിറ്റി ഉപയോഗിച്ച് മോഡലുകൾ സെർവ് ചെയ്യുന്നതിന്, മോഡലിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ വ്യക്തമാക്കുന്നതിലൂടെ നമുക്ക് ട്രാക്കിംഗ് യുഐയിലേക്ക് ആക്‌സസ് ആവശ്യമാണ്. --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 ആരംഭിക്കുക

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 ഡ്രൈവറായി കോൺഫിഗർ ചെയ്യാൻ ഞങ്ങൾക്ക് കഴിഞ്ഞതിനാൽ, 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 നൽകുന്നു. തിരഞ്ഞെടുത്ത മോഡൽ നമ്മുടെ കൈയിൽ കിട്ടിയാലുടൻ അത് മൊഡ്യൂൾ ഉപയോഗിച്ച് യു ഡി എഫ് ആയി ഇറക്കുമതി ചെയ്യാൻ അവസരമുണ്ട്. 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 മൊഡ്യൂളുകൾ ഉപയോഗിക്കേണ്ടി വന്നാലോ?

സ്കാലയ്ക്കും പൈത്തണിനുമിടയിൽ സ്പാർക്ക് സന്ദർഭം വിഭജിച്ച് ഞങ്ങൾ ഇതും പരീക്ഷിച്ചു. അതായത്, ഞങ്ങൾ പൈത്തണിൽ MLflow UDF രജിസ്റ്റർ ചെയ്യുകയും സ്കാലയിൽ നിന്ന് അത് ഉപയോഗിക്കുകയും ചെയ്തു (അതെ, ഒരുപക്ഷേ ഏറ്റവും മികച്ച പരിഹാരമല്ല, പക്ഷേ ഞങ്ങളുടെ പക്കലുള്ളത്).

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

അറ്റാച്ച് ചെയ്ത നോട്ട്ബുക്കിൽ നിന്ന് നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, യു.ഡി.എഫ് സ്പാർക്കും പൈസ്പാർക്കും തമ്മിൽ പങ്കിടുന്നു. സ്കാലയെ ഇഷ്ടപ്പെടുന്നവർക്കും നിർമ്മാണത്തിൽ മെഷീൻ ലേണിംഗ് മോഡലുകൾ വിന്യസിക്കാൻ ആഗ്രഹിക്കുന്നവർക്കും ഈ ഭാഗം ഉപയോഗപ്രദമാകുമെന്ന് ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു.

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

MLflow ഉപയോഗിച്ച് സ്പാർക്ക് നീട്ടുന്നു