MLOps - കുക്ക് ബുക്ക്, അധ്യായം 1

എല്ലാവർക്കും ഹായ്! ഞാൻ CROC-യിലെ ഒരു CV ഡെവലപ്പറാണ്. ഞങ്ങൾ ഇപ്പോൾ 3 വർഷമായി സിവി മേഖലയിൽ പദ്ധതികൾ നടപ്പിലാക്കുന്നു. ഈ സമയത്ത്, ഞങ്ങൾ ധാരാളം കാര്യങ്ങൾ ചെയ്തു, ഉദാഹരണത്തിന്: ഞങ്ങൾ ഡ്രൈവർമാരെ നിരീക്ഷിച്ചു, അങ്ങനെ വാഹനമോടിക്കുമ്പോൾ അവർ മദ്യപിക്കരുത്, പുകവലിക്കരുത്, ഫോണിൽ സംസാരിക്കരുത്, റോഡിലേക്ക് നോക്കുക, സ്വപ്നങ്ങളിലോ മേഘങ്ങളിലോ അല്ല. ; സമർപ്പിത പാതകളിൽ വാഹനമോടിക്കുകയും നിരവധി പാർക്കിംഗ് സ്ഥലങ്ങൾ എടുക്കുകയും ചെയ്യുന്ന ആളുകളെ ഞങ്ങൾ റെക്കോർഡുചെയ്‌തു; തൊഴിലാളികൾ ഹെൽമറ്റ്, കയ്യുറകൾ മുതലായവ ധരിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പുവരുത്തി; സൗകര്യത്തിൽ പ്രവേശിക്കാൻ ആഗ്രഹിക്കുന്ന ഒരു ജീവനക്കാരനെ തിരിച്ചറിഞ്ഞു; ഞങ്ങൾക്ക് കഴിയുന്നതെല്ലാം ഞങ്ങൾ എണ്ണി.

ഞാൻ എന്തിനു വേണ്ടിയാണ് ഇതെല്ലാം ചെയ്യുന്നത്?

പ്രോജക്റ്റുകൾ നടപ്പിലാക്കുന്ന പ്രക്രിയയിൽ, ഞങ്ങൾ ബമ്പുകൾ, ഒരുപാട് ബമ്പുകൾ, നിങ്ങൾക്ക് പരിചിതമായ അല്ലെങ്കിൽ ഭാവിയിൽ പരിചയപ്പെടാൻ പോകുന്ന ചില പ്രശ്നങ്ങൾ.

നമുക്ക് സാഹചര്യം അനുകരിക്കാം

ML-മായി ബന്ധപ്പെട്ട ഒരു യുവ കമ്പനിയായ "N"-ൽ ഞങ്ങൾക്ക് ജോലി ലഭിച്ചുവെന്ന് സങ്കൽപ്പിക്കുക. ഞങ്ങൾ ഒരു ML (DL, CV) പ്രോജക്റ്റിൽ പ്രവർത്തിക്കുന്നു, പിന്നീട് ചില കാരണങ്ങളാൽ ഞങ്ങൾ മറ്റൊരു ജോലിയിലേക്ക് മാറുന്നു, പൊതുവെ ഒരു ഇടവേള എടുത്ത് ഞങ്ങളുടെ സ്വന്തം അല്ലെങ്കിൽ മറ്റൊരാളുടെ ന്യൂറോണിലേക്ക് മടങ്ങുന്നു.

