Développer des processeurs personnalisés à l'aide de Java - Platform For AI

Cycle de vie du processeur

Un processeur Java est une classe unique comportant trois phases de cycle de vie qu'EAS appelle séquentiellement :

Phase	Méthode	Moment de l'appel	Obligatoire
Initialisation	Constructeur	Une fois au démarrage du service	Oui
Chargement	`Load()`	Une fois après la construction	Oui
Inférence	`Process(byte[] input)`	Une fois par requête entrante	Oui
Test	`main(String[] args)`	Uniquement sur la machine locale	Non

EAS appelle les phases dans l'ordre suivant :

Constructor → Load() → Process() [per request] → ...

Constructeur : reçoit le chemin d'accès au fichier de modèle (modelEntry) et la chaîne JSON de configuration du service (modelConfig) transmise lors du déploiement.
Load() : charge le modèle en mémoire à l'aide des chemins reçus par le constructeur.
Process(byte[] input) : exécute l'inférence pour chaque requête et renvoie le résultat sous forme d'octets.

Implémenter la classe du processeur

Définissez une classe dans le package com.alibaba.eas. Le constructeur, ainsi que les méthodes Load() et Process(), sont obligatoires. La méthode main() est facultative ; elle permet d'effectuer des tests unitaires en local sans déployer sur EAS.

package com.alibaba.eas;
import java.util.*;

public class TestProcessor {

    // Called once at startup.
    // modelEntry: path to the model file (local or HTTP URL).
    // modelConfig: the service configuration JSON string passed at deploy time.
    public TestProcessor(String modelEntry, String modelConfig) {
    }

    // Load the model into memory. Called once after construction.
    public void Load() {
    }

    // Run inference. Accepts raw bytes; returns raw bytes.
    // Use byte[] instead of String to avoid character encoding issues.
    public byte[] Process(byte[] input) {
    }

    // Optional: test the class locally without deploying to EAS.
    public static void main(String[] args) {
    }
}

Types d'entrée et de sortie pris en charge

La méthode Process() prend en charge les types byte[] et String. Privilégiez byte[] afin d'éviter les problèmes d'encodage des caractères.

Gérer les exceptions

Si Process() lève une exception non interceptée, EAS la capture et renvoie le message d'erreur au client avec le code d'état HTTP 400.

Pour renvoyer un message d'erreur personnalisé, interceptez l'exception au sein de Process() et levez une RuntimeException contenant le message destiné au client :

try {
    // inference logic
} catch (com.alibaba.fastjson.JSONException e) {
    throw new RuntimeException("bad json format, " + e.getMessage());
}

Déboguer en local avec le mode autonome

Le mode autonome vous permet de développer et de tester votre processeur sur une machine locale sans le déployer sur un cluster. Les interfaces locales sont entièrement compatibles avec l'environnement de cluster en ligne, ce qui vous permet de valider votre processeur avant le déploiement.

Remarque

Le mode autonome nécessite Docker. Si votre modèle requiert un GPU, installez également CUDA et Nvidia-Docker sur la machine locale.

Prérequis

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

Docker installé sur la machine où vous exécutez EASCMD.
(Pour les modèles GPU) CUDA et Nvidia-Docker installés.

Le client EASCMD téléchargé pour votre système d'exploitation :

Plateforme	Lien de téléchargement
Windows 64 bits	`http://eas-data.oss-cn-shanghai.aliyuncs.com/tools/eascmdwin64`
Linux 32 bits	`http://eas-data.oss-cn-shanghai.aliyuncs.com/tools/eascmd32`
Linux 64 bits	`http://eas-data.oss-cn-shanghai.aliyuncs.com/tools/eascmd64`
macOS 64 bits	`http://eas-data.oss-cn-shanghai.aliyuncs.com/tools/eascmdmac64`

Exécuter le débogage en mode autonome

Créez un fichier de configuration de service (par exemple, service.json) :

{
  "name": "diy_test",
  "generate_token": "true",
  "model_path": "http://examplebucket.oss-cn-hangzhou-zmf.aliyuncs.com/scorecard.pmml",
  "processor_path": "./diy_processor_release.tar.gz",
  "processor_mainclass": "com.alibaba.eas.TestProcessor",
  "processor_type": "java",
  "metadata": {
    "resource": "eas-r-9lkbl2jvdm0puv****",
    "instance": 1,
    "cpu": 1,
    "memory": 2000
  }
}

Paramètres clés :

Paramètre	Description
`model_path`	URL HTTP ou chemin d'accès local vers le fichier de modèle. Les chemins d'accès locaux sont pris en charge uniquement en mode autonome.
`processor_path`	URL HTTP ou chemin d'accès local vers le package du processeur. Le package est une archive `.tar.gz` qui s'extrait en un fichier JAR compilé. Les chemins d'accès locaux sont pris en charge uniquement en mode autonome.
`processor_mainclass`	Nom complet de la classe qui implémente `Load()` et `Process()`.
`processor_type`	Définissez cette valeur sur `java` pour les processeurs Java.
`metadata.resource`	ID du groupe de ressources pour un groupe de ressources dédié.
`metadata.instance`	Nombre d'instances de service.
`metadata.cpu`	Nombre de cœurs CPU par instance.
`metadata.memory`	Mémoire par instance, en Mo.

Pour consulter la référence complète des paramètres, voir Exécuter des commandes pour utiliser le client EASCMD.

Exécutez le test en mode autonome :
```
sudo eascmd test service.json
```