ML -Modell, das mit Fastapi und Redis für schnellere Vorhersagen dient

Haben Sie jemals zu lange darauf gewartet, dass ein Modell Vorhersagen zurückgibt? Wir waren alle dort. Maschinelles Lernen, insbesondere die großen, komplexen, können in Echtzeit schmerzhaft langsam dienen. Benutzer hingegen erwarten sofortiges Suggestions. Hier wird die Latenz zu einem echten Drawback. Technisch gesehen ist eines der größten Probleme eine redundante Berechnung, wenn dieselbe Eingabe wiederholt den gleichen langsamen Prozess auslöst. In diesem Weblog zeige ich Ihnen, wie Sie das beheben können. Wir werden einen Fastapi-basierten ML-Dienst erstellen und Redis Caching integrieren, um wiederholte Vorhersagen in Millisekunden zurückzugeben.

Was ist Fastapi?

Fastapi ist ein modernes, leistungsstarkes Net-Rahmen für den Aufbau von APIs mit Python. Es verwendet PythonTyptyp Hinweise für die Datenvalidierung und die automatische Erzeugung interaktiver API -Dokumentation unter Verwendung der Swagger UI und des Redoc. Fastapi ist auf Starlette und Pydantantantic gebaut und unterstützt die asynchrone Programmierung und macht es in der Leistung mit Node.js und Go vergleichbar. Das Design erleichtert eine schnelle Entwicklung robuster, produktionsbereiteter APIs und macht es zu einer hervorragenden Wahl für die Bereitstellung maschineller Lernmodelle als skalierbare erholsame Dienste.

Was ist Redis?

Redis (Distant Dictionary Server) ist eine Open-Supply-Datenstruktur für In-Reminiscence-Daten, die als Datenbank, Cache und Message Dealer fungiert. Durch das Speichern von Daten im Speicher bietet Redis eine extrem niedrige Latenz für Lese- und Schreibvorgänge, sodass es best für das Zwischenspeichern von häufigen oder rechenintensiven Aufgaben wie maschinellem Lernmodellvorhersagen. Es unterstützt verschiedene Datenstrukturen, einschließlich Zeichenfolgen, Hear, Units und Hashes, und bietet Funktionen wie wichtiger Ablauf (TTL) für ein effizientes Cache -Administration.

Warum Fastapi und Redis kombinieren?

Integrieren Fastapi Mit Redis erzeugt ein System, das sowohl reaktionsschnell als auch effizient ist. Fastapi dient als schnelle und zuverlässige Schnittstelle für den Umgang mit API -Anforderungen, während Redis als Caching -Schicht fungiert, um die Ergebnisse früherer Berechnungen zu speichern. Wenn dieselbe Eingabe erneut empfangen wird, kann das Ergebnis sofort von Redis abgerufen werden, wobei die Notwendigkeit einer Neuberechnung umgangen wird. Dieser Ansatz reduziert die Latenz, senkt die Rechenlast und verbessert die Skalierbarkeit Ihrer Anwendung. In verteilten Umgebungen dient Redis als zentraler Cache, der von mehreren Fastapi-Instanzen zugänglich ist, was es zu einer hervorragenden Passform für maschinelles Lernen für maschinelle Lernen für Produktionsqualität macht.

Lassen Sie uns nun die Implementierung einer Fastapi -Anwendung durchlaufen, die Vorhersagen für maschinelles Lernen mit Redis -Caching bedient. Dieses Setup stellt sicher, dass wiederholte Anforderungen mit demselben Eingang schnell aus dem Cache bedient werden, wodurch die Rechenzeit verkürzt und die Reaktionszeiten verbessert werden. Die Schritte werden unten erwähnt:

1. Laden eines vorgebildeten Modells
2. Erstellen eines Fastapi -Endpunkts für Vorhersagen
3. Einrichten von Redis Caching
4. Messung der Leistungssteigerungen

Lassen Sie uns diese Schritte nun ausführlicher sehen.

Schritt 1: Laden eines vorgebildeten Modells

Nehmen Sie zunächst an, dass Sie bereits über ein geschultes maschinelles Lernmodell verfügen, das bereit ist, bereitzustellen. In der Praxis werden die meisten Modelle offline ausgebildet (wie ein Scikit-Study-Modell, a Tensorflow/Pytorch -Modell usw.), auf Scheibe gespeichert und dann in eine Servier -App geladen. Für unser Beispiel werden wir einen einfachen Scikit-Study-Klassifizierer erstellen, der auf dem berühmten Iris-Blumen-Datensatz trainiert und mit Joblib gespeichert wird. Wenn Sie bereits eine gespeicherte Modelldatei haben, können Sie das Trainingsteil überspringen und einfach laden. So trainieren Sie ein Modell und laden Sie es dann zum Servieren:

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
import joblib