1. സത്യത്തിന്റെ നിമിഷം വരുന്നു, നിങ്ങൾ എവിടെയാണ് നിർത്തിയതെന്നും ഏത് ഹൈപ്പർപാരാമീറ്ററുകൾ പരീക്ഷിച്ചുവെന്നും ഏറ്റവും പ്രധാനമായി അവ എന്ത് ഫലങ്ങളിലേക്ക് നയിച്ചുവെന്നും നിങ്ങൾ എങ്ങനെയെങ്കിലും ഓർക്കേണ്ടതുണ്ട്. എല്ലാ ലോഞ്ചുകളിലും ആരാണ് വിവരങ്ങൾ സംഭരിച്ചത് എന്നതിന് നിരവധി ഓപ്ഷനുകൾ ഉണ്ടാകാം: തലയിൽ, കോൺഫിഗറുകളിൽ, നോട്ട്പാഡിൽ, ക്ലൗഡിലെ പ്രവർത്തന അന്തരീക്ഷത്തിൽ. ഹൈപ്പർപാരാമീറ്ററുകൾ കോഡിലെ കമന്റ് ചെയ്ത ലൈനുകളായി സംഭരിച്ചിരിക്കുമ്പോൾ ഞാൻ ഒരു ഓപ്ഷൻ കാണാനിടയായി, പൊതുവേ, ഫാൻസി ഒരു ഫ്ലൈറ്റ്. ഇപ്പോൾ നിങ്ങൾ മടങ്ങിയെത്തിയത് നിങ്ങളുടെ പ്രോജക്റ്റിലേക്കല്ല, കമ്പനി വിട്ടുപോയ ഒരു വ്യക്തിയുടെ പ്രോജക്റ്റിലേക്കാണ്, നിങ്ങൾക്ക് ഒരു കോഡും model_1.pb എന്ന മോഡലും പാരമ്പര്യമായി ലഭിച്ചുവെന്ന് സങ്കൽപ്പിക്കുക. ചിത്രം പൂർത്തിയാക്കാനും എല്ലാ വേദനകളും അറിയിക്കാനും, നിങ്ങൾ ഒരു തുടക്കക്കാരനായ സ്പെഷ്യലിസ്റ്റ് കൂടിയാണെന്ന് സങ്കൽപ്പിക്കുക.
2. മുന്നോട്ടുപോകുക. കോഡ് പ്രവർത്തിപ്പിക്കുന്നതിന്, ഞങ്ങളും അതിനൊപ്പം പ്രവർത്തിക്കുന്ന എല്ലാവരും ഒരു അന്തരീക്ഷം സൃഷ്ടിക്കേണ്ടതുണ്ട്. ചില കാരണങ്ങളാൽ അവർ അവനെ നമ്മുടെ അവകാശമായി ഉപേക്ഷിച്ചില്ല എന്നത് പലപ്പോഴും സംഭവിക്കുന്നു. ഇതും നിസ്സാരമല്ലാത്ത ജോലിയായി മാറാം. ഈ ഘട്ടത്തിൽ സമയം പാഴാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ല, അല്ലേ?
3. ഞങ്ങൾ ഒരു മോഡൽ പരിശീലിപ്പിക്കുന്നു (ഉദാഹരണത്തിന്, ഒരു കാർ ഡിറ്റക്ടർ). അത് വളരെ മികച്ചതായി മാറുന്ന ഘട്ടത്തിലേക്ക് ഞങ്ങൾ എത്തിച്ചേരുന്നു - ഫലം സംരക്ഷിക്കാനുള്ള സമയമാണിത്. നമുക്ക് ഇതിനെ car_detection_v1.pb എന്ന് വിളിക്കാം. തുടർന്ന് ഞങ്ങൾ മറ്റൊന്ന് പരിശീലിപ്പിക്കുന്നു - car_detection_v2.pb. കുറച്ച് സമയത്തിന് ശേഷം, ഞങ്ങളുടെ സഹപ്രവർത്തകർ അല്ലെങ്കിൽ ഞങ്ങൾ തന്നെ വ്യത്യസ്ത വാസ്തുവിദ്യകൾ ഉപയോഗിച്ച് കൂടുതൽ കൂടുതൽ പഠിപ്പിക്കുന്നു. തൽഫലമായി, ഒരു കൂട്ടം പുരാവസ്തുക്കൾ രൂപം കൊള്ളുന്നു, അവയെക്കുറിച്ചുള്ള വിവരങ്ങൾ കഠിനമായി ശേഖരിക്കണം (എന്നാൽ ഞങ്ങൾ ഇത് പിന്നീട് ചെയ്യും, കാരണം ഇപ്പോൾ ഞങ്ങൾക്ക് കൂടുതൽ മുൻഗണനകളുണ്ട്).
4. ശരി ഇപ്പോൾ എല്ലാം കഴിഞ്ഞു! ഞങ്ങൾക്ക് ഒരു മാതൃകയുണ്ട്! നമുക്ക് അടുത്ത മോഡൽ പരിശീലിപ്പിക്കാൻ കഴിയുമോ, ഒരു പുതിയ പ്രശ്നം പരിഹരിക്കാൻ ഒരു വാസ്തുവിദ്യ വികസിപ്പിച്ചെടുക്കാമോ, അല്ലെങ്കിൽ നമുക്ക് ചായ കുടിക്കാൻ പോകാമോ? പിന്നെ ആരു വിന്യസിക്കും?

പ്രശ്നങ്ങൾ തിരിച്ചറിയൽ

ഒരു പ്രോജക്റ്റിലോ ഉൽപ്പന്നത്തിലോ പ്രവർത്തിക്കുന്നത് പലരുടെയും ജോലിയാണ്. കാലക്രമേണ, ആളുകൾ പോയി വരുന്നു, കൂടുതൽ പ്രോജക്റ്റുകൾ ഉണ്ട്, പദ്ധതികൾ തന്നെ കൂടുതൽ സങ്കീർണ്ണമാകും. ഒരു തരത്തിൽ അല്ലെങ്കിൽ മറ്റൊരു തരത്തിൽ, മുകളിൽ വിവരിച്ച (മാത്രമല്ല) സൈക്കിളിൽ നിന്നുള്ള സാഹചര്യങ്ങൾ ചില കോമ്പിനേഷനുകളിൽ ആവർത്തനത്തിൽ നിന്ന് ആവർത്തനത്തിലേക്ക് സംഭവിക്കും. ഇതെല്ലാം പാഴായ സമയം, ആശയക്കുഴപ്പം, ഞരമ്പുകൾ, ഒരുപക്ഷേ ഉപഭോക്തൃ അതൃപ്തി, ആത്യന്തികമായി പണം നഷ്ടപ്പെടൽ എന്നിവയിൽ കലാശിക്കുന്നു. നാമെല്ലാവരും സാധാരണയായി ഒരേ പഴയ റേക്ക് പിന്തുടരുന്നുണ്ടെങ്കിലും, ഈ നിമിഷങ്ങൾ വീണ്ടും വീണ്ടും ആവർത്തിക്കാൻ ആരും ആഗ്രഹിക്കുന്നില്ലെന്ന് ഞാൻ വിശ്വസിക്കുന്നു.

