Bild von Editor | Chatgpt/Schrift>

Da Großsprachmodelle (LLMs) für Anwendungen wie Chatbots, Codierungsassistenten und Inhaltsgenerierung immer zentraler werden, wächst die Herausforderung, sie bereitzustellen. Herkömmliche Inferenzsysteme haben zu kämpfen mit Gedächtnisgrenzen, langen Eingabebedingungen und Latenzproblemen. Hier vllm kommt herein.

In diesem Artikel gehen wir durch, was Vllm ist, warum es wichtig ist und wie Sie damit anfangen können.

# Was ist vllm?

vllm ist eine Open-Supply-LLM-Serviermotor, die entwickelt wurde, um den Inferenzprozess für große Modelle wie GPT, Lama, Mistral und andere zu optimieren. Es ist so konzipiert:

• Maximieren Sie die GPU -Nutzung
• Minimieren Sie den Speicheraufwand
• Unterstützen Sie hohen Durchsatz und niedrige Latenz
• Integrieren in Umarmtes Gesicht Modelle

Im Kern überlegt Vllm, wie das Speicher während der Inferenz verwaltet wird, insbesondere für Aufgaben, die ein sofortiges Streaming, einen langen Kontext und die Mehrfachbenutzer-Parallelität erfordern.

# Warum VLLM verwenden?

Es gibt mehrere Gründe, um die Verwendung von VLLM in Betracht zu ziehen, insbesondere für Groups, die große Sprachmodellanwendungen skalieren möchten, ohne die Leistung zu beeinträchtigen oder zusätzliche Kosten zu entstehen.

// 1. hoher Durchsatz und geringe Latenz

VLLM ist so konzipiert, dass er einen viel höheren Durchsatz liefert als herkömmliche Serviersysteme. Durch die Optimierung des Speicherverbrauchs über den PageDattention -Mechanismus kann VLLM viele Benutzeranfragen gleichzeitig bearbeiten und gleichzeitig die schnellen Reaktionszeiten beibehalten. Dies ist für interaktive Instruments wie Chat-Assistenten, Codierung von Copiloten und Echtzeit-Inhaltsgenerierung von wesentlicher Bedeutung.

// 2. Unterstützung für lange Sequenzen

Traditionelle Inferenzmotoren haben Probleme mit langen Eingaben. Sie können langsam werden oder sogar aufhören zu arbeiten. VLLM ist so konzipiert, dass längere Sequenzen effektiver behandelt werden. Es hält auch mit großen Textmengen eine stetige Leistung. Dies ist nützlich für Aufgaben wie das Zusammenfassen von Dokumenten oder das Durchführen von langwierigen Gesprächen.

// 3. Einfache Integration und Kompatibilität

VLLM unterstützt häufig verwendete Modellformate wie z. Transformatoren und APIs kompatibel mit Openai. Dies erleichtert die Integration in Ihre vorhandene Infrastruktur mit minimalen Anpassungen Ihres aktuellen Setups.

// 4. Speicherauslastung

Viele Systeme leiden unter Fragmentierung und nicht genutzte GPU -Kapazität. VLLM löst dies durch die Verwendung eines virtuellen Speichersystems, das eine intelligentere Speicherzuweisung ermöglicht. Dies führt zu einer verbesserten GPU -Auslastung und einer zuverlässigeren Servicebereitstellung.

# Kerninnovation: PAGEDATTENTENTENTENTEN

Die Kerninnovation von VLLM ist eine Technik namens genannt PAGEDATTENTENTENTEN.

In traditionellen Aufmerksamkeitsmechanismen speichert das Modell für jedes Token in einem dichten Format Schlüssel/Wert (KV). Dies wird ineffizient, wenn es sich um viele Sequenzen unterschiedlicher Längen handelt.

