Bild vom Autor
Stellen Sie sich vor, Sie nutzen ein Hugging Face-Modell, um die Stimmung von Bewertungen zu ermitteln. Traditionell besteht der erste Schritt darin, ein solches Modell zu entwickeln und sicherzustellen, dass es ordnungsgemäß funktioniert.
Die heute vortrainierten Modelle ermöglichen es uns jedoch, solche Giant Language Fashions (LLMs) mit minimalem Aufwand bereit zu haben.
Sobald dieses Modell einsatzbereit ist, besteht unser Hauptziel darin, Kollegen innerhalb eines Unternehmens die Verwendung dieses Modells zu ermöglichen, ohne es herunterladen oder von Grund auf neu implementieren zu müssen.
Dazu würden wir eine Endpunkt-API erstellen, die es Benutzern ermöglicht, das Modell unabhängig aufzurufen und zu verwenden. Dies bezeichnen wir als Finish-to-Finish-Projekt, das von Anfang bis Ende aufgebaut ist.
Heute werden wir ein einfaches Modell mit Hugging Face, FastAPI und Docker bereitstellen und zeigen, wie dieses Ziel effizient erreicht werden kann.
Schritt 1: Auswahl unseres HuggingFace-Modells
Als erstes müssen wir ein Hugging Face-Modell auswählen, das unseren Anforderungen entspricht. Dazu können wir Hugging Face ganz einfach mit dem folgenden Befehl in unserer Umgebung installieren:
pip set up transformers
# bear in mind to work with transformers we want both tensorflow or pytorch put in as effectively
pip set up torch
pip set up tensorflow
Jetzt müssen wir den Pipeline-Befehl der Transformers-Bibliothek importieren.
from transformers import pipeline
Anschließend können wir mit dem Pipeline-Befehl ganz einfach ein Modell generieren, das die Stimmung eines bestimmten Textes definiert. Dies können wir auf zwei verschiedene Arten tun: Indem wir die Aufgabe „Sentimentanalyse“ definieren oder indem wir das Modell definieren, wie im folgenden Codeausschnitt zu sehen ist.
# Defining straight the duty we need to implement.
pipe = pipeline(job="sentiment-analysis")
# Defining the mannequin we select.
pipe = pipeline(mannequin="model-to-be-used")
Es ist wichtig zu beachten, dass die Verwendung des aufgabenbasierten Ansatzes nicht empfohlen wird, da er unsere Kontrolle über das verwendete spezifische Modell einschränkt.
In meinem Fall habe ich mich für „distilbert-base-uncased-fine tuned-sst-2-english“ entschieden, aber Sie können den Hugging Face Hub durchsuchen und jedes Modell auswählen, das Ihren Anforderungen entspricht. Eine einfache Anleitung zu Hugging Face finden Sie im folgender Artikel.
pipe = pipeline(mannequin="distilbert/distilbert-base-uncased-finetuned-sst-2-english")
Nachdem wir nun unser Rohrmodell definiert haben, müssen wir nur noch eine einfache Eingabeaufforderung senden, um unser Ergebnis zurückzubekommen. Zum Beispiel für den folgenden Befehl:
print(pipe("This tutorial is nice!"))
Wir würden erhalten ({‚label‘: ‚POSITIVE‘, ‚rating‘: 0.9998689889907837})
Nehmen wir an, wir möchten, dass unsere Benutzer einen Satz in natürlicher Sprache zu dieser Klassifizierung erhalten. Wir können einen einfachen Python-Code implementieren, der dies ebenfalls tut:
def generate_response(immediate:str):
response = pipe("This can be a nice tutorial!")
label = response(0)("label")
rating = response(0)("rating")
return f"The '{immediate}' enter is {label} with a rating of {rating}"
print(generate_response("This tutorial is nice!"))
Und wenn wir das gleiche Experiment wiederholen, erhalten wir:
Die Eingabe „Dieses Tutorial ist großartig!“ ist POSITIV mit einem Rating von 0,9997909665107727
Wir haben jetzt additionally ein funktionierendes Modell und können mit der Definition unserer API fortfahren.
Schritt 2: Schreiben Sie den API-Endpunkt für das Modell mit FastAPI
Um unsere API zu definieren, verwenden wir FastAPI. Es ist ein Python-Framework zum Erstellen leistungsstarker Internet-APIs. Installieren Sie zunächst die FastAPI-Bibliothek mit dem Befehl pip und importieren Sie sie in unsere Umgebung. Darüber hinaus verwenden wir die pydantic-Bibliothek, um sicherzustellen, dass unsere Eingaben vom gewünschten Typ sind.
Der folgende Code generiert eine funktionierende API, die unsere Kollegen direkt verwenden können.
from fastapi import FastAPI
from pydantic import BaseModel
from transformers import pipeline
# You possibly can examine every other mannequin within the Hugging Face Hub
pipe = pipeline(mannequin="distilbert/distilbert-base-uncased-finetuned-sst-2-english")
# We outline the app
app = FastAPI()
# We outline that we count on our enter to be a string
class RequestModel(BaseModel):
enter: str
# Now we outline that we settle for submit requests
@app.submit("/sentiment")
def get_response(request: RequestModel):
immediate = request.enter
response = pipe(immediate)
label = response(0)("label")
rating = response(0)("rating")
return f"The '{immediate}' enter is {label} with a rating of {rating}"
Folgendes passiert Schritt für Schritt im Code:
- Importieren der erforderlichen Bibliotheken: Der Code beginnt mit dem Importieren von FastAPI und Pydantic, wodurch sichergestellt wird, dass die von uns empfangenen und gesendeten Daten richtig strukturiert sind.
- Laden des Modells: Anschließend laden wir ein vortrainiertes Sentimentanalysemodell, wie wir es bereits im ersten Schritt getan haben.
- Einrichten der FastAPI-Anwendung:
app = FastAPI()initialisiert unsere FastAPI-App und macht sie bereit, Anfragen zu verarbeiten. - Definieren des Anforderungsmodells: Mithilfe von Pydantic wird eine RequestModel-Klasse definiert. Diese Klasse gibt an, dass wir eine Eingabezeichenfolge erwarten, und stellt sicher, dass unsere API nur Daten im richtigen Format akzeptiert.
- Erstellen des Endpunkts: Der
@app.submit("/sentiment")Decorator teilt FastAPI mit, dass diese Funktion ausgelöst werden soll, wenn eine POST-Anfrage an den /sentiment-Endpunkt gestellt wird. Die get_response-Funktion verwendet als Eingabe ein RequestModel-Objekt, das den zu analysierenden Textual content enthält. - Verarbeitung der Anfrage: Innerhalb der
get_responseFunktion wird der Textual content aus der Anfrage extrahiert und an das Modell übergeben(pipe(immediate)). Das Modell gibt eine Antwort mit der Stimmungsbezeichnung (wie „POSITIV“ oder „NEGATIV“) und einer Punktzahl zurück, die die Zuverlässigkeit der Vorhersage angibt. - Zurückgeben der Antwort: Schließlich gibt die Funktion eine formatierte Zeichenfolge zurück, die den Eingabetext, die Stimmungsbezeichnung und den Vertrauenswert enthält und dem Benutzer ein klares und prägnantes Ergebnis liefert.
Wenn wir den Code ausführen, ist die API auf unserem lokalen Host verfügbar, wie im Bild unten zu sehen ist.
Screenshot des lokalen Host-Endpunkts mit FastAPI
Um es einfach auszudrücken: Dieser Code richtet einen einfachen Webdienst ein, an den Sie einen Textual content senden können. Dieser antwortet mit einer Analyse der Stimmung dieses Textes und nutzt dabei die leistungsstarken Funktionen des Hugging Face-Modells über FastAPI.
Als Nächstes sollten wir unsere Anwendung in einen Container packen, damit sie überall ausgeführt werden kann, nicht nur auf unserem lokalen Pc. Dadurch wird eine größere Portabilität und eine einfachere Bereitstellung gewährleistet.
Schritt 3: Verwenden Sie Docker, um unser Modell auszuführen
Bei der Containerisierung wird Ihre Anwendung in einem Container platziert. Ein Docker-Container führt eine Instanz eines Docker-Photographs aus, das sein eigenes Betriebssystem und alle notwendigen Abhängigkeiten für die Anwendung enthält.
Sie können beispielsweise Python und alle erforderlichen Pakete im Container installieren, sodass es überall ausgeführt werden kann, ohne dass solche Bibliotheken installiert werden müssen.
Um unsere Sentimentanalyse-App in einem Docker-Container auszuführen, müssen wir zunächst ein Docker-Picture erstellen. Dieser Prozess umfasst das Schreiben einer Docker-Datei, die als Rezept dient und angibt, was das Docker-Picture enthalten soll.
Wenn Docker nicht auf Ihrem System installiert ist, können Sie es hier herunterladen: Dockers Web site. Hier ist die Docker-Datei, die wir für dieses Projekt verwenden werden. Sie heißt im Repository „Dockerfile“.
# Use an official Python runtime as a guardian picture
FROM python:3.10-slim
# Set the working listing within the container
WORKDIR /sentiment
# Copy the necessities.txt file into the basis
COPY necessities.txt .
# Copy the present listing contents into the container at /app as effectively
COPY ./app ./app
# Set up any wanted packages laid out in necessities.txt
RUN pip set up -r necessities.txt
# Make port 8000 out there to the world exterior this container
EXPOSE 8000
# Run predominant.py when the container launches, as it's contained below the app folder, we outline app.predominant
CMD ("uvicorn", "app.predominant:app", "--host", "0.0.0.0", "--port", "8000")
Dann müssen wir nur den folgenden Befehl im Terminal ausführen, um das Docker-Picture zu erstellen.
docker construct -t sentiment-app .
Zur Ausführung haben wir dann zwei Möglichkeiten:
- Verwenden unseres Terminals mit Befehlen.
docker run -p 8000:8000 --name name_of_cointainer sentiment-hf - Verwenden des Docker-Hubs. Wir können einfach zum Docker-Hub gehen und auf die Schaltfläche „Ausführen“ des Photographs klicken.
Screenshot des Dockerhubs
Und das ist alles! Jetzt haben wir ein funktionierendes Sentiment-Klassifizierungsmodell, das überall funktioniert und über eine API ausgeführt werden kann.
In Kürze
- Modellauswahl und -einrichtung: Wählen und konfigurieren Sie ein vortrainiertes Hugging Face-Modell für die Stimmungsanalyse und stellen Sie sicher, dass es Ihren Anforderungen entspricht.
- API-Entwicklung mit FastAPI: Erstellen Sie mit FastAPI einen API-Endpunkt, der eine einfache Interaktion mit dem Sentimentanalysemodell ermöglicht.
- Containerisierung mit Docker: Containerisieren Sie die Anwendung mit Docker, um Portabilität und nahtlose Bereitstellung in verschiedenen Umgebungen sicherzustellen.
Sie können meinen gesamten Code überprüfen im folgenden GitHub-Repo.
Josep Ferrer ist ein Analytikingenieur aus Barcelona. Er hat einen Abschluss in Physikingenieurwesen und arbeitet derzeit im Bereich der Datenwissenschaft, angewandt auf menschliche Mobilität. Er ist ein Teilzeit-Content material-Ersteller mit Schwerpunkt auf Datenwissenschaft und Technologie. Josep schreibt über alles, was mit KI zu tun hat, und befasst sich mit der Anwendung der anhaltenden Explosion in diesem Bereich.