Når du jobber innen datavitenskap, står du vanligvis overfor en ny utfordring etter å ha fullført en lang løkke med trening, finjustering og forbedring. Gratulerer med å bygge en ML-modell som har god ytelse og svarer til dine behov. Nå er utfordringen du har for hånden, hvordan kan du levere denne fine teknologien til de tiltenkte brukerne? Eller kanskje hvordan kan du effektivt kommunisere resultatet med interessenter i din bedrift? Eller til og med hvordan kan du dele modellresultatene dine med kollegene dine effektivt for bedre samarbeid?
Implementering av maskinlæring kan noen ganger være vanskelig siden vi vil bruke teknologier og teknikker utenfor det vanlige ferdighetssettet som trengs for å bygge modellene.
I denne artikkelen skal vi oppdage en måte å distribuere maskinlæringsmodeller kun ved å bruke python. Og underveis skal vi bygge en maskinoversettelsesmodell og en nettside.
Så her er trinnene vi skal se:
-
Bruke Huggingface maskinoversettelsesmodeller.
-
Oppdage Anvil og bygge et nettgrensesnitt for modellen vår.
-
Koble sammen backend og frontend og tjene verden vårt arbeid!
Bygg maskinoversettelsesmodell
Huggingface er et AI-fellesskap som jobber for å «demokratisere god maskinlæring». Under dette initiativet kan du finne mange trente modeller for ulike maskinlæringsoppgaver: bildesegmentering, tekst til tale, tekstgenerering... og også maskinoversettelse!
Maskinoversettelse er ganske enkelt en oversettelsesoppgave mellom to språk utført av et stykke programvare, i vårt tilfelle, en maskinlæringsmodell bygget med transformatorer.
En transformator er en dyp læringsarkitektur basert på oppmerksomhet. La oss få den til å kjøre på maskinen din!
Vi vil bruke transformers, et python-bibliotek for å laste ned MT-modellen og utføre en oversettelse.
pip install torch
pip install transformers
Etter at du har installert de nødvendige pakkene, importerer du følgende moduler:
from transformers import MarianTokenizer, MarianMTModel
from typing import List
La oss få en modell som oversetter en setning fra tysk til engelsk. Vi trenger navnet på modellen:
src= "de"
trg= "en"
mname= f'Helsinki-NLP/opus-mt-{src}-{trg}'
La oss nå importere den trente modellen og tokenizeren ved å bruke følgende linjer:
model = MarianMTModel.from_pretrained(mname)
tok = MarianTokenizer.from_pretrained(mname)
Nedlastingsstørrelsen er omtrent 300 MB, etter at du er ferdig kan du lagre modellen i en lokal katalog ved å bruke følgende:
model.save_pretrained("./models/de_en/")
tok.save_pretrained("./models/de_en/tok")
La 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])
Nå bør du ha den engelske oversettelsen av setningen lagret i ord[0].
Oppdag Amvil og bygg et nettgrensesnitt
Anvil er et rammeverk og en stabel med løsninger som lar deg bygge nettapplikasjoner med kun python-kode. Den har en dra-og-slipp-editor for å bygge web-UI, og den lar deg koble koden fra din lokale maskin til brukergrensesnittet du bygger og er vert for applikasjonen ved å gi deg en lenke du kan dele.
Så la oss begynne med å lage en applikasjon fra her. Velg blank applikasjon og deretter materialdesign.
Du bør se noe slikt:
Nå vil jeg stole på at du bruker editoren og bygger noe som ligner på følgende:
I dette enkle brukergrensesnittet har vi to DropDows for å velge kilde- og destinasjonsspråk. Vi har også en tekstboks for å legge inn kildeteksten og en richText-komponent for å vise den oversatte teksten. Du kan også se en knapp for å starte oversettelsesoppgaven.
For å synkronisere med kodebitene som du vil se nedenfor, gi de samme IDene til komponentene. Nedenfor finner du et eksempel på hvor du kan angi id for en komponent:
ID-ene vi bruker er:
|
Komponent |
ID |
|---|---|
| Kildespråk DropDown | source_lang |
| Destinasjonsspråk DropDown | dest_lang |
| Kildespråk TextBox | kildetekst |
| Oversatt tekst RichText | oversatt_tekst |
Onclick-funksjon
Vi har lagt til en knapp som brukes til å starte oversettelsen. Fra redaktøren din klikker du på knappen og bla nedover i egenskapspanelet. Nederst vil du se en hendelsesdel. I tekstsonen ved siden av "klikk", skriv inn "oversett" og klikk deretter på pilen til høyre for denne tekstsonen.
Dette tar deg til kodevisningen hvor du vil se noe automatisk generert python-kode.
Du vil oppdage at ambolten automatisk har lagt til en funksjon som heter translate. Den vil bli kalt opp hver gang knappen i brukergrensesnittet vårt klikkes.
Slik skal funksjonen 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
Denne funksjonen utfører 3 hovedoppgaver:
-
Få informasjon fra brukergrensesnittet
-
Send informasjonen til vår backend ved hjelp av serverfunksjonen "oversettelse" (vi vil forklare det i neste avsnitt)
-
Send den oversatte teksten til brukergrensesnittet.
Serverfunksjon
La oss fokusere på denne kodelinjen:
translated_text=anvil.server.call("translation",text,src_lang,dest_lang)
Vi bruker anvil.server.call for å kalle en serverfunksjon kalt translation som vi vil definere i vår backend-kode på den lokale maskinen.
Denne funksjonen vil fungere som en forbindelse mellom nettgrensesnittet og backend-koden som vil kjøre på vår maskinoversettelsesmodell.
Som du har lagt merke til sender vi også parametrene til denne funksjonen i funksjonen anvil.server.call.
Implementer MT-modellen vår
La oss først installere ambolt
pip install anvil-uplink
Nå har vi bygget nettgrensesnittet vårt i ambolteditor, og vi har grunnleggende kodeblokker for å kjøre vår maskinoversettelsesmodell og gjøre en oversettelse.
Det neste trinnet er å definere serverfunksjonen som vi har diskutert i forrige avsnitt.
Her er koden til funksjonen:
@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]
Funksjonen vil ta de 3 parameterne som sendes fra frontend, konvertere kilde- og destinasjonsspråkene til de respektive språkkodene og deretter laste modellene og beregne oversettelsen og returnere resultatet.
Måten å erklære denne funksjonen for ambolt som en serverfunksjon er ved å bruke dekoratoren
@anvil.server.callable.
Vi har et siste trinn å gjøre for å koble backend-koden som vi kan kjøre i en jupyter-notisbok til amboltapplikasjonen vår.
Gå til ambolt online editor, klikk på tannhjulikonet, og klikk deretter på "Uplink...".
Se skjermen nedenfor
Du vil se en popup vises, og klikk deretter på "Aktiver serveroppkobling for denne appen" for å få tilkoblingskoden du kopierer.
Du limer inn koden i følgende kodelinje:
anvil.server.connect("code here")
Denne linjen vil starte en server som kobler ditt lokale kodeskript eller jupyter-notisbok til amboltapplikasjonen med funksjonen oversettelse registrert som en serverfunksjon.
Siste trinn
Til dette punktet har du backend-serveren din som kjører med en serverfunksjon som laster maskinoversettelsesmodellen og gjør oversettelsen etter å ha tatt hensyn til parametrene sendt fra frontend. Denne figuren oppsummerer det vi har gjennomført sammen så langt.
Et siste trinn er å kjøre programmet ved å klikke på kjør-knappen øverst i midten av ambolt-editoren.
Etter å ha kjørt applikasjonen ser du øverst til høyre en knapp "publiser denne appen" som vil gi deg en lenke som du kan dele for å få tilgang til applikasjonen og gjøre oversettelsen din!
Konklusjon
Ved å følge denne artikkelen har du vært i stand til å distribuere en MT-modell og bygge et nettgrensesnitt for å bruke den.
Det er fortsatt mye å finne ut om hvordan du effektivt kan distribuere en modell ved hjelp av ambolt, men nå har du det grunnleggende for å starte din distribusjonsreise og fremme potensialet til forkunnskapene dine i Python til å gjøre mye mer!
Kom til en av våre gratis workshops
Start din karriere som dataforsker med våre gratis workshops, som er basert på en tilpasningsdyktig læreplan og veiledet av bransjeeksperter.
