LitServe: schnelle Bereitstellung von universellen KI-Modellinferenzdiensten auf Unternehmensebene

Allgemeine Einführung

LitServe ist Blitzschlag AI hat eine quelloffene KI-Modell-Service-Engine auf der Basis von FastAPI auf den Markt gebracht, die sich auf die schnelle Bereitstellung von Inferenzdiensten für KI-Modelle für allgemeine Zwecke konzentriert. Sie unterstützt eine breite Palette von Szenarien, von großen Sprachmodellen (LLMs), visuellen Modellen, Audiomodellen bis hin zu klassischen maschinellen Lernmodellen, und bietet Batch-Verarbeitung, Streaming und automatische GPU-Skalierung mit einer mindestens zweifachen Leistungssteigerung gegenüber FastAPI. LitServe ist einfach zu bedienen und hochflexibel und kann selbst gehostet oder vollständig über Lightning Studios gehostet werden. LitServe ist einfach zu bedienen und hochflexibel und kann sowohl selbst gehostet als auch vollständig über Lightning Studios gehostet werden. Damit ist es ideal für Forscher, Entwickler und Unternehmen, um schnell effiziente Modellinferenz-APIs zu erstellen. Die Verantwortlichen legen Wert auf Funktionen der Unternehmensklasse wie Sicherheit, Skalierbarkeit und Hochverfügbarkeit, um sicherzustellen, dass Produktionsumgebungen sofort einsatzbereit sind.

Funktionsliste

• Schnelle Bereitstellung von AbleitungsdienstenUnterstützung für die schnelle Konvertierung von Modellen aus Frameworks wie PyTorch, JAX, TensorFlow, etc. in APIs.
• StapeldateiZusammenfassen mehrerer Inferenzanfragen zu einem Stapel, um den Durchsatz zu erhöhen.
• StreamingUnterstützung der Ausgabe von Inferenzergebnissen in Echtzeit, geeignet für kontinuierliche Reaktionsszenarien.
• Automatische GPU-SkalierungOptimiert die Leistung durch dynamische Anpassung der GPU-Ressourcen auf der Grundlage der Inferenzlast.
• Zusammengesetztes AI-SystemErmöglicht die Zusammenarbeit mehrerer Modelle bei der Entwicklung komplexer Dienste.
• Selbstgehostetes vs. Cloud-HostingUnterstützt die lokale Bereitstellung oder die Verwaltung über die Lightning Studios Cloud.
• Integration mit vLLM: Optimierung der Inferenzleistung für große Sprachmodelle.
• OpenAPI-kompatibelAutomatisch generierte Standard-API-Dokumentation für einfache Tests und Integration.
• Vollständige ModellunterstützungAbdeckung des Inferenzbedarfs verschiedener Modelle wie LLM, Vision, Audio, Embedding, etc.
• Server-OptimierungBietet Multiprozess-Verarbeitung und Inferenz mehr als 2x schneller als FastAPI.

Hilfe verwenden

Einbauverfahren

LitServe ist einfach zu installieren mit Python's pip Das Werkzeug erledigt diese Aufgabe. Nachfolgend finden Sie die detaillierten Schritte:

1. die Umwelt vorbereiten

Stellen Sie sicher, dass Python 3.8 oder höher auf Ihrem System installiert ist; eine virtuelle Umgebung wird empfohlen:

python -m venv venv
source venv/bin/activate  # Linux/Mac
venv\Scripts\activate     # Windows

2. die Installation von LitServe

Führen Sie den folgenden Befehl aus, um die stabile Version zu installieren:

pip install litserve

Wenn Sie die neuesten Funktionen benötigen, können Sie die Entwicklungsversion installieren:

pip install git+https://github.com/Lightning-AI/litserve.git@main

3. die Kontrolle der Anlagen

Überprüfen Sie, ob der Vorgang erfolgreich war:

python -c "import litserve; print(litserve.__version__)"

Mit der erfolgreichen Ausgabe der Versionsnummer ist die Installation abgeschlossen.

4. fakultative Abhängigkeiten

Wenn Sie GPU-Unterstützung benötigen, installieren Sie z. B. die GPU-Version des entsprechenden Frameworks:

pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121

Verwendung von LitServe

LitServe verwandelt KI-Modelle durch sauberen Code in Inferenzdienste. Hier erfahren Sie, wie es im Detail funktioniert:

1. die Einrichtung des Simple Reasoning Service

Es folgt ein Beispiel für einen zusammengesetzten Reasoning-Dienst mit zwei Modellen:

import litserve as ls
class SimpleLitAPI(ls.LitAPI):
def setup(self, device):
# 初始化，加载模型或数据
self.model1 = lambda x: x ** 2  # 平方模型
self.model2 = lambda x: x ** 3  # 立方模型
def decode_request(self, request):
# 解析请求数据
return request["input"]
def predict(self, x):
# 复合推理
squared = self.model1(x)
cubed = self.model2(x)
return squared + cubed
def encode_response(self, output):
# 格式化推理结果
return {"output": output}
if __name__ == "__main__":
server = ls.LitServer(SimpleLitAPI(), accelerator="auto")
server.run(port=8000)

• in Bewegung sein: Speichern unter server.pyUmsetzung python server.py.
• Prüfung (Maschinen usw.): Verwendung von curl Sendet eine Begründungsanfrage:

  curl -X POST "http://127.0.0.1:8000/predict" -H "Content-Type: application/json" -d '{"input": 4.0}'
  

  Ausgabe:{"output": 80.0}(16 + 64).

