Déploiement de 7B GPT avec Ray
Table des matières
- Qu'est-ce que Ray serve?
- Installation de Ray et des bibliothèques requises
- Initialisation et déploiement de modèle
- Création de la fonction d'appel
- Génération de texte avec le modèle
- Déploiement du modèle avec Ray serve
- Test de l'API de génération de texte
- Utilisation de plusieurs GPU ou instances
- Intégration de la mise en cache et de la sélection des meilleurs résultats
- Déploiement de modèles pyTorch avec Ray
📝 Article
Déploiement de modèles de langage avec Ray serve: Une infrastructure de serveur d'API en Python
Dans cette vidéo, nous allons explorer le déploiement de modèles de langage à l'Aide de Ray serve, une bibliothèque Python qui permet de créer facilement des API de modèles en ligne évolutives. Ray serve est un cadre agnostique qui prend en charge une grande variété de modules d'apprentissage en profondeur, de modèles construits avec des frameworks tels que PyTorch, jusqu'à la logique métier Python arbitraire.
Qu'est-ce que Ray serve?
Ray serve est une bibliothèque de déploiement de modèles en ligne évolutive qui permet de construire des API d'inférence hautement performantes. Elle prend en charge diverses tâches, allant des modules d'apprentissage en profondeur aux logiques métier Python arbitraires. Avec Ray serve, vous pouvez créer une infrastructure de serveur d'API complète en utilisant un toolkit unique.
Installation de Ray et des bibliothèques requises
Avant de commencer à utiliser Ray serve, vous devez installer Ray et les bibliothèques requises. Vous pouvez le faire en exécutant la commande suivante :
pip install ray
Ensuite, vous devez importer les modules nécessaires dans votre script Python. Assurez-vous d'importer les bibliothèques suivantes :
import ray
from ray import serve
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from torch.cuda.amp import autocast
Initialisation et déploiement du modèle
Le premier pas pour utiliser Ray serve est d'initialiser Ray et de définir le déploiement du modèle. Vous pouvez le faire en utilisant les lignes de code suivantes :
ray.init()
serve.start()
Ensuite, vous devez créer une classe pour votre déploiement de modèle. Par exemple, vous pouvez créer une classe appelée "GPTDeployment" qui sera utilisée pour héberger notre modèle GPT-3 :
class GPTDeployment:
def __init__(self):
self.model_id = "Mosaic LM MPT 7 billion parameters"
self.device = torch.device("cuda:0")
self.model = self.load_model()
def load_model(self):
model = AutoModelForCausalLM.from_pretrained(self.model_id)
model.to(self.device)
return model
Création de la fonction d'appel
Ensuite, nous devons définir une fonction d'appel qui sera responsable du traitement des requêtes reçues par notre API. Dans notre exemple, nous utilisons FastAPI pour créer une API asynchrone. Voici comment vous pouvez définir cette fonction :
async def call(request):
data = await request.json()
text = data["text"]
generated_text = self.generate(text)
response = {
"generated_text": generated_text
}
return response
La fonction generate
est responsable de la génération de texte à l'aide de notre modèle GPT-3. Vous pouvez définir cette fonction comme suit :
def generate(self, text):
with autocast():
inputs = self.tokenizer.encode(text, return_tensors="pt").to(self.device)
output = self.model.generate(inputs)
generated_text = self.tokenizer.decode(output[0])
return generated_text
Génération de texte avec le modèle
Maintenant que nous avons notre fonction d'appel et la fonction de génération de texte, nous pouvons générer du texte en utilisant notre modèle GPT-3. Pour cela, nous allons utiliser la fonction generate
que nous avons définie précédemment :
text = "Expliquez comment écrire une fonction en Python."
generated_text = self.generate(text)
Le texte généré sera stocké dans la variable generated_text
et peut être utilisé pour renvoyer la réponse au client.
Déploiement du modèle avec Ray serve
Maintenant que nous avons défini notre modèle et notre fonction d'appel, nous pouvons les déployer en utilisant Ray serve. Voici comment vous pouvez le faire :
serve.create_endpoint("gpt_api", "/model")
serve.create_backend("gpt_backend", GPTDeployment)
serve.link("gpt_api", "gpt_backend")
serve.set_traffic("gpt_api", {"gpt_backend": 1.0})
Ces lignes de code créent un point de terminaison pour notre API, lient notre modèle à ce point de terminaison et définissent le trafic vers notre modèle.
Test de l'API de génération de texte
Maintenant que notre modèle est déployé, nous pouvons tester notre API de génération de texte. Pour cela, nous pouvons utiliser la bibliothèque requests
pour envoyer une requête POST à notre API. Voici comment vous pouvez le faire :
import requests
url = "http://localhost:8000/model"
data = {"text": "Expliquez comment écrire une fonction en Python."}
response = requests.post(url, json=data)
print(response.json()["generated_text"])
Vous devriez recevoir une réponse contenant du texte généré par notre modèle GPT-3.
Utilisation de plusieurs GPU ou instances
Si vous disposez de plusieurs GPU ou d'instances, vous pouvez tirer parti de cette puissance en utilisant Ray serve. Vous pouvez déployer plusieurs instances de votre modèle et les lier ensemble pour traiter des demandes en parallèle. Voici comment vous pouvez le faire :
serve.create_backend("gpt_backend_1", GPTDeployment)
serve.create_backend("gpt_backend_2", GPTDeployment)
serve.link("gpt_api", "gpt_backend_1")
serve.link("gpt_api", "gpt_backend_2")
serve.set_traffic("gpt_api", {"gpt_backend_1": 0.5, "gpt_backend_2": 0.5})
Cela déploiera deux instances de notre modèle et les liera ensemble pour traiter les demandes de manière équilibrée.
Intégration de la mise en cache et de la sélection des meilleurs résultats
Pour améliorer les performances de votre API de génération de texte, vous pouvez intégrer la mise en cache et la sélection des meilleurs résultats. Par exemple, vous pouvez utiliser Redis comme cache pour stocker les résultats précédemment générés afin de les renvoyer plus rapidement lorsque la même requête est effectuée à nouveau. Vous pouvez également utiliser des algorithmes d'évaluation de texte pour sélectionner les meilleurs résultats générés par votre modèle.
Déploiement de modèles pyTorch avec Ray
En plus de déployer des modèles Transformers, vous pouvez également déployer des modèles pyTorch avec Ray. Vous pouvez utiliser des modèles pyTorch pré-entraînés et des bibliothèques comme FastAPI pour créer des API d'inférence hautement performantes. Voici comment vous pouvez le faire :
from fastapi import FastAPI
from torch import nn
app = FastAPI()
@app.post("/predict")
async def predict(request: Request):
data = await request.json()
inputs = data["inputs"]
# Process inputs using pyTorch model
return {"output": output}
Dans cet exemple, nous utilisons FastAPI pour créer une API qui accepte les requêtes POST sur la route "/predict". Dans cette fonction, vous pouvez ajouter votre code de traitement en utilisant le modèle pyTorch de votre choix.
Cet article vous a montré comment déployer des modèles de langage à l'aide de Ray serve, une bibliothèque Python qui facilite le déploiement d'API de modèles en ligne évolutives. Vous avez appris comment initialiser et déployer des modèles, créer une fonction d'appel pour traiter les requêtes, générer du texte avec le modèle, déployer le modèle avec Ray serve, tester l'API de génération de texte, utiliser plusieurs GPU ou instances, intégrer la mise en cache et la sélection des meilleurs résultats, et même déployer des modèles pyTorch avec Ray.
Ray serve offre une grande flexibilité et de nombreuses fonctionnalités avancées pour le déploiement de modèles de langage. Que vous souhaitiez déployer des modèles Transformers pré-entraînés ou vos propres modèles pyTorch, Ray serve vous permettra de le faire de manière efficace et performante.
N'oubliez pas d'explorer la documentation officielle de Ray serve pour découvrir davantage de fonctionnalités et d'exemples d'utilisation. Et surtout, amusez-vous en explorant les possibilités infinies de déploiement de modèles de langage avec Ray serve !
Ressources :