Wenn Sie im Bereich der Datenwissenschaft arbeiten, stehen Sie in der Regel vor einer neuen Herausforderung, nachdem Sie eine lange Schleife des Trainings, der Feinabstimmung und der Verbesserung abgeschlossen haben. Herzlichen Glückwunsch zur Erstellung eines ML-Modells, das eine gute Leistung aufweist und Ihre Anforderungen erfüllt. Nun stehen Sie vor der Herausforderung, wie Sie dieses gute Stück Technologie an die vorgesehenen Nutzer weitergeben können. Oder wie können Sie Ihr Ergebnis effektiv mit den Beteiligten in Ihrem Unternehmen kommunizieren? Oder sogar, wie können Sie Ihre Modellergebnisse mit Ihren Kollegen teilen, um die Zusammenarbeit zu verbessern?
Der Einsatz von maschinellem Lernen kann manchmal schwierig sein, da wir Technologien und Techniken verwenden, die nicht zu den üblichen Fähigkeiten gehören, die für die Erstellung der Modelle erforderlich sind.
In diesem Artikel werden wir einen Weg entdecken, wie man Modelle für maschinelles Lernen nur mit Python einsetzen kann. Nebenbei werden wir ein maschinelles Übersetzungsmodell und eine Webseite erstellen.
Hier sind also die Schritte, die wir uns ansehen werden:
-
Verwendung von Huggingface maschinellen Übersetzungsmodellen.
-
Entdeckung von Anvil und Erstellung einer Web-UI für unser Modell.
-
Verbinden von Backend und Frontend und Bereitstellen unserer Arbeit für die Welt!
Maschinelles Übersetzungsmodell erstellen
Huggingface ist eine KI-Community, die daran arbeitet, "gutes maschinelles Lernen zu demokratisieren". Unter dieser Initiative finden Sie viele trainierte Modelle zu verschiedenen Aufgaben des maschinellen Lernens: Bildsegmentierung, Text zu Sprache, Texterzeugung... und auch maschinelle Übersetzung!
Maschinelle Übersetzung ist einfach eine Übersetzungsaufgabe zwischen zwei Sprachen, die von einer Software ausgeführt wird, in unserem Fall von einem maschinellen Lernmodell, das mit Transformatoren aufgebaut ist.
Ein Transformator ist eine Deep-Learning-Architektur, die auf Aufmerksamkeit basiert. Bringen wir sie auf Ihrem Rechner zum Laufen!
Wir werden transformers verwenden, eine Python-Bibliothek, um das MT-Modell herunterzuladen und eine Übersetzung durchzuführen.
pip install torch
pip install transformers
Nachdem Sie die benötigten Pakete installiert haben, importieren Sie die folgenden Module:
from transformers import MarianTokenizer, MarianMTModel
from typing import List
Lassen Sie uns ein Modell erstellen, das einen Satz vom Deutschen ins Englische übersetzt. Wir brauchen den Namen des Modells:
src= "de"
trg= "en"
mname= f'Helsinki-NLP/opus-mt-{src}-{trg}'
Nun importieren wir das trainierte Modell und den Tokenizer mit den folgenden Zeilen:
model = MarianMTModel.from_pretrained(mname)
tok = MarianTokenizer.from_pretrained(mname)
Der Download ist ca. 300mb groß, danach können Sie das Modell wie folgt in einem lokalen Verzeichnis speichern:
model.save_pretrained("./models/de_en/")
tok.save_pretrained("./models/de_en/tok")
Nehmen wir das Modell:
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])
Jetzt sollten Sie die englische Übersetzung des Satzes in words[0] gespeichert haben.
Entdecken Sie Anvil und bauen Sie eine Web-UI
Anvil ist ein Framework und ein Stapel von Lösungen, die es Ihnen ermöglichen, Webanwendungen nur mit Python-Code zu erstellen. Es verfügt über einen Drag-and-Drop-Editor zur Erstellung von Web-UIs und ermöglicht es Ihnen, den Code Ihres lokalen Rechners mit der von Ihnen erstellten UI zu verbinden und Ihre Anwendung zu hosten, indem es Ihnen einen Link gibt, den Sie teilen können.
Beginnen wir also mit der Erstellung einer Anwendung von hier. Wählen Sie leere Anwendung und dann Material Design.
Sie sollten etwas wie das hier sehen:
Jetzt zähle ich darauf, dass Sie den Editor benutzen und etwas Ähnliches wie das Folgende erstellen:
In dieser einfachen Benutzeroberfläche haben wir zwei DropDowns für die Auswahl der Ausgangs- und Zielsprache. Außerdem gibt es eine Textbox zur Eingabe des Ausgangstextes und eine RichText-Komponente zur Anzeige des übersetzten Textes. Sie können auch eine Schaltfläche sehen, um die Übersetzung zu starten.
Geben Sie den Komponenten die gleichen IDs, um sie mit den Codeausschnitten zu synchronisieren, die Sie weiter unten sehen werden. Unten finden Sie ein Beispiel dafür, wo Sie die ID einer Komponente festlegen können:
Die von uns verwendeten IDs sind:
|
Component |
ID |
|---|---|
| Source language DropDown | source_lang |
| Destination language DropDown | dest_lang |
| Source language TextBox | source_text |
| Translated text RichText | translated_text |
Onclick-Funktion
Wir haben eine Schaltfläche hinzugefügt, die zum Starten der Übersetzung verwendet wird. Klicken Sie in Ihrem Editor auf die Schaltfläche und scrollen Sie dann in der Eigenschaftsleiste nach unten. Unten sehen Sie einen Ereignisbereich. Geben Sie im Textfeld neben "click" "translate" ein und klicken Sie dann auf den Pfeil rechts neben dem Textfeld.
Dadurch gelangen Sie in die Codeansicht, in der Sie einen automatisch generierten Python-Code sehen.
Sie werden feststellen, dass Amboss automatisch eine Funktion namens translate hinzugefügt hat. Sie wird jedes Mal aufgerufen, wenn die Schaltfläche in unserer Benutzeroberfläche angeklickt wird.
So sollte die Funktion aussehen:
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
Diese Funktion erfüllt 3 Hauptaufgaben:
-
Abrufen von Informationen aus der Benutzeroberfläche
-
Senden der Informationen an unser Backend mit Hilfe der Serverfunktion "Übersetzung" (wir werden sie im nächsten Abschnitt erklären)
-
Senden Sie den übersetzten Text an die UI.
Server-Funktion
Konzentrieren wir uns auf diese Code-Zeile:
translated_text=anvil.server.call("translation",text,src_lang,dest_lang)
Wir verwenden anvil.server.call, um eine Serverfunktion namens translation aufzurufen, die wir in unserem Backend-Code auf dem lokalen Rechner definieren werden.
Diese Funktion dient als Verbindung zwischen der Web-UI und dem Backend-Code, der auf unserem maschinellen Übersetzungsmodell laufen wird.
Wie Sie bemerkt haben, senden wir auch die Parameter dieser Funktion in der Funktion anvil.server.call.
Einsatz unseres MT-Modells
Lassen Sie uns zuerst anvil installieren
pip install anvil-uplink
Jetzt haben wir unser Webinterface im anvil-Editor erstellt und verfügen über grundlegende Codeblöcke, um unser maschinelles Übersetzungsmodell auszuführen und eine Übersetzung zu erstellen.
Der nächste Schritt ist die Definition der Serverfunktion, die wir im vorherigen Abschnitt besprochen haben.
Hier ist der Code der Funktion:
@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]
Die Funktion nimmt die drei vom Frontend gesendeten Parameter entgegen, konvertiert die Ausgangs- und Zielsprachen in die jeweiligen Sprachcodes, lädt die Modelle, berechnet die Übersetzung und gibt das Ergebnis zurück.
Der Weg, diese Funktion in Anvil als Serverfunktion zu deklarieren, ist durch die Verwendung des Dekorators
@anvil.server.callable`.
Wir müssen noch einen letzten Schritt tun, um den Backend-Code, den wir in einem Jupyter-Notebook ausführen können, mit unserer Anvil-Anwendung zu verbinden.
Gehen Sie zum Anvil Online-Editor, klicken Sie auf das Zahnradsymbol und dann auf "Uplink...".
Siehe den folgenden Bildschirm
Es erscheint ein Popup-Fenster. Klicken Sie auf "Enable server uplink for this app", um den Verbindungscode zu erhalten, den Sie kopieren.
Fügen Sie den Code in die folgende Codezeile ein:
anvil.server.connect("code here")
Diese Zeile startet einen Server, der Ihr lokales Code-Skript oder Jupyter-Notizbuch mit der Amboss-Anwendung verbindet, wobei die Funktion translation als Server-Funktion registriert wird.
Letzter Schritt
Bis zu diesem Punkt läuft Ihr Backend-Server mit einer Serverfunktion, die das maschinelle Übersetzungsmodell lädt und die Übersetzung unter Berücksichtigung der vom Frontend gesendeten Parameter vornimmt. Diese Abbildung fasst zusammen, was wir bis jetzt gemeinsam implementiert haben.
Der letzte Schritt besteht darin, die Anwendung zu starten, indem Sie auf die Schaltfläche "Ausführen" in der oberen Mitte des Amboss-Editors klicken.
Nach dem Ausführen der Anwendung sehen Sie in der oberen rechten Ecke die Schaltfläche "Diese Anwendung veröffentlichen", die Ihnen einen Link gibt, den Sie freigeben können, um auf die Anwendung zuzugreifen und Ihre Übersetzung durchzuführen!
Fazit
Mit Hilfe dieses Artikels konnten Sie ein MÜ-Modell einsetzen und eine Weboberfläche erstellen, um es zu verwenden.
Es gibt noch viel zu entdecken, wie man ein Modell mit Amboss effektiv einsetzt, aber jetzt haben Sie die Grundlagen, um Ihre Einsatzreise zu beginnen und das Potenzial Ihrer Vorkenntnisse in Python zu erweitern, um viel mehr zu tun!
Besuchen Sie einen unserer kostenlosen Workshops
Starten Sie Ihre Karriere als Datenwissenschaftler mit unseren kostenlosen Workshops, die auf einem anpassbaren Lehrplan basieren und von Branchenexperten geleitet werden.
