Kapag nagtatrabaho sa larangan ng data science, karaniwan mong nahaharap ang iyong sarili sa isang bagong hamon pagkatapos mong tapusin ang isang mahabang loop ng pagsasanay, fine-tuning, at pagpapabuti. Binabati kita sa pagbuo ng isang modelo ng ML na may mahusay na pagganap at sumasagot sa iyong mga pangangailangan. Ngayon ang hamon na nasa kamay mo ay paano mo maihahatid ang magandang piraso ng teknolohiya sa mga nilalayong user? O baka paano mo mabisang maipapahayag ang iyong resulta sa mga stakeholder sa iyong kumpanya? O kahit paano mo maibabahagi ang iyong mga resulta ng modelo sa iyong mga kasamahan nang epektibo para sa mas mahusay na pakikipagtulungan?
Ang pag-deploy ng machine learning ay maaaring maging mahirap minsan dahil gagamit tayo ng mga teknolohiya at diskarte sa labas ng karaniwang hanay ng kasanayang kailangan para bumuo ng mga modelo.
Sa artikulong ito, tutuklasin natin ang isang paraan upang mag-deploy ng mga modelo ng machine learning gamit lamang ang python. At habang tumatagal, gagawa kami ng modelo ng pagsasalin ng makina at isang web page.
Kaya narito ang mga hakbang na makikita natin:
-
Paggamit ng Huggingface mga modelo ng machine translation.
-
Pagtuklas ng Anvil at pagbuo ng web UI para sa aming modelo.
-
Pagkonekta sa backend at frontend at paglilingkod sa mundo sa aming gawain!
Bumuo ng modelo ng Machine Translation
Ang Huggingface ay isang AI community na nagtatrabaho para "i-demokratize ang mahusay na machine learning." Sa ilalim ng inisyatiba na ito, makakahanap ka ng maraming sinanay na modelo sa iba't ibang mga gawain sa pag-aaral ng machine: pagse-segment ng larawan, text to speech, pagbuo ng text... at pati na rin ang machine translation!
Ang pagsasalin ng makina ay isang gawain lamang sa pagsasalin sa pagitan ng dalawang wika na ginagawa ng isang piraso ng software, sa aming kaso, isang modelo ng machine learning na binuo gamit ang mga transformer.
Ang isang transpormer ay isang malalim na arkitektura ng pag-aaral batay sa atensyon. Patakbuhin natin ito sa iyong makina!
Gagamit kami ng transformers, isang python library para i-download ang MT model at magsagawa ng pagsasalin.
pip install torch
pip install transformers
Pagkatapos i-install ang mga kinakailangang pakete, i-import ang mga sumusunod na module:
from transformers import MarianTokenizer, MarianMTModel
from typing import List
Kumuha tayo ng isang modelo na nagsasalin ng isang pangungusap mula sa Aleman patungo sa Ingles. Kailangan namin ang pangalan ng modelo:
src= "de"
trg= "en"
mname= f'Helsinki-NLP/opus-mt-{src}-{trg}'
Ngayon, i-import natin ang sinanay na modelo at ang tokenizer gamit ang mga sumusunod na linya:
model = MarianMTModel.from_pretrained(mname)
tok = MarianTokenizer.from_pretrained(mname)
Ang laki ng pag-download ay humigit-kumulang 300mb, pagkatapos mong matapos ay maaari mong iimbak ang modelo sa isang lokal na direktoryo gamit ang sumusunod:
model.save_pretrained("./models/de_en/")
tok.save_pretrained("./models/de_en/tok")
Let's the model:
text="ich habe keine ahnung"
gen = model.generate(**tok.prepare_seq2seq_batch(src_texts=[text], return_tensors="pt"))
words: List[str] = tok.batch_decode(gen, skip_special_tokens=True)
print(words[0])
Ngayon ay dapat ay mayroon kang pagsasalin sa Ingles ng pangungusap na naka-imbak sa mga salita[0].
Tuklasin ang Anvil at bumuo ng web UI
Ang Anvil ay isang framework at isang stack ng mga solusyon na nagbibigay-daan sa iyong bumuo ng mga web application gamit lang ang python code. Mayroon itong drag and drop na editor upang bumuo ng web UI at pinapayagan ka nitong ikonekta ang code mula sa iyong lokal na makina sa UI na iyong binuo at i-host ang iyong application sa pamamagitan ng pagbibigay sa iyo ng link na maaari mong ibahagi.
Kaya magsimula tayo sa paggawa ng application mula dito. Pumili ng blangko na aplikasyon pagkatapos ay disenyo ng materyal.
Dapat kang makakita ng ganito:
Ngayon aasahan ko sa iyo na gamitin ang editor at bumuo ng isang bagay na katulad ng sumusunod:
Sa simpleng UI na ito, mayroon kaming dalawang DropDown para sa pagpili ng pinagmulan at patutunguhang mga wika. Mayroon din kaming TextBox para ipasok ang source text at richText component para ipakita ang isinalin na text. Maaari ka ring makakita ng Button upang simulan ang gawain sa pagsasalin.
Upang mag-synchronize sa mga snippet ng code na makikita mo sa ibaba, ibigay ang parehong mga ID sa mga bahagi. Sa ibaba maaari kang makahanap ng isang halimbawa kung saan maaari mong itakda ang id ng isang bahagi:
Ang mga ID na ginagamit namin ay:
|
Component |
ID |
|---|---|
| DropDown ng pinagmulang wika | source_lang |
| DropDown ng patutunguhang wika | dest_lang |
| Pinagmulang wika TextBox | source_text |
| Isinalin na tekstong RichText | translated_text |
Onclick function
Nagdagdag kami ng button na ginagamit upang simulan ang pagsasalin. Mula sa iyong editor, mag-click sa pindutan pagkatapos ay mag-scroll pababa sa panel ng mga katangian. Sa ibaba, makakakita ka ng seksyon ng kaganapan. Sa text zone sa tabi ng “click”, ilagay ang “translate” at pagkatapos ay mag-click sa arrow sa kanan ng text zone na ito.
Dadalhin ka nito sa view ng code kung saan makikita mo ang ilang awtomatikong nabuong python code.
Malalaman mong awtomatikong nagdagdag ang anvil ng function na tinatawag na translate. Tatawagin ito sa tuwing na-click ang button sa aming UI.
Narito kung ano ang dapat na hitsura ng function:
def translate(self, **event_args):
"""This method is called when the button is clicked"""
src_lang=self.source_lang.selected_value #get the selected source language
dest_lang=self.dest_lang.selected_value #get the selected destination language
text=self.source_text.text #get the text written in source language
#call the server function
translated_text=anvil.server.call("translation",text,src_lang,dest_lang)
#write the translated text to the UI
self.translated_text.content=translated_text
Ang function na ito ay gumaganap ng 3 pangunahing gawain:
-
Kumuha ng Impormasyon mula sa UI
-
Ipadala ang impormasyon sa aming backend gamit ang function ng server na "pagsasalin" (ipapaliwanag namin ito sa susunod na seksyon)
-
Ipadala ang isinalin na teksto sa UI.
Pag-andar ng server
Tumutok tayo sa linyang ito ng code:
translated_text=anvil.server.call("translation",text,src_lang,dest_lang)
Gumagamit kami ng anvil.server.call upang tumawag sa isang function ng server na tinatawag na translation na tutukuyin namin sa aming backend code sa lokal na makina.
Ang function na ito ay magsisilbing koneksyon sa pagitan ng web UI at ng backend code na tatakbo sa aming machine translation model.
Tulad ng iyong napansin, ipinapadala rin namin ang mga parameter ng function na ito sa function na anvil.server.call.
I-deploy ang aming MT model
Mag-install muna tayo ng anvil
pip install anvil-uplink
Ngayon ay binuo namin ang aming web interface sa anvil editor at mayroon kaming mga pangunahing bloke ng code upang patakbuhin ang aming modelo ng pagsasalin ng makina at gumawa ng pagsasalin.
Ang susunod na hakbang ay tukuyin ang function ng server na tinalakay natin sa nakaraang seksyon.
Narito ang code ng function:
@anvil.server.callable
def translation(text,src,dest):
lang_code={"English":"en",
"German":"de",
"French":"fr",
"Spanish":"es"}
model=MarianMTModel.from_pretrained("./models/"+lang_code[src]+"_"+lang_code[dest])
tok=MarianTokenizer.from_pretrained("./models/"+lang_code[src]+"_"+lang_code[dest]+"/tok")
gen = model.generate(**tok.prepare_seq2seq_batch(src_texts=[text], return_tensors="pt"))
words: List[str] = tok.batch_decode(gen, skip_special_tokens=True)
return words[0]
Dadalhin ng function ang 3 parameter na ipinadala mula sa frontend, iko-convert ang pinagmulan at patutunguhang mga wika sa kani-kanilang mga code ng wika at pagkatapos ay i-load ang mga modelo at kalkulahin ang pagsasalin at ibabalik ang resulta.
Ang paraan upang ideklara ang function na ito sa anvil bilang isang function ng server ay sa pamamagitan ng paggamit ng dekorador
@anvil.server.callable.
Mayroon kaming huling hakbang na dapat gawin upang ikonekta ang backend code na maaari naming patakbuhin sa isang jupyter notebook sa aming anvil application.
Pumunta sa anvil online editor, mag-click sa icon na gear, at pagkatapos ay mag-click sa “Uplink…”.
Tingnan ang screen sa ibaba
Makakakita ka ng isang popup na lalabas, pagkatapos ay mag-click sa "Paganahin ang server uplink para sa app na ito" upang makuha ang code ng koneksyon na iyong kinopya.
I-paste mo ang code sa sumusunod na linya ng code:
anvil.server.connect("code here")
Ang linyang ito ay magsisimula ng server na nagkokonekta sa iyong lokal na code script o jupyter notebook sa anvil application na may function na translation na nakarehistro bilang isang function ng server.
Huling hakbang
Sa puntong ito, pinapagana mo ang iyong backend server na may function ng server na naglo-load sa modelo ng pagsasalin ng makina at ginagawa ang pagsasalin pagkatapos isaalang-alang ang mga parameter na ipinadala mula sa frontend. Ang figure na ito ay nagbubuod sa kung ano ang pinagsama-sama nating ipinatupad sa ngayon.
Ang huling hakbang ay ang patakbuhin ang application sa pamamagitan ng pag-click sa run button sa tuktok na gitna ng anvil editor.
Pagkatapos patakbuhin ang application na makikita mo sa kanang sulok sa itaas ang isang button na "i-publish ang app na ito" na magbibigay sa iyo ng isang link na maaari mong ibahagi upang ma-access ang application at gawin ang iyong pagsasalin!
Konklusyon
Sa pamamagitan ng pagsunod sa artikulong ito, nakapag-deploy ka ng modelong MT at nakabuo ng web interface para magamit ito.
Marami pa ring matutuklasan kung paano epektibong mag-deploy ng isang modelo gamit ang anvil ngunit mayroon ka na ngayong mga pangunahing kaalaman upang simulan ang iyong paglalakbay sa pag-deploy at palawakin pa ang potensyal ng iyong dating kaalaman sa Python upang makagawa ng higit pa!
Halika Sa Isa Sa Aming Mga Libreng Workshop
Simulan ang iyong karera bilang data scientist sa aming mga libreng workshop, na nakabatay sa isang madaling ibagay na kurikulum at ginagabayan ng mga eksperto sa industriya.
