Déploiement de modèle PyTorch

Le déploiement de modèles est le processus consistant à mettre des modèles d'apprentissage automatique entraînés dans des applications pratiques. PyTorch fournit divers outils et méthodes pour atteindre cet objectif.

Pourquoi le déploiement de modèles est nécessaire

  • Intégration applicative: Intégrer des capacités d'IA dans des systèmes Web, mobiles ou embarqués
  • Optimisation des performances: Optimiser la vitesse d'inférence des modèles pour les environnements de production
  • Gestion des ressources: Utiliser efficacement les ressources de calcul pour obtenir des services à haute concurrence

Vue d'ensemble du processus de déploiement

Préparation et optimisation du modèle

Formats d'exportation de modèles

PyTorch prend principalement en charge les formats d'exportation suivants :

Format Fonctionnalités Scénarios applicables
TorchScript Format natif de PyTorch, préserve les fonctionnalités du graphe dynamique Utilisé au sein de l'écosystème PyTorch
ONNX Standard ouvert, compatible multi-framework Environnement de collaboration multi-framework
Torch-TensorRT Format optimisé NVIDIA Accélération de l'inférence GPU

Exportation en TorchScript

Exemple

import torch
import torchvision

# Charger le modèle pré-entraîné
model = torchvision.models.resnet18(pretrained=True)
model.eval()

# Exemple d'entrée
example_input = torch.rand(1, 3, 224, 224)

# Méthode 1 : Export via traçage
traced_script = torch.jit.trace(model, example_input)
traced_script.save("resnet18_traced.pt")

# Méthode 2 : Export via scripting
scripted_model = torch.jit.script(model)
scripted_model.save("resnet18_scripted.pt")

Notes：

  1. torch.jit.tracePlus adapté aux modèles sans flux de contrôle
  2. torch.jit.scriptPeut gérer des modèles avec une logique complexe telle que des instructions conditionnelles
  3. Assurez-vous d'appeler avant l'exportmodel.eval()

Choisir une solution de déploiement

Solutions de déploiement local

LibTorch (API C++)

Exemple

#include <torch/script.h>

int main() {
    // Charger le modèle
    torch::jit::script::Module module;
    module = torch::jit::load("resnet18.pt");
   
    // Préparer l'entrée
    std::vector<torch::jit::IValue> inputs;
    inputs.push_back(torch::ones({1, 3, 224, 224}));
   
    // Exécuter l'inférence
    auto output = module.forward(inputs).toTensor();
    std::cout << output.slice(/*dim=*/1, /*start=*/0, /*end=*/5) << '\n';
}

ONNX Runtime

Exemple

import onnxruntime as ort

# Créer une session d'inférence
sess = ort.InferenceSession("model.onnx")

# Préparer l'entrée
input_name = sess.get_inputs()[0].name
input_data = np.random.rand(1, 3, 224, 224).astype(np.float32)

# Exécuter l'inférence
outputs = sess.run(None, {input_name: input_data})

Solutions de déploiement cloud

TorchServe (framework de service officiel)

Exemple

# Installer
pip install torchserve torch-model-archiver

# Empaqueter le modèle
torch-model-archiver --model-name resnet18 \
                     --version 1.0 \
                     --serialized-file model.pth \
                     --extra-files index_to_name.json \
                     --handler image_classifier \
                     --export-path model_store

# Démarrer le service
torchserve --start --model-store model_store --models resnet18=resnet18.mar

Création d'une API REST avec FastAPI

Exemple

from fastapi import FastAPI
from PIL import Image
import io
import torch

app = FastAPI()
model = torch.jit.load("model.pt")

@app.post("/predict")
async def predict(image: UploadFile = File(...)):
    img_data = await image.read()
    img = Image.open(io.BytesIO(img_data))
    # Prétraitement...
    with torch.no_grad():
        output = model(img_tensor)
    return {"prediction": output.argmax().item()}

Conseils d'optimisation des performances

Accélération de la quantification

Exemple

# Quantification dynamique
quantized_model = torch.quantization.quantize_dynamic(
    model, {torch.nn.Linear}, dtype=torch.qint8)

# Quantification statique
model.qconfig = torch.quantization.get_default_qconfig('fbgemm')
torch.quantization.prepare(model, inplace=True)
# Calibration...
torch.quantization.convert(model, inplace=True)

Utilisation de TensorRT pour l'accélération

Exemple

import torch_tensorrt

# Optimisation de la compilation
trt_model = torch_tensorrt.compile(model,
    inputs=[torch_tensorrt.Input((1, 3, 224, 224))],
    enabled_precisions={torch.float32}  # Ou {torch.float16}
)

# Sauvegarder le modèle optimisé
torch.jit.save(trt_model, "model_trt.pt")

FAQ

Q1 : Que dois-je faire si des problèmes de compatibilité de version surviennent lors du déploiement ?R : Il est recommandé d'utiliser des conteneurs Docker pour épingler les versions d'environnement, ou viacondaCréer un environnement dédié.

Q2 : Comment surveiller les performances des modèles déployés ?R : Vous pouvez intégrer des outils de surveillance tels que Prometheus pour suivre la latence, le débit et l'utilisation des ressources.

Q3 : Comment réaliser des mises à jour à chaud après le déploiement du modèle ?R : TorchServe prend en charge la gestion des versions de modèle et les tests A/B, permettant de changer dynamiquement de version de modèle via l'API.

Autres extensions