2. die Ermöglichung von Bulk Reasoning

Ändern Sie den Code, um die Stapelverarbeitung zu unterstützen:

server = ls.LitServer(SimpleLitAPI(), max_batch_size=4, accelerator="auto")

• Betriebsanleitung::max_batch_size=4 Zeigt an, dass bis zu 4 Ableitungsanfragen gleichzeitig bearbeitet und automatisch zusammengeführt werden, um die Effizienz zu verbessern.
• TestmethodenSenden Sie die Anfrage mehrmals und beobachten Sie die Verbesserung des Durchsatzes:

  curl -X POST "http://127.0.0.1:8000/predict" -H "Content-Type: application/json" -d '{"input": 5.0}'
  

3. die Konfiguration von Streaming-Überlegungen

Für Echtzeit-Darstellungsszenarien:

class StreamLitAPI(ls.LitAPI):
def setup(self, device):
self.model = lambda x: [x * i for i in range(5)]
def decode_request(self, request):
return request["input"]
def predict(self, x):
for result in self.model(x):
yield result
def encode_response(self, output):
return {"output": output}
server = ls.LitServer(StreamLitAPI(), stream=True, accelerator="auto")
server.run(port=8000)

• Betriebsanleitung::stream=True Ermöglichung von Streaming Reasoning.predict ausnutzen yield Gibt die Ergebnisse der Reihe nach zurück.
• Testmethoden: Verwenden Sie einen Client, der Streaming-Antworten unterstützt:

  curl --no-buffer -X POST "http://127.0.0.1:8000/predict" -H "Content-Type: application/json" -d '{"input": 2}'
  

4. automatische GPU-Erweiterung

Wenn ein Grafikprozessor zur Verfügung steht, optimiert LitServe die Inferenz automatisch:

• Betriebsanleitung::accelerator="auto" Erkennung und Priorisierung von GPUs.
• validieren (eine Theorie)Überprüfen Sie die Protokolle nach der Ausführung, um die GPU-Nutzung zu bestätigen.
• Anforderungen an die UmweltStellen Sie sicher, dass die GPU-Version des Frameworks (z. B. PyTorch) installiert ist.

5. der Einsatz komplexer Modellüberlegungen (am Beispiel von BERT)

Setzen Sie den BERT-Modellinferenzdienst von Hugging Face ein:

from transformers import BertTokenizer, BertModel
import litserve as ls
class BertLitAPI(ls.LitAPI):
def setup(self, device):
self.tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
self.model = BertModel.from_pretrained("bert-base-uncased").to(device)
def decode_request(self, request):
return request["text"]
def predict(self, text):
inputs = self.tokenizer(text, return_tensors="pt").to(self.model.device)
outputs = self.model(**inputs)
return outputs.last_hidden_state.mean(dim=1).tolist()
def encode_response(self, output):
return {"embedding": output}
server = ls.LitServer(BertLitAPI(), accelerator="auto")
server.run(port=8000)

• in Bewegung seinNach dem Ausführen des Skripts rufen Sie die Datei http://127.0.0.1:8000/predict.
• Prüfung (Maschinen usw.)::

  curl -X POST "http://127.0.0.1:8000/predict" -H "Content-Type: application/json" -d '{"text": "Hello, world!"}'
  

6. vLLM integrieren, um LLM-Schlussfolgerungen einzusetzen

Effizientes Reasoning für große Sprachmodelle:

import litserve as ls
from vllm import LLM
class LLMLitAPI(ls.LitAPI):
def setup(self, device):
self.model = LLM(model="meta-llama/Llama-3.2-1B", dtype="float16")
def decode_request(self, request):
return request["prompt"]
def predict(self, prompt):
outputs = self.model.generate(prompt, max_tokens=50)
return outputs[0].outputs[0].text
def encode_response(self, output):
return {"response": output}
server = ls.LitServer(LLMLitAPI(), accelerator="auto")
server.run(port=8000)

• Installation von vLLM::pip install vllm.
• Prüfung (Maschinen usw.)::

  curl -X POST "http://127.0.0.1:8000/predict" -H "Content-Type: application/json" -d '{"prompt": "What is AI?"}'
  

7. die API-Dokumentation einsehen

• Betriebsanleitung: Zugang http://127.0.0.1:8000/docsInteraktiver Test Reasoning Service.
• Tipps zur FunktionOpenAPI: Basiert auf dem OpenAPI-Standard und enthält alle Endpunktdetails.

8. die Hosting-Optionen

• selbst gehostetAusführen des Codes lokal oder auf dem Server.
• Cloud-HostingWird über Lightning Studios bereitgestellt, erfordert eine Kontoregistrierung, bietet Lastausgleich, automatische Skalierung und mehr.

Tipps zur Bedienung

• Komponenten während der Prüfung anpassen: Einstellungen timeout=60 Vermeiden Sie Zeitüberschreitungen bei der Argumentation.
• log (Rechnen)Prüfen Sie die Terminalprotokolle beim Starten, um das Problem zu beheben.
• Optimierung: Lesen Sie die offizielle Dokumentation, um erweiterte Funktionen wie Authentifizierung und Docker-Bereitstellung zu aktivieren.

LitServe unterstützt das gesamte Spektrum der Prozessanforderungen vom Prototyping bis hin zu Anwendungen der Unternehmensklasse durch die schnelle Bereitstellung und Optimierung von Inferenzdiensten.