Develop custom processors by using Java - Platform For AI - Centro de documentación de Alibaba Cloud

Cuando los procesadores integrados de Elastic Algorithm Service (EAS) no cubren los requisitos de su modelo, implemente un procesador personalizado en Java para controlar directamente la lógica de inicialización y de inference.

Ciclo de vida del procesador

Un procesador en Java es una sola clase con tres fases de ciclo de vida. EAS las invoca de forma secuencial:

Fase	Método	Momento de invocación	Obligatorio
Initialize	Constructor	Una vez al iniciar el servicio	Sí
Load	`Load()`	Una vez después de la construcción	Sí
Infer	`Process(byte[] input)`	Una vez por cada solicitud entrante	Sí
Test	`main(String[] args)`	Solo en la máquina local	No

EAS invoca las fases en este orden:

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

Constructor: recibe la ruta del archivo del modelo (modelEntry) y la cadena JSON de configuración del servicio (modelConfig) que se pasan durante el despliegue.
Load(): carga el modelo en memoria mediante las rutas que recibió el constructor.
Process(byte[] input): ejecuta la inference en cada solicitud y devuelve el resultado como bytes.

Implementación de la clase del procesador

Defina una clase en el paquete com.alibaba.eas. El constructor, Load() y Process() son obligatorios. El método main() es opcional y resulta útil para ejecutar pruebas unitarias locales sin desplegar en 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) {
    }
}

Tipos de entrada y salida compatibles

El método Process() es compatible con byte[] y String. Utilice byte[] para evitar problemas de codificación de caracteres.

Manejo de excepciones

Si Process() lanza una excepción no controlada, EAS la captura y devuelve el mensaje de error al cliente con el código de estado HTTP 400.

Para devolver un mensaje de error personalizado, capture la excepción dentro de Process() y lance una RuntimeException con el mensaje que desea enviar al cliente:

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

Depuración local con el modo independiente

El modo independiente le permite desarrollar y probar su procesador en una máquina local sin desplegarlo en un clúster. Las interfaces locales son totalmente compatibles con el entorno del clúster en línea, por lo que puede validar el procesador antes del despliegue.

Nota

El modo independiente requiere Docker. Si su modelo necesita una GPU, instale también CUDA y Nvidia-Docker en la máquina local.

Requisitos previos

Antes de empezar, asegúrese de contar con lo siguiente:

Docker instalado en la máquina donde ejecuta EASCMD.
CUDA y Nvidia-Docker instalados (para modelos con GPU).

El cliente EASCMD descargado para su sistema operativo:

Plataforma	Enlace de descarga
Windows 64-bit	`http://eas-data.oss-cn-shanghai.aliyuncs.com/tools/eascmdwin64`
Linux 32-bit	`http://eas-data.oss-cn-shanghai.aliyuncs.com/tools/eascmd32`
Linux 64-bit	`http://eas-data.oss-cn-shanghai.aliyuncs.com/tools/eascmd64`
macOS 64-bit	`http://eas-data.oss-cn-shanghai.aliyuncs.com/tools/eascmdmac64`

Ejecución de la depuración en modo independiente

Cree un archivo de configuración del servicio (por ejemplo, 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
  }
}

Parámetros clave:

Parámetro	Descripción
`model_path`	URL HTTP o ruta local del archivo del modelo. Las rutas locales solo son compatibles con el modo independiente.
`processor_path`	URL HTTP o ruta local del paquete del procesador. Este paquete es un archivo `.tar.gz` que se extrae como un archivo JAR compilado. Las rutas locales solo son compatibles con el modo independiente.
`processor_mainclass`	Nombre completo de la clase que implementa `Load()` y `Process()`.
`processor_type`	Establezca este valor en `java` para los procesadores en Java.
`metadata.resource`	Identificador del resource group dedicado.
`metadata.instance`	Número de instancias del servicio.
`metadata.cpu`	Número de núcleos de CPU por instancia.
`metadata.memory`	Memoria por instancia, en MB.

Para consultar la referencia completa de parámetros, consulte Run commands to use the EASCMD client.

Ejecute la prueba en modo independiente:
```
sudo eascmd test service.json
```