Développer des processeurs personnalisés en C ou C++ - Platform For AI

Un processeur personnalisé en C ou C++ implémente la logique de chargement du modèle et de prédiction des requêtes en définissant les fonctions initialize() et process().

Démarrage rapide

Téléchargez le projet pai-prediction-example. Ce projet contient deux processeurs personnalisés :

echo : Renvoie l'entrée utilisateur telle quelle, accompagnée de la liste des fichiers du modèle.
image_classification : Classification de texte mnist, prend en entrée des images mnist jpg et renvoie les catégories de classification d'image.

Le fichier README du projet décrit les méthodes de compilation. Celui situé dans le répertoire de chaque processeur explique comment effectuer un débogage local.

Définition de l'interface

Un processeur personnalisé doit exporter exactement deux fonctions C : initialize() et process(). Toutes deux sont obligatoires, car EAS les appelle à différents moments du cycle de vie du service.

Paramètre	Direction	Description
`model_entry`	Entrée	Correspond au champ `model_entry` du fichier de configuration de déploiement, qui indique le fichier d'entrée du package de modèle. Pour plus d'informations sur ce champ, consultez la section Déploiement JSON. Vous pouvez transmettre un nom de fichier (par exemple, `randomforest.pmml`) ou un répertoire (par exemple, `./model`).
`model_config`	Entrée	Correspond au champ `model_config` du fichier de configuration de déploiement, qui indique les informations de configuration personnalisées du modèle. Pour plus d'informations sur ce champ, consultez la section Déploiement JSON.
`state`	Sortie	Statut du chargement du modèle. Définissez la valeur sur `0` en cas de succès ; toute autre valeur indique un échec du chargement.
Valeur de retour		Pointeur vers le modèle chargé en mémoire. EAS transmet ce pointeur à chaque appel ultérieur de `process()` en tant que `model_buf`.

Paramètre	Direction	Description
`model_buf`	Entrée	Adresse mémoire du modèle renvoyée par `initialize()`.
`input_data`	Entrée	Charge utile de la requête. Peut être une chaîne de caractères ou des données binaires.
`input_size`	Entrée	Longueur des données d'entrée.
`output_data`	Sortie	Données renvoyées par le processeur. Allouez la mémoire sur le tas (heap). Le modèle est responsable de la libération de cette mémoire.
`output_size`	Sortie	Longueur des données de sortie.
Valeur de retour		Code d'état HTTP de la réponse. Renvoyez `0` ou `200` en cas de succès.

Les valeurs de retour qui ne correspondent pas à des codes d'état HTTP reconnus sont automatiquement converties en HTTP 400. Utilisez toujours un code d'état HTTP standard (par exemple, 400 ou 500 ) lors du renvoi d'une erreur.

Exemple d'utilisation

Voici un exemple d'utilisation simple. Le code de prédiction en ligne ne charge aucune donnée de modèle et renvoie l'entrée utilisateur au client telle quelle.

Écrivez le code de prédiction.

#include <stdio.h>
#include <string.h>
extern "C" {
    void *initialize(const char *model_entry, const char *model_config, int *state)
    {
       *state = 0;
        return NULL;
    }
    int process(void *model_buf, const void *input_data, int input_size,
            void **output_data, int *output_size)
    {
        if (input_size == 0) {
            const char *errmsg = "input data should not be empty";
            *output_data = strdup(errmsg);
            *output_size = strlen(errmsg);
            return 400;
        }  
        *output_data = strdup((char *)input_data);
        *output_size = input_size;
        return 200;
    }
}

Compilez le code dans un fichier .so à l'aide du Makefile suivant.

CC=g++
CCFLAGS=-I./ -D_GNU_SOURCE -Wall -g -fPIC
LDFLAGS= -shared -Wl,-rpath=./
OBJS=processor.o
TARGET=libpredictor.so
all: $(TARGET)
$(TARGET): $(OBJS)
	$(CC) -o $(TARGET) $(OBJS) $(LDFLAGS) -L./
%.o: %.cc
	$(CC) $(CCFLAGS) -c $< -o $@
clean:
	rm -f $(TARGET) $(OBJS)

Déployez le service sur EAS. La configuration de déploiement JSON doit inclure les champs suivants liés au processeur. processor_entry spécifie le fichier principal du processeur, qui correspond au fichier .so produit à l'étape précédente.

{
    "name": "test_echo",
    "model_path": "http://*****.oss-cn-shanghai.aliyuncs.com/****/saved_model.tar.gz",
    "processor_path": "oss://path/to/echo_processor_release.tar.gz",
    "processor_entry": "libpredictor.so",
    "processor_type": "cpp",
    "metadata": {
        "instance": 1
    }
}