# Load instance dataset and prepare a easy mannequin (Iris classification)
X, y = load_iris(return_X_y=True)

# Practice the mannequin
mannequin = RandomForestClassifier().match(X, y)

# Save the educated mannequin to disk
joblib.dump(mannequin, "mannequin.joblib")

# Load the pre-trained mannequin from disk (utilizing the saved file)
mannequin = joblib.load("mannequin.joblib")

print("Mannequin loaded and able to serve predictions.")

Im obigen Code haben wir die integrierten Scikit-Study verwendet Iris -Datensatztrainierte einen zufälligen Waldklassifizierer darauf und speichert dieses Modell dann in einer Datei mit dem Namen mannequin.joblib. Danach haben wir es mit JoBlib.load zurückgeladen. Die Joblib-Bibliothek ist weit verbreitet, wenn es darum geht, Scikit-Study-Modelle zu sparen, vor allem, weil es intestine darin ist, Numpy-Arrays innerhalb von Modellen zu bewältigen. Nach diesem Schritt haben wir ein Modellobjekt bereit, um neue Daten vorherzusagen. Nur ein Heads-up, können Sie hier jedes vorgeborene Modell verwenden. Die Artwork und Weise, wie Sie es mit Fastapi servieren, und auch zwischengespeicherte Ergebnisse wären mehr oder weniger gleich. Das einzige ist, dass das Modell eine Vorhersagemethode haben sollte, die einige Eingaben aufnimmt und das Ergebnis erzeugt. Stellen Sie außerdem sicher, dass die Vorhersage des Modells jedes Mal gleich bleibt, wenn Sie ihm den gleichen Eingang geben (damit es deterministisch ist). Wenn dies nicht der Fall ist, wäre das Caching für nicht deterministische Modelle problematisch, da es falsche Ergebnisse zurückgeben würde.

Schritt 2: Erstellen eines Fastapi -Vorhersageendpunkts

Jetzt, da wir ein Modell haben, verwenden wir es über API. Wir werden Fastapi verwenden, um einen Webserver zu erstellen, der sich um Vorhersageanfragen befasst. Fastapi erleichtert es einfach, einen Endpunkt- und Kartonanforderungsparameter für Python -Funktionsargumente zu definieren. In unserem Beispiel nehmen wir an, dass das Modell vier Funktionen akzeptiert. Und erzeugt einen Get -Endpunkt /predict Dies akzeptiert diese Funktionen als Abfrageparameter und gibt die Vorhersage des Modells zurück.

from fastapi import FastAPI
import joblib

app = FastAPI()

# Load the educated mannequin at startup (to keep away from re-loading on each request)
mannequin = joblib.load("mannequin.joblib")  # Guarantee this file exists from the coaching step

@app.get("/predict")
def predict(sepal_length: float, sepal_width: float, petal_length: float, petal_width: float):
    """ Predict the Iris flower species from enter measurements. """
    
    # Put together the options for the mannequin as a 2D record (mannequin expects form (n_samples, n_features))
    options = ((sepal_length, sepal_width, petal_length, petal_width))
    
    # Get the prediction (within the iris dataset, prediction is an integer class label 0,1,2 representing the species)
    prediction = mannequin.predict(options)(0)  # Get the primary (solely) prediction
    
    return {"prediction": str(prediction)}

Im obigen Code haben wir eine Fastapi -App erstellt und beim Ausführen der Datei den API -Server gestartet. Fastapi ist für Python tremendous schnell, sodass es problemlos viele Anfragen erledigen kann. Dann laden wir das Modell zu Beginn, weil es auf jeder Anfrage immer wieder zu tun ist, sodass wir es im Speicher halten, was zur Verwendung bereit ist. Wir haben a geschaffen /predict Endpunkt mit @app.getGet, macht das Testen einfach, da wir Dinge in der URL nur weitergeben können, aber in realen Projekten möchten Sie wahrscheinlich einen Beitrag verwenden, insbesondere wenn Sie große oder komplexe Eingaben wie Bilder oder JSON senden. Diese Funktion erfordert 4 Eingänge: sepal_lengthAnwesend sepal_widthAnwesend petal_lengthUnd petal_widthund Fastapi Auto liest sie aus der URL. In der Funktion setzen wir alle Eingänge in eine 2D-Liste (da Scikit-Study nur ein 2D-Array akzeptiert). Dann rufen wir an mannequin.predict()und es gibt uns eine Liste. Dann geben wir es als JSON zurück wie { “prediction”: “...”}.

