Todos los productos
Search

Este producto

    Platform For AI:Develop a custom processor using Python

    Centro de documentos

    Platform For AI:Develop a custom processor using Python

    Última actualización: Sep 22, 2026

    Desarrolle y depure un procesador de Python personalizado. Después, cárguelo junto con su archivo de modelo a OSS para el despliegue del servicio.

    Flujo de trabajo

    Para desarrollar un procesador de Python personalizado, complete los siguientes pasos:

    1. Step 1: Set up the development environment

      El SDK de Python de EAS es compatible con diversos frameworks de aprendizaje automático en Python. Además, se integra con frameworks de procesamiento de datos como Pandas. Configure un entorno local de Python, desarrolle los procesadores personalizados y, por último, empaquete y cargue el entorno.

    2. Step 2: Write the prediction logic

      El SDK de Python de EAS proporciona un framework RPC de alto rendimiento e interfaces internas para interactuar con el clúster de EAS. Escriba la lógica de predicción e implemente una interfaz sencilla para desplegar su servicio de modelo en EAS.

    3. Step 3: Test the service locally

      Pruebe el servicio de forma local para comprobar que la lógica de predicción sea correcta. Así garantiza que el servicio funcione según lo esperado tras el despliegue.

    4. Step 4: Package the code and Python environment

      Empaquete el código y el entorno para el despliegue del servicio.

    5. Step 5: Upload the processor package and model file

      Cargue por separado el paquete y los archivos de modelo a Object Storage Service (OSS).

    6. Step 6: Deploy and test the service

      Despliegue su procesador personalizado como un servicio de modelo y compruebe que funcione correctamente.

    Nota

    • Separe el archivo de modelo del procesador para reutilizar el paquete del procesador cuando aplique fine-tune y vuelva a desplegar el modelo. En la lógica de predicción, utilice el método get_model_path() para obtener la ruta de almacenamiento del modelo. De este modo, la lógica podrá cargarlo.

    • Si su procesador personalizado tiene muchas dependencias o genera un paquete muy grande, utilice una imagen para desplegar el servicio. Para comparar ambos métodos de despliegue, consulte How it works (Image deployment).

    Requisitos previos

    Prepare un archivo de modelo.

    Nota

    Desarrolle el archivo de modelo y el procesador personalizado por separado. Cárguelos a OSS de forma individual para poder montarlos durante el despliegue del servicio.

    Paso 1: Configuración del entorno de desarrollo

    Utilice herramientas de gestión de paquetes de Python, como Pyenv, para configurar un entorno de desarrollo. EAS proporciona la herramienta cliente EASCMD, la cual encapsula el proceso de inicialización del SDK de Python. Tras descargar la herramienta, ejecute un solo comando para inicializar el entorno del SDK de Python y generar las plantillas de archivos. EASCMD solo es compatible con Linux. A continuación se muestra un ejemplo:

    # Install and initialize EASCMD. This example shows how to install the EASCMD client for Linux.
$ wget https://eas-data.oss-cn-shanghai.aliyuncs.com/tools/eascmd/v2/eascmd64
# After the download is complete, modify the access permissions and configure your Alibaba Cloud AccessKey pair.
$ chmod +x eascmd64
$ ./eascmd64 config -i <access_id> -k <access_key>

# Initialize the environment.
$ ./eascmd64 pysdk init ./pysdk_demo

    Cuando el sistema lo solicite, introduzca una versión de Python (la versión predeterminada es la 3.6). El sistema creará un directorio de entorno de Python llamado ENV, una plantilla de código de servicio de predicción llamada app.py y una plantilla de despliegue de servicio llamada app.json dentro del directorio ./pysdk_demo.

    Paso 2: Escritura de la lógica de predicción

    En el mismo directorio que ENV, cree el archivo principal del servicio de predicción con el nombre app.py. Por ejemplo:

    Nota

    Si utiliza EASCMD para inicializar el entorno de Python, el archivo app.py se genera automáticamente. Modifique el contenido del archivo según sus necesidades.

    # -*- coding: utf-8 -*-
import allspark

class MyProcessor(allspark.BaseProcessor):
    """ MyProcessor is an example
        you can send mesage like this to predict
        curl -v http://127.0.0.1:8080/api/predict/service_name -d '2 105'
    """
    def initialize(self):
        """ load module, executed once at the start of the service
             do service initialization and load models in this function.
        """
        self.module = {'w0': 100, 'w1': 2}
        # model_dir = self.get_model_path().decode()
        # You must implement the load_model function yourself. For example, to load a model.pt file, you can implement it as torch.load(model_dir + "/model.pt").
        # self.model = load_model(model_dir)

    def pre_process(self, data):
        """ data format pre process
        """
        x, y = data.split(b' ')
        return int(x), int(y)

    def post_process(self, data):
        """ process after process
        """
        return bytes(data, encoding='utf8')

    def process(self, data):
        """ process the request data
        """
        x, y = self.pre_process(data)
        w0 = self.module['w0']
        w1 = self.module['w1']
        y1 = w1 * x + w0
        if y1 >= y:
            return self.post_process("True"), 200
        else:
            return self.post_process("False"), 400

