ഒരു മെഷീൻ ലേണിംഗ് മോഡൽ സൃഷ്ടിക്കുക എന്നതാണ് ഈ സാഹചര്യത്തിന്റെ ഒരു വശം. ഇത് യഥാർത്ഥ ലോകത്ത് ഉപയോഗിക്കാവുന്നതും ഉപഭോക്താക്കൾക്കും ഡവലപ്പർമാർക്കും ലഭ്യമായിരിക്കണം.
മെഷീൻ ലേണിംഗ് മോഡലുകൾ വിന്യസിക്കുന്നതിനുള്ള ഏറ്റവും ലളിതവും ജനപ്രിയവുമായ മാർഗ്ഗം അവയെ ഒരു REST API-യിൽ ഉൾപ്പെടുത്തുക എന്നതാണ്.
FastAPI എന്ന പ്രശസ്തമായ ഒരു ലൈബ്രറി ഉപയോഗിച്ച്, അതാണ് ഞങ്ങൾ ഇന്ന് നിറവേറ്റുക.
പക്ഷേ, എന്താണ് FastAPI?
സമകാലിക പൈത്തൺ കഴിവുകൾ പ്രയോജനപ്പെടുത്തുന്നതിനായി ഫാസ്റ്റ്എപിഐ പൈത്തൺ വെബ് ഫ്രെയിംവർക്ക് അടിത്തറയിൽ നിന്ന് സൃഷ്ടിച്ചു.
ക്ലയന്റുകളുമായുള്ള അസമന്വിതവും സമകാലികവുമായ ആശയവിനിമയത്തിന്, ഇത് ASGI മാനദണ്ഡം പാലിക്കുന്നു, അതേസമയം ഇത് WSGI ഉപയോഗിക്കാനും പ്രാപ്തമാണ്.
എൻഡ്പോയിന്റുകൾക്കും റൂട്ടുകൾക്കും അസിൻക് ഫംഗ്ഷനുകൾ ഉപയോഗിക്കാനാകും. കൂടാതെ, FastAPI, ടൈപ്പ്-ഹിന്ഡഡ്, ക്ലീൻ, സമകാലിക പൈത്തൺ കോഡിൽ വെബ് ആപ്ലിക്കേഷനുകളുടെ ഉൽപ്പാദനക്ഷമമായ സൃഷ്ടിക്കൽ പ്രാപ്തമാക്കുന്നു.
FastAPI-യുടെ പ്രധാന ഉപയോഗ കേസ്, പേര് സൂചിപ്പിക്കുന്നത് പോലെ, API എൻഡ് പോയിന്റുകൾ സൃഷ്ടിക്കുന്നതാണ്.
ഒരു ഇന്ററാക്ടീവ് സ്വാഗ്ഗർ യുഐ ഉൾപ്പെടുന്ന OpenAPI സ്റ്റാൻഡേർഡ് ഉപയോഗിക്കുന്നത് അല്ലെങ്കിൽ JSON ആയി പൈത്തൺ നിഘണ്ടു ഡാറ്റ നൽകുന്നത് ഇത് നേടാനുള്ള ലളിതമായ വഴികളാണ്. എന്നിരുന്നാലും, FastAPI API-കൾക്ക് മാത്രമല്ല.
Jinja2 ടെംപ്ലേറ്റ് എഞ്ചിൻ ഉപയോഗിച്ച് സ്റ്റാൻഡേർഡ് വെബ് പേജുകൾ വാഗ്ദാനം ചെയ്യുന്നതിനും വെബ്സോക്കറ്റുകൾ ഉപയോഗിച്ച് ആപ്ലിക്കേഷനുകൾ നൽകുന്നതിനും ഇത് ഉപയോഗിക്കാം, കൂടാതെ ഒരു വെബ് ഫ്രെയിംവർക്കിന് ചെയ്യാൻ കഴിയുന്ന മറ്റെല്ലാം.
ഈ ലേഖനത്തിൽ, ഞങ്ങൾ ഒരു നേരായ മെഷീൻ ലേണിംഗ് മോഡൽ വികസിപ്പിക്കുകയും അത് വിന്യസിക്കാൻ FastAPI ഉപയോഗിക്കുകയും ചെയ്യും. നമുക്ക് തുടങ്ങാം.
FastAPI യുടെ ഇൻസ്റ്റാളേഷനും ആദ്യത്തെ API സൃഷ്ടിക്കലും
ലൈബ്രറിയും ഒരു ASGI സെർവറും ഇൻസ്റ്റാൾ ചെയ്യേണ്ടത് ആദ്യം ആവശ്യമാണ്; Uvuicorn അല്ലെങ്കിൽ Hypercorn ഒന്നുകിൽ പ്രവർത്തിക്കും. ടെർമിനലിലേക്ക് ഇനിപ്പറയുന്ന കമാൻഡ് നൽകി ഇത് പ്രവർത്തിക്കുന്നു:
ഇപ്പോൾ API സൃഷ്ടിച്ചിരിക്കുന്നു, നിങ്ങൾക്ക് ഇഷ്ടപ്പെട്ട കോഡ് എഡിറ്റർ ഉപയോഗിക്കാനും അതിലൂടെ ബ്രൗസ് ചെയ്യാനും കഴിയും. ആരംഭിക്കുന്നതിന് ml_model.py എന്ന പേരിൽ ഒരു പൈത്തൺ സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കുക. നിങ്ങളുടേതിന് മറ്റൊരു പേര് നൽകാൻ നിങ്ങൾക്ക് സ്വാഗതം, എന്നാൽ ഈ പോസ്റ്റിന് വേണ്ടി, ഞാൻ ഈ ഫയലിനെ ml_model.py എന്ന് പരാമർശിക്കും.
രണ്ട് എൻഡ് പോയിന്റുകളുള്ള നേരായ API സൃഷ്ടിക്കുന്നതിന്, നിങ്ങൾ ഇനിപ്പറയുന്ന ടാസ്ക്കുകൾ പൂർത്തിയാക്കണം:
- FastAPI, Uvicorn ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യുക.
- ഒരു FastAPI ക്ലാസ് ഇൻസ്റ്റൻസ് സജ്ജീകരിക്കുക.
- സൂചിക പേജിൽ, നേരായ JSON ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്ന ആദ്യ റൂട്ട് പ്രഖ്യാപിക്കുക.
- ഇഷ്ടാനുസൃതമാക്കിയ സന്ദേശത്തോടുകൂടിയ നേരായ JSON ഒബ്ജക്റ്റ് നൽകുന്ന രണ്ടാമത്തെ റൂട്ട് പ്രഖ്യാപിക്കുക. നെയിം പാരാമീറ്റർ URL-ൽ നിന്ന് നേരിട്ട് എടുത്തതാണ് (ഉദാഹരണത്തിന്, https://127.0.0.1:8000/Jay).
- API പ്രവർത്തിപ്പിക്കാൻ Uvicorn ഉപയോഗിക്കുക.
ഈ അഞ്ച് ഘട്ടങ്ങൾ നടപ്പിലാക്കുന്നത് ഇനിപ്പറയുന്ന കോഡിന്റെ ബിറ്റിൽ കാണിച്ചിരിക്കുന്നു അതായത്. ഒരു ലളിതമായ API സൃഷ്ടിക്കുന്നു
എല്ലാം കഴിഞ്ഞു! നമുക്ക് നമ്മുടെ API ഉടൻ സമാരംഭിക്കാം. ഇത് പൂർത്തിയാക്കാൻ ml model.py ഫയലിന് അടുത്തുള്ള ഒരു ടെർമിനൽ വിൻഡോ തുറക്കുക. അടുത്തതായി, ഇനിപ്പറയുന്നവ നൽകുക:
എന്റർ കീ. മുന്നോട്ട് പോകുന്നതിന് മുമ്പ്, നമുക്ക് ഈ അവകാശവാദം പൊളിച്ചെഴുതാം. ആദ്യ ആപ്പ് വിപുലീകരണമില്ലാതെ പൈത്തൺ ഫയലിന്റെ പേര് മാത്രം ഉപയോഗിക്കുന്നു. രണ്ടാമത്തെ ആപ്പിന് നിങ്ങളുടെ FastAPI ഉദാഹരണത്തിന്റെ അതേ പേര് ഉണ്ടായിരിക്കണം.
-reload ഉപയോഗിക്കുന്നതിലൂടെ, ആദ്യം മുതൽ ആരംഭിക്കുന്നതിനുപകരം ഫയൽ സംരക്ഷിക്കുമ്പോൾ അത് സ്വയമേവ റീലോഡ് ചെയ്യണമെന്ന് നിങ്ങൾ API-യോട് പറയുന്നു.
ഇപ്പോൾ ഒരു ബ്രൗസർ സമാരംഭിച്ച് https://127.0.0.1:8000 എന്നതിലേക്ക് നാവിഗേറ്റ് ചെയ്യുക; ഫലം ഇനിപ്പറയുന്ന രീതിയിൽ ദൃശ്യമാകണം:
FastAPI ഉപയോഗിച്ച് ഒരു ലളിതമായ API എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് നിങ്ങൾ ഇപ്പോൾ മനസ്സിലാക്കുന്നു.
മെഷീൻ ലേണിംഗ് മോഡൽ നിർമ്മിക്കുകയും പരിശീലിപ്പിക്കുകയും ചെയ്യുന്നു
ഒരു ഡാറ്റയും ശേഖരിക്കുകയോ വിശകലനം ചെയ്യുകയോ ചെയ്യാതെ, ഞങ്ങൾ ഒരു ലളിതമായ മോഡൽ പരിശീലിപ്പിക്കും. ഇവ മോഡലുകളുടെ വിന്യാസവുമായി ബന്ധമില്ലാത്തവയാണ്, മാത്രമല്ല വിഷയത്തിന് അത് അനിവാര്യമല്ല.
ഐറിസ് ഡാറ്റാസെറ്റിനെ അടിസ്ഥാനമാക്കിയുള്ള ഒരു മോഡൽ അതേ ഉപയോഗിച്ച് ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും ന്യൂറൽ നെറ്റ്വർക്ക് ഇൻസ്റ്റലേഷൻ രീതി.
ഞങ്ങൾ അത് ചെയ്യും: ഡൗൺലോഡ് ചെയ്യുക ഐറിസ് ഡാറ്റാസെറ്റ് മോഡലിനെ പരിശീലിപ്പിക്കുകയും ചെയ്യുക. അത് ലളിതമായിരിക്കില്ല. ആരംഭിക്കുന്നതിന്, jaysmlmodel.py എന്ന പേരിൽ ഒരു ഫയൽ ഉണ്ടാക്കുക.
അതിൽ, നിങ്ങൾ ഇനിപ്പറയുന്നവ ചെയ്യും:
- ഇമ്പോർട്ടുകൾ - നിങ്ങൾക്ക് പാണ്ടകൾ, സ്കിറ്റ്-റാൻഡംഫോർകാസ്റ്റ്ക്ലാസിഫയർ, പൈഡന്റിക്കിന്റെ അടിസ്ഥാന മോഡൽ പഠിക്കുക (എന്തുകൊണ്ടെന്ന് ഇനിപ്പറയുന്ന ഘട്ടത്തിൽ നിങ്ങൾ കണ്ടെത്തും), മോഡലുകൾ സംഭരിക്കുന്നതിനും ലോഡുചെയ്യുന്നതിനും ജോബ്ലിബ് എന്നിവ ആവശ്യമാണ്.
- അടിസ്ഥാന മോഡലിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്ന ഒരു IrisSpecies ക്ലാസ് പ്രഖ്യാപിക്കുക. ഈ ക്ലാസിൽ ഒരൊറ്റ പൂവ് ഇനം പ്രവചിക്കാൻ ആവശ്യമായ ഫീൽഡുകൾ മാത്രമേ അടങ്ങിയിട്ടുള്ളൂ (അതിനെക്കുറിച്ച് കൂടുതൽ അടുത്ത വിഭാഗത്തിൽ)
- ഒരു ക്ലാസ് സൃഷ്ടിക്കുക. IrisModel ഒരു മാതൃകാ പരിശീലനവും പ്രവചന ഉപകരണവുമാണ്.
- IrisModel-ൽ _ട്രെയിൻ മോഡൽ എന്ന് പേരുള്ള ഒരു രീതി പ്രഖ്യാപിക്കുക. റാൻഡം ഫോറസ്റ്റ് ടെക്നിക് ഉപയോഗിച്ച് മോഡലുകളെ പരിശീലിപ്പിക്കാൻ ഇത് ഉപയോഗിക്കുന്നു. പരിശീലനം ലഭിച്ച മോഡൽ നടപടിക്രമം വഴി തിരികെ നൽകുന്നു.
- ഐറിസ് മോഡലിനുള്ളിൽ പ്രവചിക്കപ്പെട്ട സ്പീഷീസ് ഫംഗ്ഷൻ പ്രഖ്യാപിക്കുക. 4 ഇൻപുട്ട് ഘടകങ്ങളെ (പൂക്കളുടെ അളവുകൾ) അടിസ്ഥാനമാക്കി പ്രവചിക്കാൻ ഇത് ഉപയോഗിക്കുന്നു. പ്രവചനവും (പുഷ്പ ഇനങ്ങളും) പ്രവചന സാധ്യതയും അൽഗോരിതം വഴി നൽകുന്നു.
- ഐറിസ് മോഡലിലെ കൺസ്ട്രക്റ്റർ മാറ്റുക, അതുവഴി ഐറിസ് ഡാറ്റാസെറ്റ് ലോഡുചെയ്യുകയും ഫോൾഡറിൽ നിന്ന് അത് നഷ്ടപ്പെട്ടാൽ മോഡലിനെ പരിശീലിപ്പിക്കുകയും ചെയ്യുന്നു. പുതിയ മോഡലുകളെ ആവർത്തിച്ച് പരിശീലിപ്പിക്കുന്ന പ്രശ്നം ഇത് പരിഹരിക്കുന്നു. ജോബ്ലിബ് ലൈബ്രറി മോഡൽ ലോഡ് ചെയ്യുന്നതിനും സംരക്ഷിക്കുന്നതിനും ഉപയോഗിക്കുന്നു.
മുഴുവൻ കോഡും ഇതാ:
മുകളിലെ ലിസ്റ്റും അഭിപ്രായങ്ങളും ഇത് സൃഷ്ടിക്കാൻ വലിയ അളവിലുള്ള കോഡാണെങ്കിലും മനസ്സിലാക്കുന്നത് എളുപ്പമാക്കിയെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. ഇപ്പോൾ ഈ മോഡൽ വികസിപ്പിച്ചിരിക്കുന്നു, അതിന്റെ പ്രവചന ശേഷികൾ a-യിൽ പ്രസിദ്ധീകരിക്കാം REST API.
ഒരു പൂർണ്ണ REST API നിർമ്മിക്കുന്നു
ml_model.py ഫയലിലേക്ക് മടങ്ങി എല്ലാ ഡാറ്റയും ശുദ്ധീകരിക്കുക. ബോയിലർ പ്ലേറ്റ് നിങ്ങൾക്ക് മുമ്പ് ഉണ്ടായിരുന്നതിന് സമാനമായിരിക്കും, പക്ഷേ ഞങ്ങൾ ഒരു ശൂന്യ ഫയലിൽ നിന്ന് ആരംഭിക്കണം.
ഈ സമയം നിങ്ങൾ ഒരു അവസാന പോയിന്റ് മാത്രമേ നിർവചിക്കുകയുള്ളൂ, പൂവിന്റെ തരം നിർണ്ണയിക്കാൻ ഇത് ഉപയോഗിക്കുന്നു. IrisModel.predict സ്പീഷീസ്(), മുൻ വിഭാഗത്തിൽ പ്രഖ്യാപിച്ചത്, പ്രവചനം നടപ്പിലാക്കുന്നതിനായി ഈ എൻഡ്പോയിന്റിൽ വിളിക്കുന്നു.
അഭ്യർത്ഥന തരമാണ് മറ്റൊരു വലിയ മാറ്റം. URL-നേക്കാൾ JSON-ൽ പാരാമീറ്ററുകൾ കൈമാറുന്നതിന്, ഉപയോഗിക്കുമ്പോൾ POST ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു മെഷീൻ ലേണിംഗ് API- കൾ.
നിങ്ങൾ ഒരു ആണെങ്കിൽ മുകളിലെ വാചകം വിഡ്ഢിത്തം പോലെ തോന്നിയേക്കാം ഡാറ്റ ശാസ്ത്രജ്ഞൻ, പക്ഷെ അത് കുഴപ്പമില്ല. മോഡലുകൾ രൂപകൽപ്പന ചെയ്യുന്നതിനും വിന്യസിക്കുന്നതിനും, ഒരാൾ HTTP അഭ്യർത്ഥനകളിലും REST API-കളിലും വിദഗ്ധനായിരിക്കണമെന്നില്ല.
ml model.py എന്നതിനായുള്ള ടാസ്ക്കുകൾ വളരെ കുറവാണ്:
- നിങ്ങൾ മുമ്പ് സൃഷ്ടിച്ച jaymlmodel.py ഫയലിൽ നിന്ന് ഇനിപ്പറയുന്നവ ഇറക്കുമതി ചെയ്യണം: uvicorn, FastAPI, IrisModel, IrisSpecies.
- FastAPI, IrisModel എന്നിവയുടെ ഉദാഹരണങ്ങൾ സൃഷ്ടിക്കുക.
- പ്രവചനങ്ങൾ നടത്താൻ https://127.0.0.1:8000/predict എന്നതിൽ ഒരു ഫംഗ്ഷൻ പ്രഖ്യാപിക്കുക.
- IrisModel.predict species() രീതി IrisSpecies എന്ന തരത്തിലുള്ള ഒരു ഒബ്ജക്റ്റ് സ്വീകരിക്കുന്നു, അതിനെ ഒരു നിഘണ്ടുവിലേക്ക് മാറ്റുന്നു, തുടർന്ന് അത് തിരികെ നൽകുന്നു. റിട്ടേണുകൾ പ്രതീക്ഷിക്കുന്ന ക്ലാസും പ്രവചിച്ച പ്രോബബിലിറ്റിയുമാണ്.
- API എക്സിക്യൂട്ട് ചെയ്യാൻ uvicorn ഉപയോഗിക്കുക.
വീണ്ടും, ഫയലിന്റെ മുഴുവൻ കോഡും അതിന്റെ കമന്റുകളും ഇവിടെയുണ്ട്:
നിങ്ങൾ ചെയ്യേണ്ടത് ഇത്രമാത്രം. അടുത്ത ഘട്ടത്തിൽ, നമുക്ക് API പരിശോധിക്കാം.
API പരിശോധിക്കുന്നു
API എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് ടെർമിനലിലേക്ക് ഇനിപ്പറയുന്ന വരി വീണ്ടും നൽകുക: uvicorn ml_model:app –reload
ഡോക്യുമെന്റേഷൻ പേജ് ദൃശ്യമാകുന്നത് ഇങ്ങനെയാണ്:
അതുകൊണ്ട് ഇന്നത്തെ കാര്യം. ഇതിന് ശേഷമുള്ള ഭാഗത്ത്, നമുക്ക് അവസാനിപ്പിക്കാം.
തീരുമാനം
ഇന്ന്, ലളിതമായ API ഉദാഹരണവും ലളിതമായ ഒരു മെഷീൻ ലേണിംഗ് ഉദാഹരണവും ഉപയോഗിച്ച് FastAPI എന്താണെന്നും അത് എങ്ങനെ ഉപയോഗിക്കാമെന്നും നിങ്ങൾ പഠിച്ചു. API ഡോക്യുമെന്റേഷൻ എങ്ങനെ സൃഷ്ടിക്കാമെന്നും കാണാമെന്നും അത് എങ്ങനെ പരിശോധിക്കാമെന്നും നിങ്ങൾ പഠിച്ചു.
ഒരൊറ്റ കഷണത്തിന് ഇത് ധാരാളം, അതിനാൽ ശരിയായി മനസ്സിലാക്കാൻ കുറച്ച് വായനകൾ ആവശ്യമാണെങ്കിൽ ആശ്ചര്യപ്പെടേണ്ടതില്ല.
സന്തോഷകരമായ കോഡിംഗ്.
നിങ്ങളുടെ അഭിപ്രായങ്ങൾ രേഖപ്പെടുത്തുക