PAGEDATTENTENTENTEN führt ein virtualisiertes Speichersystem ein, das den Paging -Strategien der Betriebssysteme ähnelt, um KV -Cache flexibler zu verarbeiten. Anstatt den Speicher für den Aufmerksamkeits-Cache vorzulegen, unterteilt VLLM ihn in kleine Blöcke (Seiten). Diese Seiten werden dynamisch zugewiesen und über verschiedene Token und Anfragen wiederverwendet. Dies führt zu einem höheren Durchsatz und einem geringeren Speicherverbrauch.

# Schlüsselmerkmale von VLLM

VllM ist voll mit einer Reihe von Funktionen, die es für die Servierdienste von großsprachigen Modellen sehr optimiert machen. Hier sind einige der herausragenden Funktionen:

// 1. OpenAI-kompatibler API-Server

VLLM bietet einen integrierten API-Server, der nachahmt OpenaiAPI -Format. Auf diese Weise können Entwickler es an vorhandene Workflows und Bibliotheken wie die anschließen Openai Python SDK mit minimalem Aufwand.

// 2. Dynamisches Cost

Anstelle von statischen oder festen Batching fordert VLLM -Gruppen dynamisch an. Dies ermöglicht eine bessere GPU -Auslastung und einen verbesserten Durchsatz, insbesondere unter unvorhersehbarem oder burstem Verkehr.

// 3.. Umarmende Integration des Gesichtsmodells

VLLM unterstützt Umarme Gesichtstransformatoren ohne Modellumwandlung. Dies ermöglicht eine schnelle, versatile und entwicklerfreundliche Bereitstellung.

// 4. Erweiterbarkeit und Open Supply

VllM ist mit Blick auf die Modularität gebaut und von einer aktiven Open-Supply-Neighborhood gepflegt. Es ist einfach, zu kundenspezifischen Bedürfnissen beizutragen oder zu verlängern.

# Erste Schritte mit VLLM

Sie können VLLM mit dem Python Paket Supervisor installieren:

Verwenden Sie diesen Befehl in Ihrem Terminal, um ein umarmendes Gesichtsmodell zu dienen:

python3 -m vllm.entrypoints.openai.api_server 
    --model fb/opt-1.3b

Dadurch wird ein lokaler Server gestartet, der das OpenAI -API -Format verwendet.

Um es zu testen, können Sie diesen Python -Code verwenden:

import openai

openai.api_base = "http://localhost:8000/v1"
openai.api_key = "sk-no-key-required"

response = openai.ChatCompletion.create(
    mannequin="fb/opt-1.3b",
    messages=({"function": "consumer", "content material": "Hey!"})
)

print(response.selections(0).message("content material"))

Dies sendet eine Anfrage an Ihren lokalen Server und druckt die Antwort aus dem Modell.

# Häufige Anwendungsfälle

VLLM kann in vielen realen Situationen verwendet werden. Einige Beispiele sind:

• Chatbots und virtuelle Assistenten: Diese müssen schnell reagieren, auch wenn viele Menschen plaudern. VllM hilft bei der Verringerung der Latenz und zur gleichzeitigen Handlung gleichzeitig.
• Search Augmentation: VLLM kann Suchmaschinen verbessern, indem sie zusammen mit herkömmlichen Suchergebnissen kontextbezogene Zusammenfassungen oder Antworten bereitstellen.
• Enterprise AI -Plattformen: Von der Zusammenfassung der Dokumenten bis zur internen Wissensbasisabfrage können Unternehmen LLMs mit VLLM bereitstellen.
• Batch -Inferenz: Für Anwendungen wie Weblog -Schreiben, Produktbeschreibungen oder Übersetzungen kann VLLM mithilfe dynamischer Chargen große Inhaltsvolumina erzeugen.

# Leistungshighlights von VLLM

Leistung ist ein Hauptgrund für die Einführung von VLLM. Im Vergleich zu Commonplace -Transformator -Inferenzmethoden kann VLLM liefern:

• 2x–3x höherer Durchsatz (Token/Sekunden) im Vergleich zum Umarmungsgesicht + Deepspeed
• Niedrigerer Speicherverbrauch dank der KV -Cache -Verwaltung über PageDattention
• Schleinere Skalierung über mehrere GPUs mit Modell-Sharding und Tensor-Parallelität

# Nützliche Hyperlinks

# Letzte Gedanken

VLLM definiert neu, wie große Sprachmodelle eingesetzt und bedient werden. Mit seiner Fähigkeit, lange Sequenzen zu handhaben, den Speicher zu optimieren und einen hohen Durchsatz zu liefern, entfernt es viele der Leistungsengpässe, die traditionell eingeschränkte LLM -Nutzung in der Produktion haben. Die einfache Integration in vorhandene Instruments und versatile API -Unterstützung macht es zu einer hervorragenden Wahl für Entwickler, die AI -Lösungen skalieren möchten.

Jayita Gulati ist ein Fanatic und technische Schriftsteller für maschinelles Lernen, der von ihrer Leidenschaft für den Aufbau maschineller Lernmodelle angetrieben wird. Sie hat einen Grasp -Abschluss in Informatik an der Universität von Liverpool.

Bild von Autor | Leinwand

Wenn Sie gerne maschinelle Lernmodelle erstellen und mit neuen Sachen experimentieren, ist das wirklich cool – aber um ehrlich zu sein, wird es für andere nur nützlich, sobald Sie es ihnen zur Verfügung stellen. Dafür müssen Sie es bedienen – sie über eine Net -API aussetzen, damit andere Programme (oder Menschen) Daten senden und Vorhersagen zurückerhalten können. Dort kommen REST -APIs ins Spiel.

In diesem Artikel erfahren Sie, wie wir in knapp 10 Minuten von einem einfachen Modell für maschinelles Lernen zu einer produktionsbereiteten API mit Fastapi, einem der schnellsten und entwicklerfreundlichsten Webrahmen von Python, übergehen werden. Und wir werden nicht einfach bei einer Demo „Make It Run“ anhalten, sondern wir werden Dinge hinzufügen wie:

• Validierung eingehender Daten
• Jede Anfrage protokollieren
• Hinzufügen von Hintergrundaufgaben, um Verlangsamungen zu vermeiden
• Anmutig mit Fehlern umgehen

Lassen Sie mich Ihnen additionally schnell zeigen, wie unsere Projektstruktur aussehen wird, bevor wir zum Code -Teil wechseln:

ml-api/
│
├── mannequin/
│   └── train_model.py        # Script to coach and save the mannequin
│   └── iris_model.pkl        # Skilled mannequin file
│
├── app/
│   └── predominant.py               # FastAPI app
│   └── schema.py             # Enter information schema utilizing Pydantic
│
├── necessities.txt          # All dependencies
└── README.md                 # Optionally available documentation

Schritt 1: Installieren Sie das, was Sie brauchen

Für dieses Projekt benötigen wir ein paar Python-Pakete: Fastapi für die API, Scikit-Be taught für das Modell und ein paar Helfer wie JoBlib und Pydantic. Sie können sie mit PIP installieren:

pip set up fastapi uvicorn scikit-learn joblib pydantic

Und speichern Sie Ihre Umgebung:

pip freeze > necessities.txt

Schritt 2: trainieren und ein einfaches Modell speichern

Lassen Sie uns den Teil des maschinellen Lernens einfach halten, damit wir uns auf das Servieren des Modells konzentrieren können. Wir werden den Berühmten benutzen Iris -Datensatz und prepare a Zufälliger Waldklassifizierer die Artwork der Irisblume vorherzusagen, basierend auf seinen Blüten- und Sepal -Messungen.

Hier ist das Trainingsskript. Erstellen Sie eine Datei aufgerufen train_model.py in a Modell/ Verzeichnis:

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
import joblib, os

