Tous les produits
Search

Ce produit

    Alibaba Cloud Service Mesh:Deploy a transformer with InferenceService

    Centre de documentation

    Alibaba Cloud Service Mesh:Deploy a transformer with InferenceService

    Dernière mise à jour :Aug 11, 2026

    Lorsque votre serveur de modèles attend des entrées prétraitées (des tenseurs plutôt que des images brutes en Base64, par exemple), un transformateur assure l'interface. Il exécute séquentiellement trois gestionnaires au sein d'une seule InferenceService :

    1. Le gestionnaire preprocess convertit l'entrée brute au format attendu par le modèle (par exemple, en décodant une image Base64 en tenseurs).

    2. Le prédicteur reçoit les données traitées pour effectuer l'inférence.

    3. La réponse du prédicteur transite par le gestionnaire postprocess avant d'être renvoyée au client.

    Par défaut, le transformateur communique avec le prédicteur via REST.

    Prérequis

    Avant de commencer, vérifiez que vous disposez des éléments suivants :

    • Un environnement KServe fonctionnel sur Service Mesh (ASM). Pour les instructions de configuration, consultez Intégrer KServe à ASM

    • kubectl configuré pour accéder à votre cluster

    • (Facultatif) Docker installé, si vous prévoyez de construire une image de transformateur personnalisée

    • (Facultatif) Accès à un registre de conteneurs, si vous prévoyez de pousser des images personnalisées

    Remarque

    Ce tutoriel utilise KServe 0.10. Les formats de données d'entrée requis peuvent varier selon la version. Pour la documentation de référence amont, consultez Déployer un transformateur avec InferenceService.

    Créer une image Docker de transformateur

    Choisissez l'une des méthodes suivantes :

    Méthode Cas d'utilisation
    Construction depuis les sources Vous devez personnaliser la logique du transformateur
    Image préconstruite Vous souhaitez utiliser le transformateur d'image par défaut sans modifications

    Construction depuis les sources

    Construisez l'image à partir du répertoire kserve/python dans le dépôt GitHub KServe :

    cd python
docker build -t <your-registry-url>/image-transformer:latest -f custom_transformer.Dockerfile .
docker push <your-registry-url>/image-transformer:latest

    Remplacez <your-registry-url> par l'URL de votre registre de conteneurs, par exemple registry.example.com/ml-models.

    Utiliser l'image préconstruite

    Utilisez directement l'image suivante dans votre fichier YAML InferenceService :

    asm-registry.cn-hangzhou.cr.aliyuncs.com/asm/kserve-image-custom-transformer:0.10

    Déployer InferenceService avec un transformateur

    Par défaut, InferenceService utilise TorchServe pour servir les modèles PyTorch. Cet exemple déploie un classifieur pré-entraîné de chiffres manuscrits MNIST avec un transformateur d'image personnalisé.

    1. Créez un fichier nommé transformer-new.yaml :

      apiVersion: serving.kserve.io/v1beta1
kind: InferenceService
metadata:
  name: torch-transformer
spec:
  predictor:
    model:
      modelFormat:
        name: pytorch
      storageUri: gs://kfserving-examples/models/torchserve/image_classifier/v1
  transformer:
    containers:
      - image: asm-registry.cn-hangzhou.cr.aliyuncs.com/asm/kserve-image-custom-transformer:0.10
        name: kserve-container
        command:
          - "python"
          - "-m"
          - "model"
        args:
          - --model_name
          - mnist
      Champ Description
      spec.predictor.model.storageUri Chemin Google Cloud Storage vers le modèle PyTorch MNIST, servi par TorchServe
      spec.transformer.containers[].image Image du transformateur qui prétraite les données d'image entrantes
      spec.transformer.containers[].args --model_name mnist indique au transformateur le modèle cible

    2. Déployez l'InferenceService :

      kubectl apply -f transformer-new.yaml

    3. Attendez que l'InferenceService soit prête :

      kubectl get inferenceservice torch-transformer

      La colonne READY doit afficher True avant de poursuivre.

    Exécuter une prédiction

    Préparer les données d'entrée

    Encodez une image d'exemple en Base64 et enregistrez-la dans un fichier nommé input.json. L'exemple suivant utilise une image de chiffre manuscrit :

    Sample handwritten digit

    {
    "instances": [
        {
            "image": {
                "b64": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAAw0lEQVR4nGNgGFggVVj4/y8Q2GOR83n+58/fP0DwcSqmpNN7oOTJw6f+/H2pjUU2JCSEk0EWqN0cl828e/FIxvz9/9cCh1zS5z9/G9mwyzl/+PNnKQ45nyNAr9ThMHQ/UG4tDofuB4bQIhz6fIBenMWJQ+7Vn7+zeLCbKXv6z59NOPQVgsIcW4QA9YFi6wNQLrKwsBebW/68DJ388Nun5XFocrqvIFH59+XhBAxThTfeB0r+vP/QHbuDCgr2JmOXoSsAAKK7bU3vISS4AAAAAElFTkSuQmCC"
            }
        }
    ]
}

    Envoyer une requête de prédiction

    1. Récupérez le nom d'hôte du service :

      SERVICE_NAME=torchserve-transformer
SERVICE_HOSTNAME=$(kubectl get inferenceservice $SERVICE_NAME -o jsonpath='{.status.url}' | cut -d "/" -f 3)
echo $SERVICE_HOSTNAME

      Sortie attendue :

      torchserve-transformer.default.example.com

    2. Envoyez une requête via la passerelle d'entrée ASM :

      Pour trouver l'adresse IP de la passerelle d'entrée, consultez Obtenir l'adresse IP de la passerelle d'entrée.

      MODEL_NAME=mnist
INPUT_PATH=@./input.json
ASM_GATEWAY="<ingress-gateway-ip>"  # Replace with your ingress gateway IP address
curl -v -H "Host: ${SERVICE_HOSTNAME}" -d $INPUT_PATH http://${ASM_GATEWAY}/v1/models/$MODEL_NAME:predict

    Vérifier le résultat

    Une réponse réussie renvoie un code HTTP 200 avec une prédiction JSON :

    < HTTP/1.1 200 OK
< content-length: 19
< content-type: application/json
< server: istio-envoy
<
{"predictions":[2]}

    La prédiction [2] signifie que le modèle a classifié l'image d'entrée comme le chiffre 2. Cela confirme que le transformateur a décodé l'image Base64, l'a convertie en tenseurs et l'a transmise au prédicteur MNIST.

    Étapes suivantes