Aquecimento de services de modelo - Platform For AI: Central de Documentação do Alibaba Cloud

Ao receber a primeira requisição, o runtime de um service de modelo pode adiar a inicialização para carregar arquivos de modelo, compilar operações de grafo JIT ou iniciar uma Java Virtual Machine (JVM) a frio. Essa inicialização adiada pode aumentar a latência e causar erros 408 (timeout) ou 450 nas requisições iniciais.

O recurso de aquecimento de modelo do Elastic Algorithm Service (EAS) no Platform for AI (PAI) elimina essa latência de inicialização a frio. O EAS envia requisições de aquecimento ao mecanismo do service antes da entrada em produção. O service de modelo só é considerado totalmente iniciado após o envio bem-sucedido dessas requisições.

Como funciona

Fluxo de aquecimento:

Gere um arquivo de requisição de aquecimento com um SDK do EAS.
Faça upload do arquivo para o Object Storage Service (OSS).
Referencie o arquivo na configuração JSON do service de modelo.
Implante ou atualize o service — o EAS envia as requisições de aquecimento automaticamente durante a inicialização.

Pré-requisitos

Antes de começar, verifique se você tem:

Um bucket do OSS para armazenar o arquivo de requisição de aquecimento
O SDK do EAS para Python ou SDK para Java instalado
Um service de modelo do EAS implantado ou pronto para implantação

Gerar um arquivo de requisição de aquecimento

Um arquivo de requisição de aquecimento contém uma ou mais requisições de exemplo que representam o tráfego real de produção. O EAS reproduz essas requisições durante a inicialização para preparar o modelo.

Há suporte para dois formatos de arquivo:

Binário (.bin): Para TensorFlow e outros modelos com entrada estruturada. Criado com o SDK do EAS.
Texto (.txt): Para modelos com entrada de string. Cada linha corresponde a uma requisição. O EAS detecta o formato automaticamente.

Importante

As entradas e saídas na requisição de aquecimento devem corresponder exatamente às usadas em produção. Qualquer diferença nas entradas ou saídas faz o TensorFlow recarregar os arquivos do modelo, o que anula o propósito do aquecimento.

Os exemplos a seguir mostram como crie um arquivo de requisição de aquecimento .bin para um modelo TensorFlow.

Usar o SDK para Python

#!/usr/bin/env python

from eas_prediction import TFRequest

# Build a warm-up request that matches your production request exactly.
# The inputs and outputs must be identical to those used after the service goes live.
req = TFRequest('serving_default')
req.add_feed('sentence1', [200, 15], TFRequest.DT_INT32, [1] * 200 * 15)
req.add_feed('sentence2', [200, 15], TFRequest.DT_INT32, [1] * 200 * 15)
req.add_feed('y', [200, 2], TFRequest.DT_INT32, [2] * 200 * 2)
req.add_feed('keep_rate', [], TFRequest.DT_FLOAT, [0.2])
req.add_feed('images', [1, 784], TFRequest.DT_FLOAT, [1] * 784)
req.add_fetch('sorted_labels')
req.add_fetch('sorted_probs')

# Save the warm-up request to a binary file.
with open("warm_up.bin", "wb") as fw:
    fw.write(req.to_string())

Usar o SDK para Java

Adicione a dependência eas-sdk ao seu pom.xml:

<dependency>
  <groupId>com.aliyun.openservices.eas</groupId>
  <artifactId>eas-sdk</artifactId>
  <version>2.0.13</version>
</dependency>

Consulte o repositório Maven para obter a versão mais recente.

import java.io.File;
import com.aliyun.openservices.eas.predict.request.TFDataType;
import com.aliyun.openservices.eas.predict.request.TFRequest;
import org.apache.commons.io.FileUtils;

public class TestTf {

    public static void main(String[] args) throws Exception {
        // Build a warm-up request that matches your production request exactly.
        TFRequest request = new TFRequest();
        request.setSignatureName("predict_images");

        float[] content = new float[784];
        for (int i = 0; i < content.length; i++) {
            content[i] = (float) 0.0;
        }
        request.addFeed("images", TFDataType.DT_FLOAT, new long[]{1, 784}, content);
        request.addFetch("scores");

        // Write the request to a binary file.
        File writename = new File("/path/to/warm_up1.bin");
        FileUtils.writeByteArrayToFile(writename, request.getRequest().toByteArray());
    }
}

Substitua /path/to/warm_up1.bin pelo caminho real onde deseja salve o arquivo.

Verificar o arquivo de requisição

Antes de fazer upload do arquivo para o OSS, verifique se ele produz uma resposta válida.

Enviar uma requisição de teste com curl

curl --data-binary @"</path/to/warmup.bin>" \
  -H 'Authorization: <your-token>' \
  <service-address>

