LitServe : déploiement rapide de services d'inférence de modèles d'IA polyvalents de niveau entreprise

Introduction générale

LitServe est foudre AI a lancé un moteur de service de modèle d'IA open source, construit sur FastAPI, qui se concentre sur le déploiement rapide de services d'inférence pour les modèles d'IA à usage général. Il prend en charge un large éventail de scénarios, depuis les modèles de grands langages (LLM), les modèles visuels, les modèles audio, jusqu'aux modèles classiques d'apprentissage automatique, et permet le traitement par lots, la diffusion en continu et la mise à l'échelle automatique du GPU, avec une augmentation des performances d'au moins 2 fois par rapport à FastAPI. LitServe est facile à utiliser et très flexible, et peut être auto-hébergé ou entièrement hébergé via les Lightning Studios. LitServe est facile à utiliser et très flexible, et peut être auto-hébergé ou entièrement hébergé via Lightning Studios, ce qui le rend idéal pour les chercheurs, les développeurs et les entreprises afin de créer rapidement des API d'inférence de modèles efficaces. Les responsables mettent l'accent sur des fonctionnalités de classe entreprise telles que la sécurité, l'évolutivité et la haute disponibilité pour s'assurer que les environnements de production sont prêts à fonctionner dès la sortie de la boîte.

Liste des fonctions

• Déploiement rapide de services d'inférenceSupport pour la conversion rapide de modèles à partir de frameworks comme PyTorch, JAX, TensorFlow, etc. vers des API.
• fichier de lotFusionner plusieurs demandes d'inférence en un lot afin d'améliorer le débit.
• streamingLes résultats de l'inférence peuvent être transmis en temps réel, ce qui convient aux scénarios de réponse en continu.
• Mise à l'échelle automatique du GPUOptimise les performances en ajustant dynamiquement les ressources GPU en fonction de la charge d'inférence.
• Système composite d'IALe système de gestion de l'information : Il permet à plusieurs modèles de raisonner en collaboration afin de créer des services complexes.
• Hébergement autonome ou hébergement dans le nuageLa solution de déploiement local ou de gestion par le biais du nuage Lightning Studios : La solution de déploiement local ou de gestion par le biais du nuage Lightning Studios.
• Intégration avec vLLM: Optimisation de la performance de l'inférence pour les modèles de langage de grande taille.
• Compatible avec OpenAPILes API : génèrent automatiquement une documentation standard sur les API pour faciliter les tests et l'intégration.
• Prise en charge complète du modèleLes modèles d'inférence : Couvrir les besoins d'inférence de différents modèles tels que LLM, vision, audio, encastrement, etc.
• Optimisation du serveurFastAPI : permet un traitement multiprocessus et une inférence plus de deux fois plus rapide que FastAPI.

Utiliser l'aide

Processus d'installation

LitServe est facile à installer avec le logiciel Python pip L'outil fera le travail. Voici les étapes détaillées :

1. préparer l'environnement

Assurez-vous que Python 3.8 ou une version ultérieure est installé sur votre système ; un environnement virtuel est recommandé :

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

2. installation de LitServe

Exécutez la commande suivante pour installer la version stable :

pip install litserve

Si vous avez besoin des dernières fonctionnalités, vous pouvez installer la version de développement :

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

3. l'inspection des installations

Vérifiez que l'opération s'est déroulée correctement :

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

La sortie du numéro de version complète l'installation.

4. dépendances optionnelles

Si vous avez besoin d'un support GPU, installez la version GPU du framework correspondant, par exemple :

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

Comment utiliser LitServe

LitServe transforme les modèles d'IA en services d'inférence grâce à un code propre. Voici comment cela fonctionne en détail :

1. création du service de raisonnement simple

Voici un exemple de service de raisonnement composite avec deux modèles :

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)

• être en mouvement: Sauvegarder sous server.pyMise en œuvre python server.py.
• test (machines, etc.)Utilisation de la curl Envoi d'une demande de raisonnement :

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

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

2) Permettre le raisonnement en masse

Modifier le code pour permettre le traitement par lots :

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

• Mode d'emploi: :max_batch_size=4 Indique que jusqu'à 4 requêtes d'inférence sont traitées en même temps et automatiquement fusionnées pour améliorer l'efficacité.
• Méthodes d'essaiLa demande est envoyée plusieurs fois et l'on observe l'amélioration du débit :

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

3. configurer le raisonnement en continu

Pour les scénarios de raisonnement en temps réel :

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)

• Mode d'emploi: :stream=True Permettre le raisonnement en continu.predict utiliser yield Renvoie les résultats un par un.
• Méthodes d'essaiLes réponses en continu : Utilisez un client qui prend en charge les réponses en continu :

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

4. expansion automatique du GPU

Si un GPU est disponible, LitServe optimise automatiquement l'inférence :

• Mode d'emploi: :accelerator="auto" Détecter les GPU et leur donner la priorité.
• valider (une théorie)Les données de l'utilisation du GPU doivent être vérifiées après l'exécution de l'application.
• Exigences environnementalesPour cela, il faut s'assurer que la version GPU du framework (par exemple PyTorch) est installée.

5) Déploiement d'un modèle de raisonnement complexe (en utilisant BERT comme exemple)

Déployer le service d'inférence de modèle BERT de Hugging Face :

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)

• être en mouvementAprès avoir exécuté le script, accédez à la page http://127.0.0.1:8000/predict.
• test (machines, etc.): :

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

6. intégrer vLLM pour déployer le raisonnement LLM

Raisonnement efficace pour les grands modèles linguistiques :

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 de vLLM: :pip install vllm.
• test (machines, etc.): :

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

7. consulter la documentation de l'API

• Mode d'emploi: Accès http://127.0.0.1:8000/docsService de raisonnement par test interactif.
• Conseils de fonctionnementLe système est basé sur la norme OpenAPI et contient toutes les informations relatives aux points d'extrémité.

8. options d'hébergement

• auto-hébergéLe code peut être exécuté localement ou sur le serveur.
• hébergement en nuageDéploiement via Lightning Studios, nécessite l'enregistrement d'un compte, offre l'équilibrage de la charge, la mise à l'échelle automatique, et plus encore.

Conseils d'utilisation

• ajuster les composants pendant les essais: Réglages timeout=60 Éviter les délais de raisonnement.
• log (calcul)Pour résoudre le problème, il faut consulter les journaux du terminal au moment du démarrage.
• optimisationLes fonctions avancées telles que l'authentification et le déploiement Docker sont activées en se référant à la documentation officielle.

LitServe prend en charge l'ensemble des exigences des processus, du prototypage aux applications d'entreprise, grâce au déploiement rapide et à l'optimisation des services d'inférence.