അതിനാൽ, ഞങ്ങൾ ഒരു വികസന ചക്രത്തിലൂടെ കടന്നുപോയി, പരിഹരിക്കപ്പെടേണ്ട പ്രശ്നങ്ങൾ ഉണ്ടെന്ന് ഞങ്ങൾ കാണുന്നു. ഇത് ചെയ്യുന്നതിന് നിങ്ങൾക്ക് ഇത് ആവശ്യമാണ്:

• ജോലി ഫലങ്ങൾ സൗകര്യപ്രദമായി സംഭരിക്കുക;
• പുതിയ ജീവനക്കാരെ ഉൾപ്പെടുത്തുന്ന പ്രക്രിയ ലളിതമാക്കുക;
• ഒരു വികസന അന്തരീക്ഷം വിന്യസിക്കുന്ന പ്രക്രിയ ലളിതമാക്കുക;
• മോഡൽ പതിപ്പിംഗ് പ്രക്രിയ കോൺഫിഗർ ചെയ്യുക;
• മോഡലുകൾ സാധൂകരിക്കുന്നതിന് സൗകര്യപ്രദമായ മാർഗമുണ്ട്;
• ഒരു മാതൃകാ സംസ്ഥാന മാനേജ്മെന്റ് ഉപകരണം കണ്ടെത്തുക;
• ഉൽപ്പാദനത്തിലേക്ക് മോഡലുകൾ എത്തിക്കുന്നതിനുള്ള ഒരു മാർഗം കണ്ടെത്തുക.

ഈ ജീവിത ചക്രം എളുപ്പത്തിലും സൗകര്യപ്രദമായും നിയന്ത്രിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു വർക്ക്ഫ്ലോ കൊണ്ടുവരേണ്ടത് ആവശ്യമാണോ? ഈ രീതിയെ MLOps എന്ന് വിളിക്കുന്നു

MLOps അല്ലെങ്കിൽ മെഷീൻ ലേണിംഗിനുള്ള DevOps, ഡാറ്റാ സയൻസിനെയും ഐടി ടീമുകളെയും മോഡൽ ഡെവലപ്‌മെന്റിന്റെയും വിന്യാസത്തിന്റെയും വേഗത കൂട്ടാനും മെഷീൻ ലേണിംഗ് മോഡലുകളുടെ നിരീക്ഷണം, മൂല്യനിർണ്ണയം, ഭരണം എന്നിവയിലൂടെ വർദ്ധിപ്പിക്കാനും അനുവദിക്കുന്നു.

നിങ്ങൾക്ക് കഴിയും വായിച്ചുഗൂഗിളുകാർ ഇതിനെ കുറിച്ച് എന്താണ് ചിന്തിക്കുന്നത്? ലേഖനത്തിൽ നിന്ന് MLOps വളരെ വലിയ കാര്യമാണെന്ന് വ്യക്തമാണ്.

എന്റെ ലേഖനത്തിൽ ഈ പ്രക്രിയയുടെ ഒരു ഭാഗം മാത്രമേ ഞാൻ വിവരിക്കുന്നുള്ളൂ. നടപ്പിലാക്കുന്നതിനായി, ഞാൻ MLflow ടൂൾ ഉപയോഗിക്കും, കാരണം... ഇതൊരു ഓപ്പൺ സോഴ്‌സ് പ്രോജക്‌റ്റാണ്, കണക്റ്റുചെയ്യാൻ ചെറിയ അളവിലുള്ള കോഡ് ആവശ്യമാണ്, കൂടാതെ ജനപ്രിയ ml ചട്ടക്കൂടുകളുമായുള്ള സംയോജനവുമുണ്ട്. Kubeflow, SageMaker, ട്രെയിനുകൾ മുതലായവ പോലുള്ള മറ്റ് ഉപകരണങ്ങൾക്കായി നിങ്ങൾക്ക് ഇന്റർനെറ്റിൽ തിരയാനും നിങ്ങളുടെ ആവശ്യങ്ങൾക്ക് അനുയോജ്യമായ ഒന്ന് കണ്ടെത്താനും കഴിയും.

MLFlow ടൂൾ ഉപയോഗിക്കുന്നതിന്റെ ഉദാഹരണം ഉപയോഗിച്ച് "ബിൽഡിംഗ്" MLOps

