Préchauffage des services de modèle - Platform For AI - Centre de documentation Alibaba Cloud

Lorsqu'un service de modèle reçoit sa première requête, le runtime peut différer l'initialisation : chargement des fichiers de modèle, compilation JIT des opérations du graphe ou démarrage à froid d'une machine virtuelle Java (JVM). Cette initialisation différée peut entraîner une latence plus élevée ainsi que des erreurs 408 (délai d'attente dépassé) ou 450 lors des premières requêtes.

La fonctionnalité de préchauffage de modèle d'Elastic Algorithm Service (EAS) dans Platform for AI (PAI) élimine cette latence de démarrage à froid. EAS envoie des requêtes de préchauffage au moteur de service avant la mise en production du service de modèle. Le service de modèle est considéré comme entièrement démarré uniquement après l'envoi réussi de ces requêtes de préchauffage.

Fonctionnement

Le flux de préchauffage se déroule comme suit :

Générez un fichier de requête de préchauffage à l'aide d'un SDK EAS.
Téléchargez le fichier vers Object Storage Service (OSS).
Référencez le fichier dans la configuration JSON du service de modèle.
Déployez ou mettez à jour le service : EAS envoie automatiquement les requêtes de préchauffage lors du démarrage.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

Un bucket OSS pour stocker le fichier de requête de préchauffage
Le SDK EAS pour Python ou le SDK pour Java installé
Un service de modèle EAS déployé ou prêt à être déployé

Génération d'un fichier de requête de préchauffage

Un fichier de requête de préchauffage contient une ou plusieurs requêtes d'exemple représentant le trafic de production réel. EAS rejoue ces requêtes lors du démarrage pour initialiser le modèle.

Deux formats de fichier sont pris en charge :

Binaire (.bin) : Pour TensorFlow et autres modèles avec entrées structurées. Généré à l'aide du SDK EAS.
Texte (.txt) : Pour les modèles avec entrées sous forme de chaîne. Chaque ligne correspond à une requête. EAS détecte automatiquement le format.

Important

Les entrées et sorties de la requête de préchauffage doivent correspondre exactement à celles utilisées en production. Toute différence au niveau des entrées ou des sorties entraîne le rechargement des fichiers de modèle par TensorFlow, ce qui annule l'objectif du préchauffage.

Les exemples suivants montrent comment créer un fichier de requête de préchauffage .bin pour un modèle TensorFlow.

Utilisation du SDK pour Python

#!/usr/bin/env python

from eas_prediction import TFRequest

# Build a warm-up request that matches your production request exactly.
# The inputs and outputs must be identical to those used after the service goes live.
req = TFRequest('serving_default')
req.add_feed('sentence1', [200, 15], TFRequest.DT_INT32, [1] * 200 * 15)
req.add_feed('sentence2', [200, 15], TFRequest.DT_INT32, [1] * 200 * 15)
req.add_feed('y', [200, 2], TFRequest.DT_INT32, [2] * 200 * 2)
req.add_feed('keep_rate', [], TFRequest.DT_FLOAT, [0.2])
req.add_feed('images', [1, 784], TFRequest.DT_FLOAT, [1] * 784)
req.add_fetch('sorted_labels')
req.add_fetch('sorted_probs')

# Save the warm-up request to a binary file.
with open("warm_up.bin", "wb") as fw:
    fw.write(req.to_string())

Utilisation du SDK pour Java

Ajoutez la dépendance eas-sdk à votre fichier pom.xml :

<dependency>
  <groupId>com.aliyun.openservices.eas</groupId>
  <artifactId>eas-sdk</artifactId>
  <version>2.0.13</version>
</dependency>

Consultez le dépôt Maven pour obtenir la dernière version.

import java.io.File;
import com.aliyun.openservices.eas.predict.request.TFDataType;
import com.aliyun.openservices.eas.predict.request.TFRequest;
import org.apache.commons.io.FileUtils;

public class TestTf {

    public static void main(String[] args) throws Exception {
        // Build a warm-up request that matches your production request exactly.
        TFRequest request = new TFRequest();
        request.setSignatureName("predict_images");

        float[] content = new float[784];
        for (int i = 0; i < content.length; i++) {
            content[i] = (float) 0.0;
        }
        request.addFeed("images", TFDataType.DT_FLOAT, new long[]{1, 784}, content);
        request.addFetch("scores");

        // Write the request to a binary file.
        File writename = new File("/path/to/warm_up1.bin");
        FileUtils.writeByteArrayToFile(writename, request.getRequest().toByteArray());
    }
}

Remplacez /path/to/warm_up1.bin par le chemin réel où vous souhaitez enregistrer le fichier.

Vérification du fichier de requête

Avant de télécharger le fichier vers OSS, vérifiez qu'il produit une réponse valide.

Envoi d'une requête de test avec curl

curl --data-binary @"</path/to/warmup.bin>" \
  -H 'Authorization: <your-token>' \
  <service-address>