Daher funktioniert es jetzt, Sie können es verwenden uvicorn most important:app --reloadSchlag /predictEndpunkt und Ergebnisse erzielen. Selbst wenn Sie denselben Eingang erneut senden, wird das Modell erneut ausgeführt, was nicht intestine ist. Im nächsten Schritt wird Redis hinzugefügt, um die vorherigen Ergebnisse zu speichern und sie wieder zu überspringen.

Schritt 3: Hinzufügen von Redis -Caching für Vorhersagen

Um die Modellausgabe zu leiten, werden wir Redis verwenden. Stellen Sie zunächst sicher, dass der Redis -Server ausgeführt wird. Sie können es lokal installieren oder einfach einen Docker -Container ausführen. Es läuft normalerweise am Port 6379 Standardmäßig. Wir werden die Python Redis -Bibliothek verwenden, um mit dem Server zu sprechen.

Die Idee ist additionally einfach: Wenn eine Anfrage eingeht, erstellen Sie einen eindeutigen Schlüssel, der die Eingabe darstellt. Überprüfen Sie dann, ob der Schlüssel in Redis vorhanden ist. Wenn dieser Schlüssel bereits vorhanden ist, was bedeutet, dass wir dies bereits zuvor zwischengespeichert haben, geben wir einfach das gespeicherte Ergebnis zurück und müssen das Modell nicht erneut aufrufen. Wenn nicht, tun wir das mannequin.predictHolen Sie sich die Ausgabe, speichern Sie sie in Redis und senden Sie die Vorhersage zurück.

Lassen Sie uns nun die Fastapi -App aktualisieren, um diese Cache -Logik hinzuzufügen.

!pip set up redis
import redis  # New import to make use of Redis

# Connect with an area Redis server (alter host/port if wanted)
cache = redis.Redis(host="localhost", port=6379, db=0)

@app.get("/predict")
def predict(sepal_length: float, sepal_width: float, petal_length: float, petal_width: float):
    """
    Predict the species, with caching to hurry up repeated predictions.
    """
    # 1. Create a novel cache key from enter parameters
    cache_key = f"{sepal_length}:{sepal_width}:{petal_length}:{petal_width}"
    
    # 2. Examine if the result's already cached in Redis
    cached_val = cache.get(cache_key)
    
    if cached_val:
        # If cache hit, decode the bytes to a string and return the cached prediction
        return {"prediction": cached_val.decode("utf-8")}
    
    # 3. If not cached, compute the prediction utilizing the mannequin
    options = ((sepal_length, sepal_width, petal_length, petal_width))
    prediction = mannequin.predict(options)(0)
    
    # 4. Retailer the lead to Redis for subsequent time (as a string)
    cache.set(cache_key, str(prediction))
    
    # 5. Return the freshly computed prediction
    return {"prediction": str(prediction)}

Im obigen Code haben wir jetzt Redis hinzugefügt. Zuerst haben wir einen Kunden verwendet redis.Redis(). Es stellt eine Verbindung zum Redis -Server her. Standardmäßig mit DB = 0 verwenden. Dann haben wir einen Cache -Style erstellt, indem wir die Eingabewerte verbinden. Hier funktioniert es, weil die Eingaben einfache Zahlen sind, aber für komplexe ist es besser, einen Hash oder eine JSON -String zu verwenden. Der Schlüssel muss für jeden Eingang eindeutig sein. Wir haben benutzt cache.get(cache_key). Wenn es den gleichen Schlüssel findet, wird dies zurückgegeben, was es schnell macht, und damit ist es nicht erforderlich, das Modell erneut auszusetzen. Wenn es jedoch nicht im Cache zu finden ist, müssen wir das Modell ausführen und die Vorhersage erhalten. Schließlich speichern Sie das in Redis mithilfe cache.set(). Wenn der gleiche Eingang das nächste Mal kommt, ist es bereits da und das Caching wäre schnell.

Schritt 4: Testen und Messen der Leistungssteigerungen

Nachdem unsere Fastapi -App ausgeführt wird und mit Redis verbunden ist, ist es an der Zeit, zu testen, wie das Caching die Reaktionszeit verbessert. Hier werde ich demonstrieren, wie man Pythons Anforderungsbibliothek verwendet, um die API zweimal mit derselben Eingabe anzurufen und die Zeit für jeden Anruf zu messen. Stellen Sie außerdem sicher, dass Sie Ihren Fastapi starten, bevor Sie den Testcode ausführen:

