Todos os produtos
Search

Este produto

    Platform For AI:Desenvolver um processador personalizado usando Python

    Central de documentação

    Platform For AI:Desenvolver um processador personalizado usando Python

    Última atualização: Jun 27, 2026

    Desenvolva e depure um processador Python personalizado e envie-o com o arquivo do modelo para o OSS para implantar o serviço.

    Fluxo de trabalho

    Desenvolva um processador Python personalizado seguindo estas etapas:

    1. Etapa 1: Configurar o ambiente de desenvolvimento

      O SDK Python do EAS oferece suporte a diversos frameworks de machine learning em Python e integra-se a frameworks de processamento de dados, como o Pandas. Configure um ambiente Python local, desenvolva processadores personalizados e, em seguida, empacote e envie o ambiente.

    2. Etapa 2: Escrever a lógica de previsão

      O SDK Python do EAS fornece um framework RPC de alto desempenho e interfaces internas para interação com o cluster do EAS. Escreva a lógica de previsão e implemente uma interface simples para implantar seu serviço de modelo no EAS.

    3. Etapa 3: Testar o serviço localmente

      Teste o serviço localmente para verificar se a lógica de previsão está correta e se o serviço funciona conforme o esperado após a implantação.

    4. Etapa 4: Empacotar o código e o ambiente Python

      Empacote o código e o ambiente para implantar o serviço.

    5. Etapa 5: Enviar o pacote do processador e o arquivo do modelo

      Envie o pacote e os arquivos do modelo separadamente para o Object Storage Service (OSS).

    6. Etapa 6: Implantar e testar o serviço

      Implante seu processador personalizado como um serviço de modelo e verifique se ele funciona corretamente.

    Nota

    • Separe o arquivo do modelo do processador para reutilizar o pacote do processador ao ajustar e reimplantar o modelo. Na lógica de previsão, use o método get_model_path() para obter o caminho de armazenamento do modelo e permitir que a lógica o carregue.

    • Se o processador personalizado tiver muitas dependências ou um pacote grande, use uma imagem para implantar o serviço. Para comparar os dois métodos de implantação, consulte Como funciona (Implantação por imagem).

    Pré-requisitos

    Prepare um arquivo de modelo.

    Nota

    Desenvolva o arquivo do modelo e o processador personalizado separadamente. Envie-os para o OSS de forma independente para que possam ser montados durante a implantação do serviço.

    Etapa 1: Configurar o ambiente de desenvolvimento

    Use ferramentas de gerenciamento de pacotes Python, como o Pyenv, para configurar um ambiente de desenvolvimento. O EAS fornece a ferramenta cliente EASCMD, que encapsula o processo de inicialização do SDK Python. Após baixar a ferramenta, execute um único comando para inicializar o ambiente do SDK Python e gerar modelos de arquivos. O EASCMD oferece suporte apenas ao Linux. Exemplo:

    # 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

    Quando solicitado, insira uma versão do Python (padrão: 3,6). O sistema cria então um diretório de ambiente Python chamado ENV, um modelo de código de serviço de previsão chamado app.py e um modelo de implantação de serviço chamado app.json no diretório ./pysdk_demo.

    Etapa 2: Escrever a lógica de previsão

    No mesmo diretório do ENV, crie o arquivo principal para o serviço de previsão, denominado app.py. Exemplo:

    Nota

    Se você usar o EASCMD para inicializar o ambiente Python, o arquivo app.py será gerado automaticamente. Modifique o conteúdo do arquivo conforme necessário.

    # -*- 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 exemplo herda a classe base BaseProcessor fornecida pelo EAS e implementa as funções initialize() e process().

    Método

    Descrição

    Uso

    initialize()

    Método de inicialização do processador. Executa tarefas de inicialização, como carregar o modelo quando o serviço é iniciado.

    Adicione o seguinte código a initialize() para separar a recuperação do arquivo do modelo da implementação do processador.

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

    • get_model_path() retorna o diretório de armazenamento do arquivo do modelo como um objeto bytes. Este é o diretório de armazenamento real do arquivo do modelo carregado na instância de serviço.

    • Implemente uma função load_model() para carregar o arquivo do modelo. Por exemplo, para carregar um arquivo model.pt, implemente a função como torch.load(model_dir + "/model.pt").

    get_model_path()

    Retorna o diretório de armazenamento do arquivo do modelo como um objeto bytes.

    Quando o parâmetro model_path for especificado no JSON de implantação, chame get_model_path() para recuperar o diretório de armazenamento do modelo dentro da instância de serviço para carregamento.

    process(data)

    Método de tratamento de requisições. Para cada requisição, o corpo da requisição é passado para process(). O valor retornado é enviado ao cliente.

    data: Corpo da requisição, tipo BYTES. Os valores de retorno são BYTES e INT, correspondendo a response_data e status_code. Para uma requisição normal, status_code pode ser 0 ou 200.

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

    Construtor do processador.

    • worker_threads: Número de threads de trabalho. Valor padrão: 5.

    • worker_processes: Número de processos. Valor padrão: 1. Se definido como 1, o serviço executa no modo de processo único e multithread. Se maior que 1, worker_threads apenas lê dados, e múltiplos processos tratam as requisições simultaneamente. Cada processo executa initialize().

    • endpoint: Endereço e porta nos quais o serviço escuta. Exemplo: endpoint='0.0.0.0:8079'.

      Nota

      Não use as portas 8080 ou 9090, pois são reservadas pelo EAS.

    run()

    Inicia o serviço.

    Nenhum.

    Etapa 3: Testar o serviço localmente

    1. No diretório que contém o arquivo app.py, execute o seguinte comando para iniciar a aplicação.

      ./ENV/bin/python app.py

      Saída esperada em caso de sucesso:

      [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 um novo terminal e execute o seguinte comando para testar a aplicação.

      Com base no código de exemplo na Etapa 2, envie dados de requisição para a aplicação. O resultado retornado reflete a lógica do código.

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

    Etapa 4: Empacotar o código e o ambiente

    O EASCMD fornece um comando de empacotamento em uma única etapa. Se você não estiver usando o EASCMD, empacote o ambiente manualmente. Ambos os métodos estão descritos abaixo.

    • Comando de empacotamento do EASCMD (apenas Linux):

      $ ./eascmd64 pysdk pack ./pysdk_demo

      Saída esperada em caso de sucesso:

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

    • Empacotamento manual

      Requisito

      Detalhes

      Formato do pacote

      O pacote deve ser um arquivo compactado no formato .zip ou .tar.gz.

      Conteúdo do pacote

    Etapa 5: Enviar o pacote e os arquivos do modelo

    Envie o arquivo do pacote (.zip ou .tar.gz) e o arquivo do modelo para o OSS separadamente para montagem durante a implantação do serviço. Para mais informações, consulte Início rápido para ossutil.

    Etapa 6: Implantar e testar o serviço

    Implante o serviço de modelo usando o PAI console ou o EASCMD.

    1. Implante o serviço.

      PAI console

      1. Faça logon no PAI console. Selecione uma região na parte superior da página. Em seguida, selecione o workspace desejado e clique em Elastic Algorithm Service (EAS).

      2. Clique em Deploy Service. Na seção Custom Model Deployment, clique em Custom Deployment.

      3. Na página Custom Deployment, configure os seguintes parâmetros. Para outros parâmetros, consulte Implantação personalizada.

        Parâmetro

        Descrição

        Deployment Method

        Selecione Processor-based Deployment.

        Model Settings

        Para Type, selecione OSS e escolha o caminho do OSS onde está o arquivo do modelo.

        Processor Type

        Selecione Custom Processor.

        Processor Language

        Selecione python.

        Processor Package

        Para Type, selecione OSS e escolha o caminho do OSS do arquivo de pacote da etapa anterior.

        Processor Main File

        Insira ./app.py.

      4. (Opcional) Na seção Service Configurations, adicione o parâmetro data_image e defina-o como o caminho da imagem configurado durante o empacotamento.

        Nota

        Este parâmetro é necessário apenas se você usou uma imagem para empacotar o ambiente na Etapa 4.

      5. Clique em Deploy.

      EASCMD

      Implante o serviço no Linux:

      1. Baixe e autentique o EASCMD. Para mais informações, consulte Baixar e autenticar o cliente.

      2. No diretório do EASCMD, crie um arquivo JSON chamado app.json. Exemplo:

        {
  "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. No diretório que contém o arquivo app.json, execute o seguinte comando para implantar o serviço.

        $ ./eascmd64 create app.json

        Saída esperada em caso de sucesso:

        [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. Teste o serviço.

      1. Faça logon no PAI console. Selecione uma região na parte superior da página. Em seguida, selecione o workspace desejado e clique em Elastic Algorithm Service (EAS).

      2. Localize o serviço de destino e clique em Invocation Information na coluna Service Type para obter o endpoint público e o Token.

      3. Execute o seguinte comando para chamar o serviço com o endpoint e o token obtidos na etapa anterior.

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

        Parâmetros:

        • <service_url>: Endpoint público da etapa anterior. Exemplo: http://182848887922****.vpc.cn-beijing.pai-eas.aliyuncs.com/api/predict/pysdk_demo.

        • <token>: Token da etapa anterior. Exemplo: ZTBhZTY3ZjgwMmMyMTQ5OTgyMTQ5YmM0NjdiMmNiNmJkY2M5ODI0****.

        • -d: Dados de entrada para o serviço.

    Referências