Espace réservé	Description
`</path/to/warmup.bin>`	Chemin d'accès au fichier de requête de préchauffage
`<your-token>`	Jeton utilisé pour accéder au service de modèle
`<service-address>`	Endpoint du service de modèle

Si la réponse est trop volumineuse pour s'afficher dans le terminal, ajoutez --output <file-path> pour l'enregistrer dans un fichier.

Analyse directe du fichier

Utilisez cette méthode pour inspecter le contenu de la requête sans avoir besoin d'un service en cours d'exécution.

Python

from eas_prediction import TFRequest

req = TFRequest()
with open('/path/to/warm_up1.bin', 'rb') as wm:
    req.request_data.ParseFromString(wm.read())
    print(req.request_data)

Java

import com.aliyun.openservices.eas.predict.proto.PredictProtos;
import org.apache.commons.io.FileUtils;
import java.io.File;

public class Test {

    public static void main(String[] args) throws Exception {
        File refile = new File("/path/to/warm_up1.bin");
        byte[] data = FileUtils.readFileToByteArray(refile);
        PredictProtos.PredictRequest pb = PredictProtos.PredictRequest.parseFrom(data);
        System.out.println(pb);
    }
}

Configuration et déploiement du service de modèle

Téléchargez le fichier de requête de préchauffage vers OSS.

Ajoutez les paramètres de préchauffage à la configuration JSON du service de modèle :

{
    "name": "warm_up_demo",
    "model_path": "oss://path/to/model",
    "warm_up_data_path": "oss://path/to/warm_up_test.bin",
    "processor": "tensorflow_cpu_1.15",
    "metadata": {
        "cpu": 2,
        "instance": 1,
        "rpc": {
            "warm_up_count": 5
        }
    }
}

Paramètre	Description	Valeur par défaut
`warm_up_data_path`	Chemin OSS du fichier de requête de préchauffage. EAS localise et utilise ce fichier automatiquement lors du démarrage.	—
`warm_up_count`	Nombre d'envois de chaque requête de préchauffage.	`5`

Pour tous les autres paramètres de configuration, consultez la rubrique Paramètres des services de modèle.

Déployez ou mettez à jour le service de modèle. Pour plus de détails, consultez les rubriques Création d'un service et Modification d'un service.

EAS envoie les requêtes de préchauffage lors du démarrage. Le service de modèle est considéré comme entièrement démarré uniquement après la réussite de toutes les requêtes de préchauffage.

FAQ

Pourquoi mon modèle TensorFlow recharge-t-il toujours les fichiers après le préchauffage ?

Problème

Dans les scénarios commerciaux réels, la mise à jour des modèles TensorFlow peut entraîner une instabilité du service. Même avec l'ajout de la fonctionnalité de préchauffage au processeur, ce problème peut persister. Chaque signature d'entrée-sortie distincte peut amener le modèle à recharger les fichiers pour le préchauffage.

Cause

Ce problème survient car la fonction TensorFlow session->Run(inputs, output_tensor_names, {}, &outputs) effectue une validation de hachage sur les entrées et les output_tensor_names. Si les entrées ou les sorties changent, cela déclenche un rechargement.

Par exemple, considérons un modèle TensorFlow avec les entrées et sorties suivantes :

Inputs:
  threshold: []; DT_FLOAT
  model_id: []; DT_STRING
  input_holder: [-1]; DT_STRING

Outputs:
  model_version_id: []; DT_STRING
  sorted_labels: [-1, 3]; DT_STRING
  sorted_probs: [-1, 3]; DT_FLOAT

Si la requête de préchauffage récupère uniquement sorted_labels et sorted_probs :

request.addFeed("input_holder", TFDataType.DT_STRING, new long[]{1}, input);
request.addFeed("threshold", TFDataType.DT_FLOAT, new long[] {}, th);
request.addFeed("model_id", TFDataType.DT_STRING, new long[]{}, model_name);

request.addFetch("sorted_labels");
request.addFetch("sorted_probs");

Mais les requêtes de production récupèrent également model_version_id :

request.addFeed("input_holder", TFDataType.DT_STRING, new long[]{1}, input);
request.addFeed("threshold", TFDataType.DT_FLOAT, new long[] {}, th);
request.addFeed("model_id", TFDataType.DT_STRING, new long[]{}, model_name);

request.addFetch("sorted_labels");
request.addFetch("sorted_probs");
request.addFetch("model_version_id"); // An additional output is fetched.

Cette sortie supplémentaire modifie le hachage, provoquant un rechargement même après le préchauffage.

Solution

Chaque service doit utiliser de véritables requêtes commerciales pour le préchauffage. Téléchargez un fichier de préchauffage construit à partir d'une requête de production réelle, avec exactement les mêmes entrées et sorties. Il suffit que session->Run s'exécute avec succès une fois avec une requête correspondante : un seul fichier de préchauffage est nécessaire.

Étapes suivantes

SDK : Découvrez comment utiliser les SDK EAS pour construire et envoyer des requêtes.
Paramètres des services de modèle : Explorez l'ensemble complet des paramètres de déploiement JSON.