Als je op het gebied van data science werkt, sta je meestal voor een nieuwe uitdaging nadat je een lange cyclus van training, finetuning en verbetering hebt afgerond. Gefeliciteerd met het bouwen van een ML-model dat goede prestaties levert en aan uw behoeften voldoet. De uitdaging die u nu heeft, is: hoe kunt u dit mooie stukje technologie aan de beoogde gebruikers leveren? Of misschien: hoe kunt u uw resultaat effectief communiceren met belanghebbenden in uw bedrijf? Of zelfs: hoe kunt u uw modelresultaten effectief met uw collega's delen voor een betere samenwerking?
Het inzetten van machine learning kan soms moeilijk zijn, omdat we technologieën en technieken zullen gebruiken die buiten de gebruikelijke vaardigheden vallen die nodig zijn om de modellen te bouwen.
In dit artikel gaan we een manier ontdekken om machine learning-modellen te implementeren met alleen Python. En gaandeweg zullen we een machinevertaalmodel en een webpagina bouwen.
Dus hier zijn de stappen die we gaan zien:
-
Gebruik van Huggingface automatische vertaalmodellen.
-
Anvil ontdekken en een web-UI voor ons model bouwen.
-
Backend en frontend verbinden en de wereld ons werk dienen!
Bouw een machinevertalingsmodel
Huggingface is een AI-gemeenschap die werkt aan “het democratiseren van goed machine learning”. Onder dit initiatief kun je veel getrainde modellen vinden over verschillende machine learning-taken: beeldsegmentatie, tekst-naar-spraak, tekstgeneratie… en ook automatische vertaling!
Machinevertaling is eenvoudigweg een vertaaltaak tussen twee talen, uitgevoerd door een stukje software, in ons geval een machine learning-model gebouwd met transformatoren.
Een transformator is een deep learning-architectuur gebaseerd op aandacht. Laten we het op uw machine laten draaien!
We zullen transformers, een Python-bibliotheek, gebruiken om het MT-model te downloaden en een vertaling uit te voeren.
pip install torch
pip install transformers
Na het installeren van de benodigde pakketten importeert u de volgende modules:
from transformers import MarianTokenizer, MarianMTModel
from typing import List
Laten we een model nemen dat een zin van Duits naar Engels vertaalt. We hebben de naam van het model nodig:
src= "de"
trg= "en"
mname= f'Helsinki-NLP/opus-mt-{src}-{trg}'
Laten we nu het getrainde model en de tokenizer importeren met behulp van de volgende regels:
model = MarianMTModel.from_pretrained(mname)
tok = MarianTokenizer.from_pretrained(mname)
De downloadgrootte is ongeveer 300 MB. Na voltooiing kunt u het model als volgt in een lokale map opslaan:
model.save_pretrained("./models/de_en/")
tok.save_pretrained("./models/de_en/tok")
Laten we het 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])
Nu zou de Engelse vertaling van de zin opgeslagen moeten zijn in words[0].
Ontdek Anvil en bouw een web-UI
Anvil is een raamwerk en een stapel oplossingen waarmee u webapplicaties kunt bouwen met uitsluitend Python-code. Het heeft een drag-and-drop-editor om een web-UI te bouwen en u kunt de code van uw lokale machine verbinden met de UI die u bouwt en uw applicatie hosten door u een link te geven die u kunt delen.
Laten we dus beginnen met het maken van een applicatie vanaf hier. Kies blanco toepassing en vervolgens materiaalontwerp.
Je zou zoiets als dit moeten zien:
Nu reken ik erop dat je de editor gebruikt en iets bouwt dat lijkt op het volgende:
In deze eenvoudige gebruikersinterface hebben we twee vervolgkeuzelijsten voor het kiezen van de bron- en doeltalen. We hebben ook een TextBox om de brontekst in te voeren en een richText-component om de vertaalde tekst weer te geven. U kunt ook een knop zien waarmee u de vertaaltaak kunt starten.
Om te synchroniseren met de codefragmenten die u hieronder ziet, geeft u dezelfde ID's aan de componenten. Hieronder vindt u een voorbeeld van waar u de id van een component kunt instellen:
De ID's die we gebruiken zijn:
<tabelrand="2">
Component
ID
Onclick-functie
We hebben een knop toegevoegd die wordt gebruikt om de vertaling te starten. Klik vanuit uw editor op de knop en scroll vervolgens naar beneden in het eigenschappenpaneel. Onderaan ziet u een evenementengedeelte. Voer in de tekstzone naast “klik” “vertalen” in en klik vervolgens op de pijl rechts van deze tekstzone.
Dit brengt je naar de codeweergave waar je een aantal automatisch gegenereerde Python-code zult zien.
Je zult zien dat aambeeld automatisch een functie heeft toegevoegd met de naam vertalen. Het wordt elke keer aangeroepen wanneer op de knop in onze gebruikersinterface wordt geklikt.
Hier ziet u hoe de functie eruit zou moeten zien:
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
Deze functie voert 3 hoofdtaken uit:
-
Haal informatie op via de gebruikersinterface
-
Stuur de informatie naar onze backend met behulp van de serverfunctie “vertaling” (we leggen dit in de volgende sectie uit)
-
Stuur de vertaalde tekst naar de gebruikersinterface.
Serverfunctie
Laten we ons concentreren op deze regel code:
translated_text=anvil.server.call("translation",text,src_lang,dest_lang)
We gebruiken anvil.server.call om een serverfunctie aan te roepen genaamd translation die we zullen definiëren in onze backend-code op de lokale machine.
Deze functie zal dienen als verbinding tussen de webinterface en de backendcode die op ons machinevertaalmodel zal draaien.
Zoals je hebt gemerkt sturen we de parameters van deze functie ook naar de functie anvil.server.call.
Implementeer ons MT-model
Laten we eerst het aambeeld installeren
pip install anvil-uplink
Nu hebben we onze webinterface in de aambeeldeditor gebouwd en hebben we basiscodeblokken om ons machinevertaalmodel uit te voeren en een vertaling uit te voeren.
De volgende stap is het definiëren van de serverfunctie die we in de vorige sectie hebben besproken.
Hier is de code van de functie:
@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]
De functie neemt de 3 parameters die vanaf de frontend worden verzonden, converteert de bron- en doeltalen naar de respectievelijke taalcodes en laadt vervolgens de modellen, berekent de vertaling en retourneert het resultaat.
De manier om deze functie als serverfunctie aan het aambeeld te declareren, is door de decorateur te gebruiken
@anvil.server.callable.
We moeten nog een laatste stap doen om de backend-code die we in een jupyter-notebook kunnen uitvoeren, te verbinden met onze aambeeld-applicatie.
Ga naar de online editor van het aambeeld, klik op het tandwielpictogram en klik vervolgens op "Uplink ...".
Zie onderstaand scherm
U ziet een pop-up verschijnen en klikt vervolgens op 'Server-uplink inschakelen voor deze app' om de verbindingscode te krijgen die u kopieert.
Je plakt de code in de volgende coderegel:
anvil.server.connect("code here")
Deze regel start een server die uw lokale codescript of jupyter-notebook verbindt met de aambeeldtoepassing met de functie 'vertaling' geregistreerd als een serverfunctie.
Laatste stap
Tot nu toe draait uw backend-server met een serverfunctie die het machinevertaalmodel laadt en de vertaling uitvoert, rekening houdend met de parameters die vanaf de frontend worden verzonden. Dit cijfer vat samen wat we tot nu toe samen hebben geïmplementeerd.
Een laatste stap is het uitvoeren van de applicatie door op de knop Uitvoeren bovenaan in het midden van de aambeeldeditor te klikken.
Nadat u de applicatie heeft uitgevoerd, ziet u in de rechterbovenhoek een knop "publiceer deze app" waarmee u een link krijgt die u kunt delen om toegang te krijgen tot de applicatie en uw vertaling te doen!
Conclusie
Door dit artikel te volgen, hebt u een MT-model kunnen implementeren en een webinterface kunnen bouwen om het te gebruiken.
Er valt nog veel te ontdekken over hoe je een model effectief kunt inzetten met behulp van het aambeeld, maar nu heb je de basis om aan je implementatietraject te beginnen en het potentieel van je voorkennis in Python te vergroten om nog veel meer te doen!
Kom naar een van onze gratis workshops
Begin je carrière als datawetenschapper met onze gratis workshops, die zijn gebaseerd op een aanpasbaar curriculum en worden begeleid door experts uit de industrie.