Placeholder	Descrição
`</path/to/warmup.bin>`	Caminho para o arquivo de requisição de aquecimento
`<your-token>`	Token usado para acessar o service de modelo
`<service-address>`	Endpoint do service de modelo

Se a resposta for muito grande para exibição no terminal, adicione --output <file-path> para salvá-la em um arquivo.

Analisar o arquivo diretamente

Use este método para inspecionar o conteúdo da requisição sem um service em execução.

Python

from eas_prediction import TFRequest

req = TFRequest()
with open('/path/to/warm_up1.bin', 'rb') as wm:
    req.request_data.ParseFromString(wm.read())
    print(req.request_data)

Java

import com.aliyun.openservices.eas.predict.proto.PredictProtos;
import org.apache.commons.io.FileUtils;
import java.io.File;

public class Test {

    public static void main(String[] args) throws Exception {
        File refile = new File("/path/to/warm_up1.bin");
        byte[] data = FileUtils.readFileToByteArray(refile);
        PredictProtos.PredictRequest pb = PredictProtos.PredictRequest.parseFrom(data);
        System.out.println(pb);
    }
}

Configure e implante o service de modelo

Faça upload do arquivo de requisição de aquecimento para o OSS.

Adicione os parâmetros de aquecimento à configuração JSON do service de modelo:

{
    "name": "warm_up_demo",
    "model_path": "oss://path/to/model",
    "warm_up_data_path": "oss://path/to/warm_up_test.bin",
    "processor": "tensorflow_cpu_1.15",
    "metadata": {
        "cpu": 2,
        "instance": 1,
        "rpc": {
            "warm_up_count": 5
        }
    }
}

Parâmetro	Descrição	Padrão
`warm_up_data_path`	Caminho do OSS para o arquivo de requisição de aquecimento. O EAS localiza e usa esse arquivo automaticamente durante a inicialização.	—
`warm_up_count`	Número de vezes que cada requisição de aquecimento é enviada.	`5`

Para todos os outros parâmetros de configuração, consulte Parameters of model services.

Implante ou atualize o service de modelo. Para mais detalhes, consulte Create a service e Modify a service.

O EAS envia as requisições de aquecimento durante a inicialização. O service de modelo só é considerado totalmente iniciado após o sucesso de todas as requisições de aquecimento.

FAQ

Por que meu modelo TensorFlow ainda recarrega arquivos após o aquecimento?

Problema

Em cenários reais de negócios, a atualização de modelos TensorFlow pode levar à instabilidade do service. Mesmo com o recurso de aquecimento adicionado ao Processor, esse problema pode persistir. Cada assinatura distinta de entrada e saída pode fazer o modelo recarregar arquivos para aquecimento.

Causa

Esse problema ocorre porque a função do TensorFlow session->Run(inputs, output_tensor_names, {}, &outputs) valida o hash das entradas e de output_tensor_names. Alterações nas entradas ou saídas acionam um recarregamento.

Por exemplo, considere um modelo TensorFlow com as seguintes entradas e saídas:

Inputs:
  threshold: []; DT_FLOAT
  model_id: []; DT_STRING
  input_holder: [-1]; DT_STRING

Outputs:
  model_version_id: []; DT_STRING
  sorted_labels: [-1, 3]; DT_STRING
  sorted_probs: [-1, 3]; DT_FLOAT

Se a requisição de aquecimento buscar apenas sorted_labels e sorted_probs:

request.addFeed("input_holder", TFDataType.DT_STRING, new long[]{1}, input);
request.addFeed("threshold", TFDataType.DT_FLOAT, new long[] {}, th);
request.addFeed("model_id", TFDataType.DT_STRING, new long[]{}, model_name);

request.addFetch("sorted_labels");
request.addFetch("sorted_probs");

Mas as requisições de produção também buscam model_version_id:

request.addFeed("input_holder", TFDataType.DT_STRING, new long[]{1}, input);
request.addFeed("threshold", TFDataType.DT_FLOAT, new long[] {}, th);
request.addFeed("model_id", TFDataType.DT_STRING, new long[]{}, model_name);

request.addFetch("sorted_labels");
request.addFetch("sorted_probs");
request.addFetch("model_version_id"); // An additional output is fetched.

Essa saída adicional altera o hash e causa um recarregamento mesmo após o aquecimento.

Solução

Cada service deve usar requisições reais de negócios para aquecimento. Faça upload de um arquivo de aquecimento criado a partir de uma requisição de produção real, com exatamente as mesmas entradas e saídas. Basta que session->Run seja executado com sucesso uma vez com uma requisição correspondente — você precisa de apenas um arquivo de aquecimento.

Próximos passos

SDKs: Aprenda a usar os SDKs do EAS para crie e enviar requisições.
Parameters of model services: Explore o conjunto completo de parâmetros de implantação JSON.