if __name__ == '__main__':
    # allspark.default_properties().put('rpc.keepalive', '10000')
    # Set the service timeout to 10s. The default is 5s.
    # The worker_threads parameter indicates the processing concurrency.
    runner = MyProcessor(worker_threads=10)
    runner.run()

    Este ejemplo hereda la clase base BaseProcessor proporcionada por EAS e implementa las funciones initialize() y process().

    Método

    Descripción

    Uso

    initialize()

    Método de inicialización del procesador. Ejecuta tareas de inicialización, como la carga del modelo, cuando se inicia el servicio.

    Agregue el siguiente código a initialize() para separar la obtención del archivo de modelo de la implementación del procesador.

    model_dir = self.get_model_path().decode()
    self.model = load_model(model_dir)

    • get_model_path() devuelve el directorio de almacenamiento del archivo de modelo como un objeto bytes. Este es el directorio de almacenamiento real del archivo de modelo cargado en la instancia de servicio.

    • Implemente una función load_model() para cargar el archivo de modelo. Por ejemplo, si necesita cargar un archivo model.pt, implemente la función como torch.load(model_dir + "/model.pt").

    get_model_path()

    Devuelve el directorio de almacenamiento del archivo de modelo como un objeto bytes.

    Cuando se especifica el parámetro model_path en el JSON de despliegue, llame a get_model_path() para recuperar el directorio de almacenamiento del modelo dentro de la instancia de servicio y cargarlo.

    process(data)

    Método de manejo de solicitudes. Para cada solicitud, el cuerpo de la petición se pasa a process(). El valor devuelto se envía al cliente.

    data: cuerpo de la solicitud, de tipo BYTES. Los valores de retorno son BYTES e INT, que corresponden a response_data y status_code. Para una solicitud normal, status_code puede ser 0 o 200.

    _init_(worker_threads=5, worker_processes=1,endpoint=None)

    Constructor del procesador.

    • worker_threads: número de hilos de trabajo. Valor predeterminado: 5.

    • worker_processes: número de procesos. Valor predeterminado: 1. Si se establece en 1, el servicio se ejecuta en modo de un solo proceso y varios hilos. Si es mayor que 1, worker_threads solo lee datos y varios procesos manejan las solicitudes de forma concurrente. Cada proceso ejecuta initialize().

    • endpoint: dirección y puerto en los que escucha el servicio. Por ejemplo: endpoint='0.0.0.0:8079'.

      Nota

      No utilice los puertos 8080 ni 9090, ya que están reservados por EAS.

    run()

    Inicia el servicio.

    Ninguna.

    Paso 3: Prueba local del servicio

    1. En el directorio que contiene app.py, ejecute el siguiente comando para iniciar la aplicación.

      ./ENV/bin/python app.py

      Salida esperada si la ejecución es correcta:

      [INFO] waiting for service initialization to complete...
