Når du arbejder inden for datavidenskab, står du normalt over for en ny udfordring efter at have afsluttet en lang løkke med træning, finjustering og forbedring. Tillykke med at bygge en ML-model, der har god ydeevne og opfylder dine behov. Nu er udfordringen du har ved hånden, hvordan kan du levere dette gode stykke teknologi til de tilsigtede brugere? Eller måske hvordan kan du effektivt kommunikere dit resultat med interessenter i din virksomhed? Eller endda hvordan kan du dele dine modelresultater med dine kolleger effektivt for bedre samarbejde?
Det kan nogle gange være svært at implementere maskinlæring, da vi vil bruge teknologier og teknikker ud over de sædvanlige færdigheder, der er nødvendige for at bygge modellerne.
I denne artikel skal vi opdage en måde at implementere maskinlæringsmodeller kun ved hjælp af python. Og undervejs bygger vi en maskinoversættelsesmodel og en webside.
Så her er de trin, vi skal se:
-
Brug af Huggingface maskinoversættelsesmodeller.
-
Opdagelse af Anvil og opbygning af en web-brugergrænseflade til vores model.
-
At forbinde backend og frontend og tjene verden vores arbejde!
Byg maskinoversættelsesmodel
Huggingface er et AI-fællesskab, der arbejder på at "demokratisere god maskinlæring". Under dette initiativ kan du finde mange trænede modeller om forskellige maskinlæringsopgaver: billedsegmentering, tekst til tale, tekstgenerering... og også maskinoversættelse!
Maskinoversættelse er simpelthen en oversættelsesopgave mellem to sprog udført af et stykke software, i vores tilfælde en maskinlæringsmodel bygget med transformere.
En transformer er en dyb læringsarkitektur baseret på opmærksomhed. Lad os få det til at køre på din maskine!
Vi vil bruge transformers, et python-bibliotek til at downloade MT-modellen og udføre en oversættelse.
pip install torch
pip install transformers
Efter installation af de nødvendige pakker skal du importere følgende moduler:
from transformers import MarianTokenizer, MarianMTModel
from typing import List
Lad os få en model, der oversætter en sætning fra tysk til engelsk. Vi skal bruge navnet på modellen:
src= "de"
trg= "en"
mname= f'Helsinki-NLP/opus-mt-{src}-{trg}'
Lad os nu importere den trænede model og tokenizeren ved hjælp af følgende linjer:
model = MarianMTModel.from_pretrained(mname)
tok = MarianTokenizer.from_pretrained(mname)
Downloadstørrelsen er omkring 300mb, efter afslutning kan du gemme modellen i en lokal mappe ved hjælp af følgende:
model.save_pretrained("./models/de_en/")
tok.save_pretrained("./models/de_en/tok")
Lad os 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 skulle du have den engelske oversættelse af sætningen gemt i ord[0].
Opdag Amvil og byg en web-brugergrænseflade
Anvil er en ramme og en stak af løsninger, der giver dig mulighed for at bygge webapplikationer ved kun at bruge python-kode. Den har en træk og slip-editor til at bygge web-UI, og den giver dig mulighed for at forbinde koden fra din lokale maskine til den brugergrænseflade, du bygger og hoster din applikation ved at give dig et link, som du kan dele.
Så lad os starte med at oprette en applikation her. Vælg blank applikation og derefter materialedesign.
Du bør se noget som dette:
Nu vil jeg regne med, at du bruger editoren og bygger noget, der ligner følgende:
I denne enkle brugergrænseflade har vi to DropDows til at vælge kilde- og destinationssprog. Vi har også en tekstboks til at indtaste kildeteksten og en richText-komponent til at vise den oversatte tekst. Du kan også se en knap for at starte oversættelsesopgaven.
For at synkronisere med kodestykkerne, som du vil se nedenfor, skal du give de samme id'er til komponenterne. Nedenfor kan du finde et eksempel på, hvor du kan indstille id'et for en komponent:
De id'er vi bruger er:
|
Komponent |
ID |
|---|---|
| Kildesprog DropDown | source_lang |
| Destinationssprog DropDown | dest_lang |
| Kildesprog TextBox | kildetekst |
| Oversat tekst RichText | oversat_tekst |
Onclick-funktion
Vi har tilføjet en knap, der bruges til at starte oversættelsen. Fra din editor skal du klikke på knappen og derefter rulle ned i egenskabspanelet. Nederst vil du se en begivenhedssektion. Indtast "oversæt" i tekstzonen ved siden af "klik", og klik derefter på pilen til højre for denne tekstzone.
Dette vil tage dig til kodevisningen, hvor du vil se noget automatisk genereret python-kode.
Du vil opdage, at ambolt automatisk har tilføjet en funktion kaldet oversætte. Det vil blive kaldt hver gang der klikkes på knappen i vores brugergrænseflade.
Sådan skal funktionen se ud:
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 funktion udfører 3 hovedopgaver:
-
Få oplysninger fra brugergrænsefladen
-
Send oplysningerne til vores backend ved hjælp af serverfunktionen "oversættelse" (vi vil forklare det i næste afsnit)
-
Send den oversatte tekst til brugergrænsefladen.
Serverfunktion
Lad os fokusere på denne kodelinje:
translated_text=anvil.server.call("translation",text,src_lang,dest_lang)
Vi bruger anvil.server.call til at kalde en serverfunktion kaldet oversættelse, som vi vil definere i vores backend-kode på den lokale maskine.
Denne funktion vil fungere som en forbindelse mellem web-UI og backend-koden, der kører på vores maskinoversættelsesmodel.
Som du har bemærket, sender vi også parametrene for denne funktion i funktionen anvil.server.call.
Implementer vores MT-model
Lad os først installere ambolt
pip install anvil-uplink
Nu har vi bygget vores webgrænseflade i ambolt-editor, og vi har grundlæggende kodeblokke til at køre vores maskinoversættelsesmodel og lave en oversættelse.
Det næste trin er at definere serverfunktionen, som vi har diskuteret i det foregående afsnit.
Her er koden til 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 vil tage de 3 parametre sendt fra frontend, konvertere kilde- og destinationssprogene til de respektive sprogkoder og derefter indlæse modellerne og beregne oversættelsen og returnere resultatet.
Måden at erklære denne funktion for ambolt som en serverfunktion er ved at bruge dekoratøren
@anvil.server.callable.
Vi har et sidste trin at gøre for at forbinde backend-koden, som vi kan køre i en jupyter-notesbog til vores ambolt-applikation.
Gå til ambolt online editor, klik på tandhjulsikonet, og klik derefter på "Uplink...".
Se skærmbilledet nedenfor
Du vil se en popup vises, og klik derefter på "Aktiver server-uplink for denne app" for at få den forbindelseskode, du kopierer.
Du indsætter koden i følgende kodelinje:
anvil.server.connect("code here")
Denne linje vil starte en server, der forbinder dit lokale kodescript eller jupyter-notebook til amboltapplikationen med funktionen oversættelse registreret som en serverfunktion.
Sidste trin
Til dette punkt har du din backend-server kørende med en serverfunktion, der indlæser maskinoversættelsesmodellen og udfører oversættelsen efter at have taget hensyn til parametrene sendt fra frontend. Denne figur opsummerer, hvad vi har implementeret sammen indtil nu.
Et sidste trin er at køre programmet ved at klikke på Kør-knappen øverst i midten af ambolt-editoren.
Efter at have kørt applikationen ser du i øverste højre hjørne en knap "udgiv denne app", som giver dig et link, som du kan dele for at få adgang til applikationen og lave din oversættelse!
Konklusion
Ved at følge denne artikel har du været i stand til at implementere en MT-model og bygge en webgrænseflade til at bruge den.
Der er stadig meget at opdage om, hvordan man effektivt implementerer en model ved hjælp af ambolt, men nu har du det grundlæggende til at starte din implementeringsrejse og fremme potentialet i din tidligere viden i Python til at gøre meget mere!
Kom til en af vores gratis workshops
Start din karriere som dataforsker med vores gratis workshops, som er baseret på en tilpasselig læseplan og guidet af brancheeksperter.