import requests, time
# Pattern enter to foretell (similar enter might be used twice to check caching)
params = {
"sepal_length": 5.1,
"sepal_width": 3.5,
"petal_length": 1.4,
"petal_width": 0.2
}

# First request (anticipated to be a cache miss, will run the mannequin)
begin = time.time()
response1 = requests.get("http://localhost:8000/predict", params=params)
elapsed1 = time.time() - begin
print("First response:", response1.json(), f"(Time: {elapsed1:.4f} seconds)")

# Second request (similar params, anticipated cache hit, no mannequin computation)
begin = time.time()
response2 = requests.get("http://localhost:8000/predict", params=params)
elapsed2 = time.time() - begin
print("Second response:", response2.json(), f"(Time: {elapsed2:.6f}seconds)")

Wenn Sie dies ausführen, sollten Sie sehen, dass die erste Anfrage ein Ergebnis zurückgibt. Dann gibt die zweite Anfrage das gleiche Ergebnis zurück, aber merklich schneller. Zum Beispiel finden Sie möglicherweise, dass der erste Anruf in der Reihenfolge von zehn Millisekunden (abhängig von der Modellkomplexität) angenommen wird, während der zweite Anruf möglicherweise einige Millisekunden oder weniger beträgt. In unserer einfachen Demo mit einem leichten Modell könnte der Unterschied klein sein (da das Modell selbst schnell ist), aber der Effekt für schwerere Modelle ist drastisch.

Vergleich

Um dies ins rechte Licht zu rücken, sollten wir uns überlegen, was wir erreicht haben:

• Ohne zwischengespeichert: Jede Anfrage, sogar identische, würde das Modell treffen. Wenn das Modell 100 ms professional Vorhersage dauert, würden 10 identische Anfragen gemeinsam noch ~ 1000 ms dauern.
• Mit Caching: Die erste Anfrage dauert den vollständigen Treffer (100 ms), aber die nächsten 9 identischen Anfragen können beispielsweise jeweils 1–2 ms (nur eine Redis -Suche und Rückgabedaten) erfolgen. Diese 10 Anfragen können additionally ~ 120 ms anstelle von 1000 ms insgesamt ~ 8x in diesem Szenario in Höhe von ~ 8x.

In realen Experimenten kann das Caching zu Verbesserungen der Anordnung zur Verfügung führen. Zum Beispiel im E-Commerce Die Verwendung von Redis bedeutete die Rückgabe von Empfehlungen in Mikrosekunden für Wiederholungsanfragen im Vergleich zu sie mit der vollständigen Modelldienste Pipeline neu berechnen müssen. Der Leistungsgewinn hängt davon ab, wie teuer Ihre Modellinferenz ist. Je komplexer das Modell ist, desto mehr profitieren Sie von der Zwischenspeicherung bei wiederholten Anrufen. Es hängt auch von Anforderungsmustern ab: Wenn jede Anforderung eindeutig ist, hilft der Cache nicht (keine Wiederholungen, die aus dem Speicher dienen können). Viele Anwendungen sehen jedoch überlappende Anforderungen (z. B. beliebte Suchanfragen, empfohlene Elemente usw.).

Sie können auch Ihren Redis -Cache direkt überprüfen, um zu überprüfen, ob die Schlüsselspeicher speichert.

Abschluss

In diesem Weblog haben wir gezeigt, wie Fastapi und Redis in Zusammenarbeit mit der Beschleunigung des ML -Modells für das ML -Modell arbeiten können. Fastapi bietet eine schnelle und einfach zu bauende API-Schicht für die Servicvorhersagen, und Redis fügt eine Caching-Schicht hinzu, die die Latenz- und CPU-Final für wiederholte Berechnungen erheblich reduziert. Durch die Vermeidung von wiederholten Modellaufrufen haben wir die Reaktionsfähigkeit verbessert und es auch ermöglicht, dass das System weitere Anforderungen mit denselben Ressourcen bearbeiten kann.

Hallo, ich bin Janvi, ein leidenschaftlicher Information -Science -Fanatic, der derzeit bei Analytics Vidhya arbeitet. Meine Reise in die Daten der Daten begann mit einer tiefen Neugier darüber, wie wir aus komplexen Datensätzen sinnvolle Erkenntnisse herausholen können.