[INFO] service initialization complete
[INFO] create service
[INFO] rpc binds to predefined port 8080
[INFO] install builtin handler call to /api/builtin/call
[INFO] install builtin handler eastool to /api/builtin/eastool
[INFO] install builtin handler monitor to /api/builtin/monitor
[INFO] install builtin handler ping to /api/builtin/ping
[INFO] install builtin handler prop to /api/builtin/prop
[INFO] install builtin handler realtime_metrics to /api/builtin/realtime_metrics
[INFO] install builtin handler tell to /api/builtin/tell
[INFO] install builtin handler term to /api/builtin/term
[INFO] Service start successfully

    2. Abra una nueva terminal y ejecute el siguiente comando para probar la aplicación.

      Con base en el código de ejemplo de Step 2, envíe datos de solicitud a la aplicación. El resultado devuelto refleja la lógica del código.

      curl http://127.0.0.1:8080/test  -d '10 20'

    Paso 4: Empaquetado del código y del entorno

    EASCMD ofrece un comando de empaquetado en un solo paso. Si no utiliza EASCMD, empaquete el entorno manualmente. A continuación se describen ambos métodos.

    • Comando de empaquetado de EASCMD (solo para Linux):

      $ ./eascmd64 pysdk pack ./pysdk_demo

      Salida esperada si la ejecución es correcta:

      [PYSDK] Creating package: /home/xi****.lwp/code/test/pysdk_demo.tar.gz

    • Empaquetado manual

      Requisito

      Detalles

      Formato del paquete

      El paquete debe ser un archivo comprimido en formato .zip o .tar.gz.

      Contenido del paquete

    Paso 5: Carga del paquete y de los archivos de modelo

    Cargue por separado el archivo del paquete (.zip o .tar.gz) y el archivo de modelo a OSS. Esto permite montarlos durante el despliegue del servicio. Para más información, consulte Quick start for ossutil.

    Paso 6: Despliegue y prueba del servicio

    Despliegue el servicio de modelo mediante PAI console o EASCMD.

    1. Despliegue el servicio.

      PAI console

      1. Inicie sesión en PAI console. Seleccione una región en la parte superior de la página. Luego, seleccione el espacio de trabajo deseado y haga clic en Enter Elastic Algorithm Service (EAS).

      2. Haga clic en Deploy Service. En la sección Custom Model Deployment, haga clic en Custom Deployment.

      3. En la página Custom Deployment, configure los siguientes parámetros. Para el resto de los parámetros, consulte Custom deployment.

        Parámetro

        Descripción

        Deployment Method

        Seleccione Processor-based Deployment.

        Model Settings

        Para Type, seleccione OSS y elija la ruta de OSS del archivo de modelo.

        Processor Type

        Seleccione Custom Processor.

        Processor Language

        Seleccione python.

        Processor Package

        Para Type, seleccione OSS y elija la ruta de OSS del archivo de paquete del paso anterior.

        Processor Main File

        Introduzca ./app.py.

      4. (Opcional) En la sección Service Configurations, agregue el parámetro data_image y establézcalo con la ruta de la imagen configurada durante el empaquetado.

        Nota

        Este parámetro solo es obligatorio si utilizó una imagen para empaquetar el entorno en Step 4.

      5. Haga clic en Deploy.

      EASCMD

      Despliegue el servicio en Linux:

      1. Descargue y autentique EASCMD. Para más información, consulte Download and authenticate the client.

      2. En el directorio de EASCMD, cree un archivo JSON llamado app.json. Por ejemplo:

        {
  "name": "pysdk_demo",
  "processor_entry": "./app.py",
  "processor_type": "python",
  "processor_path": "oss://examplebucket/exampledirectory/pysdk_demo.tar.gz",
  "model_path": "oss://examplebucket/exampledirectory/model",
  "cloud": {
        "computing": {
            "instance_type": "ecs.c7.large"
        }
  },
  "metadata": {
    "instance": 1,
    }
}

      3. En el directorio que contiene app.json, ejecute el siguiente comando para desplegar el servicio.

        $ ./eascmd64 create app.json

        Salida esperada si la ejecución es correcta:

        [RequestId]: 1202D427-8187-4BCB-8D32-D7096E95B5CA
+-------------------+-------------------------------------------------------------------+
| Intranet Endpoint | http://182848887922****.vpc.cn-beijing.pai-eas.aliyuncs.com/api/predict/pysdk_demo |
|             Token | ZTBhZTY3ZjgwMmMyMTQ5OTgyMTQ5YmM0NjdiMmNiNmJkY2M5ODI0****          |
+-------------------+-------------------------------------------------------------------+
[OK] Waiting task server to be ready
[OK] Fetching processor from [oss://eas-model-beijing/195557026392****/pysdk_demo.tar.gz]
[OK] Building image [registry-vpc.cn-beijing.aliyuncs.com/eas/pysdk_demo_cn-beijing:v0.0.1-20190806082810]
[OK] Pushing image [registry-vpc.cn-beijing.aliyuncs.com/eas/pysdk_demo_cn-beijing:v0.0.1-20190806082810]
[OK] Waiting [Total: 1, Pending: 1, Running: 0]
[OK] Service is running

    2. Pruebe el servicio.

      1. Inicie sesión en PAI console. Seleccione una región en la parte superior de la página. Luego, seleccione el espacio de trabajo deseado y haga clic en Enter Elastic Algorithm Service (EAS).

      2. Busque el servicio de destino y haga clic en Invocation Information en la columna Service Type para obtener el endpoint público y el Token.

      3. Ejecute el siguiente comando para invocar el servicio con el endpoint y el token obtenidos en el paso anterior.

        $ curl <service_url> -H 'Authorization: <token>' -d '10 20'

        Parámetros:

        • <service_url>: endpoint público obtenido en el paso anterior. Por ejemplo: http://182848887922****.vpc.cn-beijing.pai-eas.aliyuncs.com/api/predict/pysdk_demo.

        • <token>: token obtenido en el paso anterior. Por ejemplo: ZTBhZTY3ZjgwMmMyMTQ5OTgyMTQ5YmM0NjdiMmNiNmJkY2M5ODI0****.

        • -d: datos de entrada para el servicio.

    Referencias