När du arbetar inom området datavetenskap står du vanligtvis inför en ny utmaning efter att ha avslutat en lång slinga med träning, finjustering och förbättring. Grattis till att du har byggt en ML-modell som har bra prestanda och svarar på dina behov. Nu är utmaningen du har till hands hur kan du leverera denna trevliga teknik till de avsedda användarna? Eller kanske hur kan du effektivt kommunicera ditt resultat med intressenter i ditt företag? Eller till och med hur kan du dela dina modellresultat med dina kollegor på ett effektivt sätt för bättre samarbete?
Att implementera maskininlärning kan ibland vara svårt eftersom vi kommer att använda teknologier och tekniker utöver de vanliga färdigheter som behövs för att bygga modellerna.
I den här artikeln kommer vi att upptäcka ett sätt att distribuera maskininlärningsmodeller med enbart python. Och längs vägen kommer vi att bygga en maskinöversättningsmodell och en webbsida.
Så här är stegen som vi kommer att se:
-
Använda Huggingface maskinöversättningsmodeller.
-
Upptäcka Anvil och bygga ett webbgränssnitt för vår modell.
-
Koppla ihop backend och frontend och tjäna världen vårt arbete!
Bygg maskinöversättningsmodell
Huggingface är en AI-gemenskap som arbetar för att "demokratisera bra maskininlärning". Under detta initiativ kan du hitta många utbildade modeller för olika maskininlärningsuppgifter: bildsegmentering, text till tal, textgenerering... och även maskinöversättning!
Maskinöversättning är helt enkelt en översättningsuppgift mellan två språk som utförs av en mjukvara, i vårt fall en maskininlärningsmodell byggd med transformatorer.
En transformator är en djupinlärningsarkitektur baserad på uppmärksamhet. Låt oss köra det på din maskin!
Vi kommer att använda transformers, ett pythonbibliotek för att ladda ner MT-modellen och utföra en översättning.
pip install torch
pip install transformers
När du har installerat de nödvändiga paketen importerar du följande moduler:
from transformers import MarianTokenizer, MarianMTModel
from typing import List
Låt oss skaffa en modell som översätter en mening från tyska till engelska. Vi behöver namnet på modellen:
src= "de"
trg= "en"
mname= f'Helsinki-NLP/opus-mt-{src}-{trg}'
Låt oss nu importera den tränade modellen och tokenizern med hjälp av följande rader:
model = MarianMTModel.from_pretrained(mname)
tok = MarianTokenizer.from_pretrained(mname)
Nedladdningsstorleken är cirka 300mb, efter att du är klar kan du lagra modellen i en lokal katalog med följande:
model.save_pretrained("./models/de_en/")
tok.save_pretrained("./models/de_en/tok")
Låt oss modellen:
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])
Nu bör du ha den engelska översättningen av meningen lagrad i ord[0].
Upptäck Anvil och bygg ett webbgränssnitt
Anvil är ett ramverk och en hög med lösningar som låter dig bygga webbapplikationer med enbart pythonkod. Den har en dra och släpp-redigerare för att bygga webbgränssnitt och den låter dig ansluta koden från din lokala dator till det användargränssnitt du bygger och är värd för din applikation genom att ge dig en länk som du kan dela.
Så låt oss börja med att skapa en applikation från här. Välj tom applikation sedan materialdesign.
Du borde se något sånt här:
Nu kommer jag att räkna med att du använder editorn och bygger något som liknar följande:
I detta enkla användargränssnitt har vi två DropDows för att välja käll- och målspråk. Vi har också en TextBox för att skriva in källtexten och en richText-komponent för att visa den översatta texten. Du kan också se en knapp för att starta översättningsuppgiften.
För att synkronisera med kodavsnitten som du kommer att se nedan, ge samma ID till komponenterna. Nedan hittar du ett exempel på var du kan ställa in id för en komponent:
ID:n vi använder är:
|
Komponent |
ID |
|---|---|
| Källspråk DropDown | source_lang |
| Destinationsspråk DropDown | dest_lang |
| Källspråk TextBox | källa_text |
| Översatt text RichText | översatt_text |
Onclick-funktion
Vi har lagt till en knapp som används för att starta översättningen. Från din editor klickar du på knappen och bläddrar sedan ner i egenskapspanelen. Längst ner ser du en händelsesektion. I textzonen bredvid "klicka", skriv "översätt" och klicka sedan på pilen till höger om denna textzon.
Detta tar dig till kodvyn där du kommer att se lite automatiskt genererad python-kod.
Du kommer att upptäcka att städet automatiskt har lagt till en funktion som heter translate. Den kommer att anropas varje gång knappen i vårt användargränssnitt klickas.
Så här ska funktionen se ut:
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
Denna funktion utför 3 huvuduppgifter:
-
Få information från användargränssnittet
-
Skicka informationen till vår backend med serverfunktionen "översättning" (vi kommer att förklara det i nästa avsnitt)
-
Skicka den översatta texten till användargränssnittet.
Serverfunktion
Låt oss fokusera på denna kodrad:
translated_text=anvil.server.call("translation",text,src_lang,dest_lang)
Vi använder anvil.server.call för att anropa en serverfunktion som heter translation som vi kommer att definiera i vår backend-kod på den lokala maskinen.
Denna funktion kommer att fungera som en koppling mellan webbgränssnittet och backend-koden som kommer att köras på vår maskinöversättningsmodell.
Som du har märkt skickar vi även parametrarna för denna funktion i funktionen anvil.server.call.
Distribuera vår MT-modell
Låt oss först installera städet
pip install anvil-uplink
Nu har vi byggt vårt webbgränssnitt i städredigerare och vi har grundläggande kodblock för att köra vår maskinöversättningsmodell och göra en översättning.
Nästa steg är att definiera serverfunktionen som vi har diskuterat i föregående avsnitt.
Här är koden för funktionen:
@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]
Funktionen tar de 3 parametrarna som skickas från frontend, konverterar käll- och destinationsspråken till respektive språkkoder och laddar sedan modellerna och beräknar översättningen och returnerar resultatet.
Sättet att deklarera denna funktion för städet som en serverfunktion är att använda dekoratorn
@anvil.server.callable.
Vi har ett sista steg att göra för att ansluta backend-koden som vi kan köra i en Jupyter-anteckningsbok till vår städapplikation.
Gå till städets onlineredigerare, klicka på kugghjulsikonen och klicka sedan på "Uplink...".
Se skärmen nedan
Du kommer att se ett popup-fönster, klicka sedan på "Aktivera serverupplänk för denna app" för att få anslutningskoden som du kopierar.
Du klistrar in koden i följande kodrad:
anvil.server.connect("code here")
Den här raden kommer att starta en server som ansluter ditt lokala kodskript eller jupyter-anteckningsbok till städapplikationen med funktionen översättning registrerad som en serverfunktion.
Sista steget
Till denna punkt har du din backend-server igång med en serverfunktion som laddar maskinöversättningsmodellen och gör översättningen efter att ha tagit hänsyn till parametrarna som skickas från frontend. Den här figuren sammanfattar vad vi har genomfört tillsammans hittills.
Ett sista steg är att köra programmet genom att klicka på knappen Kör längst upp i mitten av städredigeraren.
Efter att ha kört applikationen ser du i det övre högra hörnet en knapp "publicera den här appen" som ger dig en länk som du kan dela för att komma åt applikationen och göra din översättning!
Slutsats
Genom att följa den här artikeln har du kunnat distribuera en MT-modell och bygga ett webbgränssnitt för att använda den.
Det finns fortfarande mycket att upptäcka om hur man effektivt distribuerar en modell med hjälp av städet, men nu har du grunderna för att starta din distributionsresa och främja potentialen hos dina förkunskaper i Python för att göra mycket mer!
Kom till en av våra kostnadsfria workshops
Börja din karriär som datavetare med våra gratis workshops, som är baserade på en anpassningsbar läroplan och vägleds av branschexperter.