X, y = load_iris(return_X_y=True)
clf = RandomForestClassifier()
clf.match(*train_test_split(X, y, test_size=0.2, random_state=42)(:2))

os.makedirs("mannequin", exist_ok=True)
joblib.dump(clf, "mannequin/iris_model.pkl")
print("✅ Mannequin saved to mannequin/iris_model.pkl")

Dieses Skript lädt die Daten, spaltet es, trainiert das Modell und speichert es mit JoBlib. Führen Sie es einmal aus, um die Modelldatei zu generieren:

python mannequin/train_model.py

Schritt 3: Definieren Sie, welche Eingabe Ihre API erwarten sollte

Jetzt müssen wir definieren, wie Benutzer mit Ihrer API interagieren. Was sollten sie senden und in welchem ​​Format?

Wir werden Pydantic, einen integrierten Teil von Fastapi, verwenden, um ein Schema zu erstellen, das eingehende Daten beschreibt und validiert. Insbesondere stellen wir sicher, dass Benutzer vier optimistic Float -Werte bereitstellen – für die Sepallänge/-breite und Blütenblätterlänge/-breite.

In einer neuen Datei App/Schema.pyhinzufügen:

from pydantic import BaseModel, Discipline

class IrisInput(BaseModel):
    sepal_length: float = Discipline(..., gt=0, lt=10)
    sepal_width: float = Discipline(..., gt=0, lt=10)
    petal_length: float = Discipline(..., gt=0, lt=10)
    petal_width: float = Discipline(..., gt=0, lt=10)

Hier haben wir Wertschöpfungsbeschränkungen (mehr als 0 und weniger als 10) zusätzliche Wertschöpfungsbeschränkungen, um unsere Eingaben sauber und realistisch zu halten.

Schritt 4: Erstellen Sie die API

Jetzt ist es Zeit, die eigentliche API zu erstellen. Wir werden Fastapi verwenden, um:

• Laden Sie das Modell
• Akzeptieren Sie JSON -Eingaben
• Vorhersage der Klasse und den Wahrscheinlichkeiten
• Melden Sie die Anforderung im Hintergrund an
• Eine saubere JSON -Antwort zurückgeben

Schreiben wir den Haupt -API -Code darin App/predominant.py:

from fastapi import FastAPI, HTTPException, BackgroundTasks
from fastapi.responses import JSONResponse
from app.schema import IrisInput
import numpy as np, joblib, logging

# Load the mannequin
mannequin = joblib.load("mannequin/iris_model.pkl")

# Arrange logging
logging.basicConfig(filename="api.log", degree=logging.INFO,
                    format="%(asctime)s - %(message)s")

# Create the FastAPI app
app = FastAPI()

@app.submit("/predict")
def predict(input_data: IrisInput, background_tasks: BackgroundTasks):
    attempt:
        # Format the enter as a NumPy array
        information = np.array(((input_data.sepal_length,
                          input_data.sepal_width,
                          input_data.petal_length,
                          input_data.petal_width)))
        
        # Run prediction
        pred = mannequin.predict(information)(0)
        proba = mannequin.predict_proba(information)(0)
        species = ("setosa", "versicolor", "virginica")(pred)

        # Log within the background so it doesn’t block response
        background_tasks.add_task(log_request, input_data, species)

        # Return prediction and chances
        return {
            "prediction": species,
            "class_index": int(pred),
            "chances": {
                "setosa": float(proba(0)),
                "versicolor": float(proba(1)),
                "virginica": float(proba(2))
            }
        }

    besides Exception as e:
        logging.exception("Prediction failed")
        elevate HTTPException(status_code=500, element="Inner error")

# Background logging job
def log_request(information: IrisInput, prediction: str):
    logging.information(f"Enter: {information.dict()} | Prediction: {prediction}")

Lassen Sie uns innehalten und verstehen, was hier passiert.

