Ang isang aspeto ng scenario ay ang paggawa ng machine learning model. Dapat itong magamit sa totoong mundo at magagamit sa mga mamimili at developer.
Ang pinakasimple at pinakasikat na paraan upang mag-deploy ng mga modelo ng machine learning ay ang pagsamahin ang mga ito sa isang REST API.
Sa isang sikat na aklatan na tinatawag na FastAPI, iyon mismo ang gagawin natin ngayon.
Pero, ano ba FastAPI?
Ang FastAPI Python web framework ay nilikha mula sa simula upang samantalahin ang mga kontemporaryong kakayahan ng Python.
Para sa asynchronous, sabay-sabay na komunikasyon sa mga kliyente, sumusunod ito sa pamantayan ng ASGI, habang may kakayahan din itong gumamit ng WSGI.
Ang mga endpoint at ruta ay maaaring parehong gumamit ng mga async function. Bukod pa rito, pinapagana ng FastAPI ang produktibong paglikha ng mga web app sa uri-hinted, malinis, kontemporaryong Python code.
Ang pangunahing kaso ng paggamit ng FastAPI ay, gaya ng iminumungkahi ng pangalan, ang paglikha ng mga endpoint ng API.
Ang paggamit ng pamantayan ng OpenAPI, na kinabibilangan ng interactive na Swagger UI, o pagbibigay ng data ng diksyunaryo ng Python bilang JSON ay parehong simpleng paraan upang makamit ito. Gayunpaman, ang FastAPI ay hindi lamang para sa mga API.
Maaari itong magamit upang mag-alok ng mga karaniwang web page gamit ang Jinja2 template engine at maghatid ng mga app na gumagamit ng WebSockets, bilang karagdagan sa halos lahat ng bagay na magagawa ng isang web framework.
Sa artikulong ito, bubuo kami ng isang direktang modelo ng machine learning at pagkatapos ay gagamitin ang FastAPI para i-deploy ito. Magsimula tayo.
Pag-install ng FastAPI at paglikha ng unang API
Ang pag-install ng library at isang ASGI server ay kailangan muna; alinman sa Uvuicorn o Hypercorn ay gagana. Gumagana ito sa pamamagitan ng pagpasok ng sumusunod na command sa Terminal:
Ngayong nagawa na ang API, maaari mong gamitin ang iyong gustong editor ng code at mag-browse dito. Lumikha ng script ng Python na tinatawag na ml_model.py upang makapagsimula. Maaari kang magbigay ng ibang pangalan sa iyo, ngunit para sa kapakanan ng post na ito, tatawagin ko ang file na ito bilang ml_model.py.
Upang lumikha ng isang direktang API na may dalawang endpoint, dapat mong kumpletuhin ang mga sumusunod na gawain:
- I-import ang mga aklatan ng FastAPI at Uvicorn.
- Mag-set up ng isang halimbawa ng klase ng FastAPI.
- Ipahayag ang unang ruta, na, sa pahina ng index, ay gumagawa ng isang diretsong JSON object.
- Ipahayag ang pangalawang ruta, na nagbibigay ng isang direktang JSON object na may naka-customize na mensahe. Ang parameter ng pangalan ay kinuha diretso mula sa URL (halimbawa, https://127.0.0.1:8000/Jay).
- Gamitin ang Uvicorn para patakbuhin ang API.
Ang pagpapatupad ng limang yugtong ito ay ipinapakita sa sumusunod na bit ng code ie. paglikha ng isang simpleng API
Tapos na! Ilunsad natin kaagad ang ating API. Magbukas ng Terminal window sa tabi ng ml model.py file para magawa ito. Susunod, ipasok ang sumusunod:
ang Enter key. Bago magpatuloy, i-debunk natin ang assertion na ito. Ginagamit ng unang app ang Python file name nang mag-isa, nang walang extension. Ang pangalawang app ay dapat may parehong pangalan sa iyong FastAPI instance.
Sa pamamagitan ng paggamit ng -reload, sasabihin mo sa API na gusto mong awtomatikong i-reload ito kapag nai-save mo ang file sa halip na magsimula sa simula.
Ngayon maglunsad ng browser at mag-navigate sa https://127.0.0.1:8000; ang kinalabasan ay dapat lumitaw tulad ng sumusunod:
Naiintindihan mo na ngayon kung paano lumikha ng isang simpleng API gamit ang FastAPI.
Pagbuo at pagsasanay sa modelo ng Machine Learning
Nang walang pagkolekta o pagsusuri ng anumang data, magsasanay lamang kami ng isang simpleng modelo. Ang mga ito ay walang kaugnayan sa pag-deploy ng mga modelo at hindi mahalaga sa paksang nasa kamay.
Ang isang modelong batay sa Iris dataset ay maaaring i-install gamit ang pareho neural network paraan ng pag-install.
At iyon lang ang gagawin namin: i-download ang Iris dataset at sanayin ang modelo. Hindi iyon magiging simple. Upang magsimula, gumawa ng file na pinangalanang jaysmlmodel.py.
Sa loob nito, gagawin mo ang sumusunod:
- Mga Pag-import — Kakailanganin mo ang mga panda, scikit-RandomForecastClassifier, ang BaseModel ng pydantic na alamin (matutuklasan mo kung bakit sa susunod na hakbang), at joblib para sa pag-iimbak at pag-load ng mga modelo.
- Ideklara ang isang klase ng IrisSpecies na nagmana mula sa batayang modelo. Naglalaman lang ang klase na ito ng mga field na kailangan para hulaan ang isang species ng bulaklak (higit pa tungkol doon sa susunod na seksyon)
- Gumawa ng klase. Ang IrisModel ay isang modelong pagsasanay at tool sa paghula.
- Ipahayag ang isang paraan na pinangalanang _train model sa loob ng IrisModel. Ito ay ginagamit upang sanayin ang mga modelo gamit ang Random Forests technique. Ang sinanay na modelo ay ibinalik sa pamamagitan ng pamamaraan.
- Ipahayag ang isang hinulaang function ng species sa loob ng IrisModel. Ginagamit ito sa pagtataya batay sa 4 na input factor (mga sukat ng bulaklak). Parehong ang forecast (mga species ng bulaklak) at ang posibilidad ng hula ay ibinalik ng algorithm.
- Baguhin ang constructor sa IrisModel para ma-load nito ang Iris dataset at sanayin ang modelo kung nawawala ito sa folder. Malulutas nito ang problema ng paulit-ulit na pagsasanay ng mga bagong modelo. Ang joblib library ay ginagamit para sa pag-load at pag-save ng modelo.
Narito ang buong code:
Umaasa ako na ang listahan sa itaas at ang mga komento ay ginawang madaling maunawaan kahit na ito ay isang malaking halaga ng code na gagawin. Ngayong nabuo na ang modelong ito, i-publish natin ang mga kakayahan sa paghula nito sa isang REST API.
Pagbuo ng buong REST API
Bumalik sa ml_model.py file at i-purge ang lahat ng data. Ang boilerplate ay magiging kapareho ng kung ano ang mayroon ka noon, ngunit dapat tayong magsimulang muli sa isang blangkong file.
Isang endpoint lang ang tutukuyin mo sa oras na ito, na siyang ginagamit upang matukoy ang uri ng bulaklak. Ang IrisModel.predict species(), na idineklara sa naunang seksyon, ay tinatawag ng endpoint na ito upang isagawa ang hula.
Ang uri ng kahilingan ay ang iba pang malaking pagbabago. Upang magpadala ng mga parameter sa JSON sa halip na URL, inirerekomenda na gumamit ka ng POST kapag gumagamit machine learning API.
Ang pangungusap sa itaas ay maaaring parang walang kwenta kung ikaw ay a siyentipiko ng data, pero ayos lang. Upang magdisenyo at mag-deploy ng mga modelo, hindi kinakailangang maging eksperto ang isa sa mga kahilingan sa HTTP at REST API.
Ang mga gawain para sa ml model.py ay kakaunti at diretso:
- Dapat mong i-import ang sumusunod mula sa naunang ginawang jaymlmodel.py file: uvicorn, FastAPI, IrisModel, at IrisSpecies.
- Lumikha ng mga pagkakataon ng FastAPI at IrisModel.
- Magdeklara ng function sa https://127.0.0.1:8000/predict para makagawa ng mga hula.
- Ang paraan ng IrisModel.predict species() ay tumatanggap ng isang object ng uri ng IrisSpecies, binabago ito sa isang diksyunaryo, at pagkatapos ay ibinabalik ito. Ang mga pagbabalik ay ang inaasahang klase at hinulaang posibilidad.
- Gumamit ng uvicorn para i-execute ang API.
Muli, narito ang buong code ng file kasama ang mga komento nito:
Iyon lang ang kailangan mong gawin. Sa susunod na hakbang, subukan natin ang API.
Pagsubok sa API
Ipasok muli ang sumusunod na linya sa Terminal upang isagawa ang API: uvicorn ml_model:app –reload
Ganito lumalabas ang pahina ng dokumentasyon:
Kaya't para sa araw na ito. Sa bahagi pagkatapos nito, tapusin natin.
Konklusyon
Ngayon, natutunan mo kung ano ang FastAPI at kung paano ito gamitin, gamit ang parehong simpleng halimbawa ng API at simpleng halimbawa ng machine learning. Natutunan mo rin kung paano gumawa at tingnan ang dokumentasyon ng API, pati na rin kung paano ito subukan.
Malaki iyon para sa isang piraso, kaya huwag magtaka kung kailangan ng ilang pagbabasa upang maunawaan nang maayos.
Maligayang coding.
Mag-iwan ng Sagot