MLFlow എന്നത് ml മോഡലുകളുടെ ലൈഫ് സൈക്കിൾ മാനേജ്മെന്റിനുള്ള ഒരു ഓപ്പൺ സോഴ്സ് പ്ലാറ്റ്ഫോമാണ് (https://mlflow.org/).

MLflow നാല് ഘടകങ്ങൾ ഉൾക്കൊള്ളുന്നു:

• MLflow ട്രാക്കിംഗ് - ഈ ഫലത്തിലേക്ക് നയിച്ച റെക്കോർഡിംഗ് ഫലങ്ങളുടെയും പാരാമീറ്ററുകളുടെയും പ്രശ്നങ്ങൾ ഉൾക്കൊള്ളുന്നു;
• MLflow പ്രോജക്റ്റ് - കോഡ് പാക്കേജുചെയ്യാനും ഏത് പ്ലാറ്റ്‌ഫോമിലും പുനർനിർമ്മിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു;
• MLflow മോഡലുകൾ - ഉൽപ്പാദനത്തിലേക്ക് മോഡലുകൾ വിന്യസിക്കുന്നതിനുള്ള ഉത്തരവാദിത്തം;
• MLflow രജിസ്ട്രി - ഒരു കേന്ദ്രീകൃത ശേഖരത്തിൽ മോഡലുകൾ സംഭരിക്കാനും അവയുടെ അവസ്ഥ നിയന്ത്രിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു.

MLflow രണ്ട് എന്റിറ്റികളിൽ പ്രവർത്തിക്കുന്നു:

• ലോഞ്ച് എന്നത് ഞങ്ങൾ രജിസ്റ്റർ ചെയ്യാൻ ആഗ്രഹിക്കുന്ന പരിശീലനത്തിന്റെയും പാരാമീറ്ററുകളുടെയും മെട്രിക്സിന്റെയും ഒരു പൂർണ്ണ ചക്രമാണ്;
• ഒരു പരീക്ഷണം ഒരുമിച്ച് പ്രവർത്തിക്കുന്ന ഒരു "വിഷയം" ആണ്.

ഉദാഹരണത്തിന്റെ എല്ലാ ഘട്ടങ്ങളും ഉബുണ്ടു 18.04 ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ നടപ്പിലാക്കുന്നു.

1. സെർവർ വിന്യസിക്കുക

ഞങ്ങളുടെ പ്രോജക്റ്റ് എളുപ്പത്തിൽ കൈകാര്യം ചെയ്യുന്നതിനും ആവശ്യമായ എല്ലാ വിവരങ്ങളും സ്വീകരിക്കുന്നതിനും, ഞങ്ങൾ ഒരു സെർവർ വിന്യസിക്കും. MLflow ട്രാക്കിംഗ് സെർവറിന് രണ്ട് പ്രധാന ഘടകങ്ങളുണ്ട്:

• ബാക്കെൻഡ് സ്റ്റോർ - രജിസ്റ്റർ ചെയ്ത മോഡലുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ സൂക്ഷിക്കുന്നതിനുള്ള ഉത്തരവാദിത്തം (4 DBMS-കളെ പിന്തുണയ്ക്കുന്നു: mysql, mssql, sqlite, postgresql);
• ആർട്ടിഫാക്റ്റ് സ്റ്റോർ - പുരാവസ്തുക്കൾ സംഭരിക്കുന്നതിനുള്ള ഉത്തരവാദിത്തം (7 സ്റ്റോറേജ് ഓപ്ഷനുകൾ പിന്തുണയ്ക്കുന്നു: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP സെർവർ, SFTP സെർവർ, NFS, HDFS).

എ ആർട്ടിഫാക്റ്റ് സ്റ്റോർ ലാളിത്യത്തിനായി, നമുക്ക് ഒരു sftp സെർവർ എടുക്കാം.

• ഒരു ഗ്രൂപ്പ് ഉണ്ടാക്കുക

  $ sudo groupadd sftpg

• ഒരു ഉപയോക്താവിനെ ചേർക്കുകയും അവനുവേണ്ടി ഒരു പാസ്‌വേഡ് സജ്ജമാക്കുകയും ചെയ്യുക

  $ sudo useradd -g sftpg mlflowsftp
  $ sudo passwd mlflowsftp 

• രണ്ട് ആക്സസ് ക്രമീകരണങ്ങൾ ക്രമീകരിക്കുന്നു

  $ sudo mkdir -p /data/mlflowsftp/upload
  $ sudo chown -R root.sftpg /data/mlflowsftp
  $ sudo chown -R mlflowsftp.sftpg /data/mlflowsftp/upload

• /etc/ssh/sshd_config-ലേക്ക് കുറച്ച് വരികൾ ചേർക്കുക

  Match Group sftpg
   ChrootDirectory /data/%u
   ForceCommand internal-sftp

• സേവനം പുനരാരംഭിക്കുക

  $ sudo systemctl restart sshd

എ ബാക്കെൻഡ് സ്റ്റോർ നമുക്ക് postgresql എടുക്കാം.

$ sudo apt update
$ sudo apt-get install -y postgresql postgresql-contrib postgresql-server-dev-all
$ sudo apt install gcc
$ pip install psycopg2
$ sudo -u postgres -i
# Create new user: mlflow_user
[postgres@user_name~]$ createuser --interactive -P
Enter name of role to add: mlflow_user
Enter password for new role: mlflow
Enter it again: mlflow
Shall the new role be a superuser? (y/n) n
Shall the new role be allowed to create databases? (y/n) n
Shall the new role be allowed to create more new roles? (y/n) n
# Create database mlflow_bd owned by mlflow_user
$ createdb -O mlflow_user mlflow_db

സെർവർ ആരംഭിക്കുന്നതിന്, നിങ്ങൾ ഇനിപ്പറയുന്ന പൈത്തൺ പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട് (ഒരു പ്രത്യേക വെർച്വൽ പരിസ്ഥിതി സൃഷ്ടിക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു):

pip install mlflow
pip install pysftp

നമുക്ക് നമ്മുടെ സെർവർ ആരംഭിക്കാം

$ mlflow server  
                 --backend-store-uri postgresql://mlflow_user:mlflow@localhost/mlflow_db 
                 --default-artifact-root sftp://mlflowsftp:mlflow@sftp_host/upload  
                --host server_host 
                --port server_port

2. ട്രാക്കിംഗ് ചേർക്കുക

ഞങ്ങളുടെ പരിശീലനത്തിന്റെ ഫലങ്ങൾ നഷ്‌ടപ്പെടാതിരിക്കാനും, ഡെവലപ്പർമാരുടെ ഭാവി തലമുറകൾക്ക് എന്താണ് സംഭവിക്കുന്നതെന്ന് മനസിലാക്കാനും, പഴയ സഖാക്കൾക്കും നിങ്ങൾക്കും പഠന പ്രക്രിയ ശാന്തമായി വിശകലനം ചെയ്യാൻ കഴിയുന്നതിനും, ഞങ്ങൾ ട്രാക്കിംഗ് ചേർക്കേണ്ടതുണ്ട്. ട്രാക്കിംഗ് എന്നതിനർത്ഥം പാരാമീറ്ററുകൾ, മെട്രിക്‌സ്, ആർട്ടിഫാക്‌റ്റുകൾ, പരിശീലനത്തിന്റെ തുടക്കത്തെക്കുറിച്ചുള്ള ഏതെങ്കിലും അധിക വിവരങ്ങൾ, ഞങ്ങളുടെ കാര്യത്തിൽ, സെർവറിൽ സംരക്ഷിക്കുക എന്നാണ്.

ഉദാഹരണത്തിന്, ഞാൻ ഒരു ചെറിയ സൃഷ്ടിച്ചു ഗിത്തബിലെ പദ്ധതി ഉള്ളതെല്ലാം വിഭജിക്കുന്നതിന് കേരസിൽ COCO ഡാറ്റാസെറ്റ്. ട്രാക്കിംഗ് ചേർക്കാൻ, ഞാൻ mlflow_training.py ഒരു ഫയൽ സൃഷ്ടിച്ചു.

ഏറ്റവും രസകരമായ കാര്യങ്ങൾ സംഭവിക്കുന്ന വരികൾ ഇതാ:

def run(self, epochs, lr, experiment_name):
        # getting the id of the experiment, creating an experiment in its absence
        remote_experiment_id = self.remote_server.get_experiment_id(name=experiment_name)
        # creating a "run" and getting its id
        remote_run_id = self.remote_server.get_run_id(remote_experiment_id)

        # indicate that we want to save the results on a remote server
        mlflow.set_tracking_uri(self.tracking_uri)
        mlflow.set_experiment(experiment_name)

        with mlflow.start_run(run_id=remote_run_id, nested=False):
            mlflow.keras.autolog()
            self.train_pipeline.train(lr=lr, epochs=epochs)

        try:
            self.log_tags_and_params(remote_run_id)
        except mlflow.exceptions.RestException as e:
            print(e)

ഇവിടെ self.remote_server mlflow.tracking രീതികൾക്ക് മുകളിലുള്ള ഒരു ചെറിയ റാപ്പറാണ്. MlflowClient (ഞാൻ ഇത് സൗകര്യാർത്ഥം ഉണ്ടാക്കി), അതിന്റെ സഹായത്തോടെ ഞാൻ ഒരു പരീക്ഷണം സൃഷ്ടിക്കുകയും സെർവറിൽ പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു. അടുത്തതായി, ലോഞ്ച് ഫലങ്ങൾ എവിടെയാണ് ലയിപ്പിക്കേണ്ടതെന്ന് ഞാൻ സൂചിപ്പിക്കുന്നു (mlflow.set_tracking_uri(self.tracking_uri)). ഞാൻ സ്വയമേവയുള്ള ലോഗിംഗ് mlflow.keras.autolog() പ്രവർത്തനക്ഷമമാക്കുന്നു. നിലവിൽ MLflow ട്രാക്കിംഗ് TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark എന്നിവയ്ക്കായി ഓട്ടോമാറ്റിക് ലോഗിംഗിനെ പിന്തുണയ്ക്കുന്നു. നിങ്ങളുടെ ചട്ടക്കൂടോ ലൈബ്രറിയോ കണ്ടെത്തിയില്ലെങ്കിൽ, നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും വ്യക്തമായി ലോഗിൻ ചെയ്യാൻ കഴിയും. ഞങ്ങൾ പരിശീലനം ആരംഭിക്കുകയാണ്. റിമോട്ട് സെർവറിൽ ടാഗുകളും ഇൻപുട്ട് പാരാമീറ്ററുകളും രജിസ്റ്റർ ചെയ്യുക.

എല്ലാ ലോഞ്ചുകളെയും കുറിച്ചുള്ള വിവരങ്ങളിലേക്ക് എല്ലാവരേയും പോലെ രണ്ട് വരികളും നിങ്ങൾക്കും ആക്‌സസ് ഉണ്ട്. അടിപൊളിയാണോ?

3. ഞങ്ങൾ പ്രോജക്റ്റ് വരയ്ക്കുന്നു

ഇനി പ്രോജക്റ്റ് ലോഞ്ച് ചെയ്യുന്നത് എളുപ്പമാക്കാം. ഇത് ചെയ്യുന്നതിന്, പ്രോജക്റ്റ് റൂട്ടിലേക്ക് MLproject, conda.yaml ഫയലുകൾ ചേർക്കുക.
ML പദ്ധതി

name: flow_segmentation
conda_env: conda.yaml

entry_points:
  main:
    parameters:
        categories: {help: 'list of categories from coco dataset'}
        epochs: {type: int, help: 'number of epochs in training'}

        lr: {type: float, default: 0.001, help: 'learning rate'}
        batch_size: {type: int, default: 8}
        model_name: {type: str, default: 'Unet', help: 'Unet, PSPNet, Linknet, FPN'}
        backbone_name: {type: str, default: 'resnet18', help: 'exampe resnet18, resnet50, mobilenetv2 ...'}

        tracking_uri: {type: str, help: 'the server address'}
        experiment_name: {type: str, default: 'My_experiment', help: 'remote and local experiment name'}
    command: "python mlflow_training.py 
            --epochs={epochs}
            --categories={categories}
            --lr={lr}
            --tracking_uri={tracking_uri}
            --model_name={model_name}
            --backbone_name={backbone_name}
            --batch_size={batch_size}
            --experiment_name={experiment_name}"

MLflow പ്രോജക്ടിന് നിരവധി ഗുണങ്ങളുണ്ട്:

• പേര് - നിങ്ങളുടെ പ്രോജക്റ്റിന്റെ പേര്;
• പരിസ്ഥിതി - എന്റെ കാര്യത്തിൽ, conda_env സൂചിപ്പിക്കുന്നത് അനക്കോണ്ട റൺ ചെയ്യാൻ ഉപയോഗിക്കുന്നുവെന്നും ഡിപൻഡൻസി വിവരണം conda.yaml ഫയലിലാണെന്നും;
• എൻട്രി പോയിന്റുകൾ - ഏത് ഫയലുകൾ, ഏത് പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് നമുക്ക് പ്രവർത്തിപ്പിക്കാൻ കഴിയുമെന്ന് സൂചിപ്പിക്കുന്നു (പരിശീലനം ആരംഭിക്കുമ്പോൾ എല്ലാ പാരാമീറ്ററുകളും സ്വയമേവ ലോഗ് ചെയ്യപ്പെടും)

കൊണ്ട.യാംൽ

name: flow_segmentation
channels:
  - defaults
  - anaconda
dependencies:
  - python==3.7
  - pip:
    - mlflow==1.8.0
    - pysftp==0.2.9
    - Cython==0.29.19
    - numpy==1.18.4
    - pycocotools==2.0.0
    - requests==2.23.0
    - matplotlib==3.2.1
    - segmentation-models==1.0.1
    - Keras==2.3.1
    - imgaug==0.4.0
    - tqdm==4.46.0
    - tensorflow-gpu==1.14.0

നിങ്ങളുടെ റൺടൈം പരിതസ്ഥിതിയായി നിങ്ങൾക്ക് ഡോക്കർ ഉപയോഗിക്കാം, കൂടുതൽ വിവരങ്ങൾക്ക് ദയവായി കാണുക പ്രമാണീകരണം.

4. നമുക്ക് പരിശീലനം ആരംഭിക്കാം

ഞങ്ങൾ പ്രോജക്റ്റ് ക്ലോൺ ചെയ്ത് പ്രോജക്റ്റ് ഡയറക്ടറിയിലേക്ക് പോകുന്നു:

git clone https://github.com/simbakot/mlflow_example.git
cd mlflow_example/

പ്രവർത്തിപ്പിക്കുന്നതിന് നിങ്ങൾ ലൈബ്രറികൾ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്

pip install mlflow
pip install pysftp

കാരണം ഞാൻ ഉപയോഗിക്കുന്ന conda_env ഉദാഹരണത്തിൽ, Anaconda നിങ്ങളുടെ കമ്പ്യൂട്ടറിൽ ഇൻസ്റ്റാൾ ചെയ്യണം (എന്നാൽ ആവശ്യമായ എല്ലാ പാക്കേജുകളും സ്വയം ഇൻസ്റ്റാൾ ചെയ്ത് ലോഞ്ച് പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് മറികടക്കാനാകും).

എല്ലാ തയ്യാറെടുപ്പ് നടപടികളും പൂർത്തിയായി, നമുക്ക് പരിശീലനം ആരംഭിക്കാം. പ്രോജക്റ്റ് റൂട്ടിൽ നിന്ന്:

$ mlflow run -P epochs=10 -P categories=cat,dog -P tracking_uri=http://server_host:server_port .

കമാൻഡ് നൽകിയ ശേഷം, ഒരു കോണ്ട എൻവയോൺമെന്റ് സ്വയമേവ സൃഷ്ടിക്കപ്പെടുകയും പരിശീലനം ആരംഭിക്കുകയും ചെയ്യും.
മുകളിലുള്ള ഉദാഹരണത്തിൽ, പരിശീലനത്തിനുള്ള യുഗങ്ങളുടെ എണ്ണം ഞാൻ പാസാക്കി, ഞങ്ങൾ സെഗ്‌മെന്റ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന വിഭാഗങ്ങൾ (നിങ്ങൾക്ക് പൂർണ്ണമായ ലിസ്റ്റ് കാണാം ഇവിടെ) കൂടാതെ ഞങ്ങളുടെ റിമോട്ട് സെർവറിന്റെ വിലാസവും.
സാധ്യമായ പരാമീറ്ററുകളുടെ പൂർണ്ണമായ ലിസ്റ്റ് MLproject ഫയലിൽ കാണാം.

5. പഠന ഫലങ്ങൾ വിലയിരുത്തുക

പരിശീലനം പൂർത്തിയാക്കിയ ശേഷം, ഞങ്ങളുടെ സെർവറിന്റെ വിലാസത്തിലേക്ക് ബ്രൗസറിൽ പോകാം http://server_host:server_port

എല്ലാ പരീക്ഷണങ്ങളുടെയും (മുകളിൽ ഇടത്) ഒരു ലിസ്റ്റും റണ്ണുകളെക്കുറിച്ചുള്ള വിവരങ്ങളും (മധ്യത്തിൽ) ഇവിടെ കാണാം. ഓരോ ലോഞ്ചിനും കൂടുതൽ വിശദമായ വിവരങ്ങൾ (പാരാമീറ്ററുകൾ, മെട്രിക്‌സ്, ആർട്ടിഫാക്‌റ്റുകൾ, ചില അധിക വിവരങ്ങൾ) നമുക്ക് കാണാൻ കഴിയും.

ഓരോ മെട്രിക്കിനും നമുക്ക് മാറ്റങ്ങളുടെ ചരിത്രം നിരീക്ഷിക്കാം

ആ. ഇപ്പോൾ ഞങ്ങൾക്ക് ഒരു "മാനുവൽ" മോഡിൽ ഫലങ്ങൾ വിശകലനം ചെയ്യാം, കൂടാതെ നിങ്ങൾക്ക് MLflow API ഉപയോഗിച്ച് യാന്ത്രിക മൂല്യനിർണ്ണയം സജ്ജീകരിക്കാനും കഴിയും.

6. മോഡൽ രജിസ്റ്റർ ചെയ്യുക

ഞങ്ങൾ ഞങ്ങളുടെ മോഡൽ വിശകലനം ചെയ്യുകയും യുദ്ധത്തിന് തയ്യാറാണെന്ന് തീരുമാനിക്കുകയും ചെയ്ത ശേഷം, ഞങ്ങൾ അത് രജിസ്റ്റർ ചെയ്യാൻ മുന്നോട്ട് പോകുന്നു, ഇതിനായി ഞങ്ങൾക്ക് ആവശ്യമായ ലോഞ്ച് തിരഞ്ഞെടുത്ത് (മുമ്പത്തെ ഖണ്ഡികയിൽ കാണിച്ചിരിക്കുന്നതുപോലെ) താഴേക്ക് പോകുക.

ഞങ്ങളുടെ മോഡലിന് ഒരു പേര് നൽകിയ ശേഷം, അതിന് ഒരു പതിപ്പുണ്ട്. നിങ്ങൾ അതേ പേരിൽ മറ്റൊരു മോഡൽ സേവ് ചെയ്താൽ, പതിപ്പ് സ്വയമേവ നവീകരിക്കപ്പെടും.

ഓരോ മോഡലിനും, നമുക്ക് ഒരു വിവരണം ചേർക്കാനും മൂന്ന് സ്റ്റേറ്റുകളിൽ ഒന്ന് തിരഞ്ഞെടുക്കാനും കഴിയും (സ്റ്റേജിംഗ്, പ്രൊഡക്ഷൻ, ആർക്കൈവ്ഡ്); തുടർന്ന്, API ഉപയോഗിച്ച്, നമുക്ക് ഈ അവസ്ഥകൾ ആക്സസ് ചെയ്യാൻ കഴിയും, ഇത് പതിപ്പിനൊപ്പം അധിക വഴക്കവും നൽകുന്നു.

എല്ലാ മോഡലുകളിലേക്കും ഞങ്ങൾക്ക് എളുപ്പത്തിൽ ആക്സസ് ഉണ്ട്

അവയുടെ പതിപ്പുകളും

മുമ്പത്തെ ഖണ്ഡികയിലെന്നപോലെ, എല്ലാ പ്രവർത്തനങ്ങളും API ഉപയോഗിച്ച് ചെയ്യാം.

7. മോഡൽ വിന്യസിക്കുക

ഈ ഘട്ടത്തിൽ, ഞങ്ങൾക്ക് ഇതിനകം പരിശീലനം ലഭിച്ച (കേരാസ്) മോഡൽ ഉണ്ട്. നിങ്ങൾക്ക് ഇത് എങ്ങനെ ഉപയോഗിക്കാം എന്നതിന്റെ ഒരു ഉദാഹരണം:

class SegmentationModel:
    def __init__(self, tracking_uri, model_name):

        self.registry = RemoteRegistry(tracking_uri=tracking_uri)
        self.model_name = model_name
        self.model = self.build_model(model_name)

    def get_latest_model(self, model_name):
        registered_models = self.registry.get_registered_model(model_name)
        last_model = self.registry.get_last_model(registered_models)
        local_path = self.registry.download_artifact(last_model.run_id, 'model', './')
        return local_path

    def build_model(self, model_name):
        local_path = self.get_latest_model(model_name)

        return mlflow.keras.load_model(local_path)

    def predict(self, image):
        image = self.preprocess(image)
        result = self.model.predict(image)
        return self.postprocess(result)

    def preprocess(self, image):
        image = cv2.resize(image, (256, 256))
        image = image / 255.
        image = np.expand_dims(image, 0)
        return image

    def postprocess(self, result):
        return result

ഇവിടെ self.registry സൗകര്യാർത്ഥം mlflow.tracking.MlflowClient ന് മുകളിലുള്ള ഒരു ചെറിയ റാപ്പറാണ്. ഞാൻ ഒരു റിമോട്ട് സെർവർ ആക്‌സസ്സുചെയ്‌ത് അവിടെ നിർദ്ദിഷ്ട പേരും ഏറ്റവും പുതിയ പ്രൊഡക്ഷൻ പതിപ്പും ഉള്ള ഒരു മോഡലിനായി തിരയുന്നു എന്നതാണ് കാര്യം. അടുത്തതായി, ഞാൻ ആർട്ടിഫാക്റ്റ് പ്രാദേശികമായി ./മോഡൽ ഫോൾഡറിലേക്ക് ഡൗൺലോഡ് ചെയ്യുകയും, mlflow.keras.load_model(local_path) എന്ന ഡയറക്ടറിയിൽ നിന്ന് മോഡൽ നിർമ്മിക്കുകയും ചെയ്യുന്നു. ഇപ്പോൾ നമുക്ക് നമ്മുടെ മാതൃക ഉപയോഗിക്കാം. CV (ML) ഡെവലപ്പർമാർക്ക് എളുപ്പത്തിൽ മോഡൽ മെച്ചപ്പെടുത്താനും പുതിയ പതിപ്പുകൾ പ്രസിദ്ധീകരിക്കാനും കഴിയും.

ഉപസംഹാരമായി

അനുവദിക്കുന്ന ഒരു സിസ്റ്റം ഞാൻ അവതരിപ്പിച്ചു:

• ML മോഡലുകൾ, പരിശീലന പുരോഗതി, ഫലങ്ങൾ എന്നിവയെക്കുറിച്ചുള്ള വിവരങ്ങൾ കേന്ദ്രീകൃതമായി സംഭരിക്കുക;
• ഒരു വികസന അന്തരീക്ഷം വേഗത്തിൽ വിന്യസിക്കുക;
• മോഡലുകളിലെ ജോലിയുടെ പുരോഗതി നിരീക്ഷിക്കുകയും വിശകലനം ചെയ്യുകയും ചെയ്യുക;
• മോഡലുകളുടെ അവസ്ഥ പതിപ്പിക്കാനും നിയന്ത്രിക്കാനും ഇത് സൗകര്യപ്രദമാണ്;
• തത്ഫലമായുണ്ടാകുന്ന മോഡലുകൾ വിന്യസിക്കുന്നത് എളുപ്പമാണ്.

ഈ ഉദാഹരണം ഒരു കളിപ്പാട്ടമാണ് കൂടാതെ നിങ്ങളുടെ സ്വന്തം സിസ്റ്റം നിർമ്മിക്കുന്നതിനുള്ള ഒരു ആരംഭ പോയിന്റായി വർത്തിക്കുന്നു, അതിൽ ഫലങ്ങളുടെ മൂല്യനിർണ്ണയവും മോഡലുകളുടെ രജിസ്ട്രേഷനും (യഥാക്രമം പോയിന്റുകൾ 5 ഉം 6 ഉം) ഉൾപ്പെടാം അല്ലെങ്കിൽ നിങ്ങൾ ഡാറ്റാസെറ്റുകളുടെ പതിപ്പ് ചേർക്കുമോ, അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും ? ഞാൻ പറയാൻ ശ്രമിച്ച കാര്യം നിങ്ങൾക്ക് മൊത്തത്തിൽ MLOps ആവശ്യമാണ് എന്നതാണ്, MLflow ഒരു ലക്ഷ്യത്തിലേക്കുള്ള ഒരു ഉപാധി മാത്രമാണ്.

ഞാൻ പ്രദർശിപ്പിക്കാത്ത എന്തൊക്കെ പ്രശ്നങ്ങൾ നിങ്ങൾ നേരിട്ടുവെന്ന് എഴുതുക?
നിങ്ങളുടെ ആവശ്യങ്ങൾ നിറവേറ്റുന്നതിനായി സിസ്റ്റത്തിലേക്ക് നിങ്ങൾ എന്ത് ചേർക്കും?
എല്ലാ അല്ലെങ്കിൽ ഭാഗികമായ പ്രശ്നങ്ങളും പരിഹരിക്കാൻ നിങ്ങൾ എന്ത് ഉപകരണങ്ങളും സമീപനങ്ങളും ഉപയോഗിക്കുന്നു?

PS ഞാൻ രണ്ട് ലിങ്കുകൾ ഇടാം:
github പദ്ധതി - https://github.com/simbakot/mlflow_example
MLflow - https://mlflow.org/
ചോദ്യങ്ങൾക്കുള്ള എന്റെ ജോലി ഇമെയിൽ - [ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]

ഞങ്ങളുടെ കമ്പനി ആനുകാലികമായി ഐടി സ്പെഷ്യലിസ്റ്റുകൾക്കായി വിവിധ ഇവന്റുകൾ ഹോസ്റ്റുചെയ്യുന്നു, ഉദാഹരണത്തിന്: ജൂലൈ 8 ന് മോസ്കോ സമയം 19:00 ന് ഒരു ഓൺലൈൻ ഫോർമാറ്റിൽ ഒരു സിവി മീറ്റപ്പ് ഉണ്ടാകും, നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് പങ്കെടുക്കാം, രജിസ്ട്രേഷൻ ഇവിടെ .

അവലംബം: www.habr.com