Wir laden das Modell einmal, wenn die App startet. Wenn ein Benutzer die trifft /vorhersagen Endpunkt mit gültigen JSON -Eingaben konvertieren wir dies in ein Numpy -Array, bestehen es durch das Modell und geben die vorhergesagte Klasse und Wahrscheinlichkeiten zurück. Wenn etwas schief geht, protokollieren wir es und geben einen freundlichen Fehler zurück.

Beachten Sie die Hintergrundbeschwerden Teil – Dies ist eine ordentliche Fastapi -Funktion, mit der wir nach dem Senden der Antwort arbeiten können (z. B. Speichern von Protokollen). Das hält die API an und vermeidet Verzögerungen.

Schritt 5: Führen Sie Ihre API aus

Verwenden Sie uvicorn so wie folgt, um den Server zu starten:

uvicorn app.predominant:app --reload

Besuchen: http://127.0.0.1:8000/docs
Sie werden eine interaktive Swagger -Benutzeroberfläche sehen, in der Sie die API testen können.
Probieren Sie diese Beispieleingabe aus:

{
  "sepal_length": 6.1,
  "sepal_width": 2.8,
  "petal_length": 4.7,
  "petal_width": 1.2
}

Oder Sie können Curl verwenden, um die Anfrage wie folgt zu stellen:

curl -X POST "http://127.0.0.1:8000/predict" -H  "Content material-Kind: utility/json" -d 
'{
  "sepal_length": 6.1,
  "sepal_width": 2.8,
  "petal_length": 4.7,
  "petal_width": 1.2
}'

Beide erzeugen die gleiche Antwort, die Folgendes ist:

{"prediction":"versicolor",
 "class_index":1,
 "chances": {
	 "setosa":0.0,
	 "versicolor":1.0,
	 "virginica":0.0 }
 }

Optionaler Schritt: Stellen Sie Ihre API bereit

Sie können die Fastapi -App auf:

• Render.com (Null -Konfigurationsbereitstellung)
• Eisenbahn.App (für kontinuierliche Integration)
• Heroku (über Docker)

Sie können dies auch in einen produktionsbereiten Service ausdehnen, indem Sie Authentifizierung (z. B. API-Schlüssel oder OAuth) hinzufügen, um Ihre Endpunkte zu schützen, Anforderungen mit Prometheus und Grafana zu überwachen und Redis oder Sellerie für Hintergrundjob-Warteschlangen zu verwenden. Sie können sich auch auf meinen Artikel beziehen: Schritt-für-Schritt-Anleitung zum Bereitstellen von Modellen für maschinelles Lernen mit Docker.

Einpacken

Das struggle’s – und es ist schon besser als die meisten Demos. Was wir gebaut haben, ist mehr als nur ein Spielzeugbeispiel. Allerdings: es:

• Validiert automatisch Eingabedaten
• Gibt aussagekräftige Antworten mit Vorhersagevertrauen zurück
• Melden Sie sich jede Anforderung an eine Datei an (api.log)
• Verwendet Hintergrundaufgaben, sodass die API schnell und reaktionsschnell bleibt
• Verarbeitet Misserfolge anmutig

Und alles in weniger als 100 Codezeilen.

Kanwal Mehreen Kanwal ist ein Ingenieur für maschinelles Lernen und technischer Schriftsteller mit einer tiefgreifenden Leidenschaft für die Datenwissenschaft und die Schnittstelle von KI mit Medizin. Sie hat das eBook „Produktivität mit Chatgpt maximieren“. Als Google -Era -Gelehrte 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie wird auch als Teradata -Vielfalt in Tech Scholar, MITACS Globalink Analysis Scholar und Harvard Wecode Scholar anerkannt. Kanwal ist ein leidenschaftlicher Verfechter der Veränderung, nachdem er Femcodes gegründet hat, um Frauen in STEM -Bereichen zu stärken.