Hospede vários modelos de visão computacional do TensorFlow usando pontos de extremidade de vários modelos do Amazon SageMaker

Amazon Sage Maker ajuda cientistas de dados e desenvolvedores a preparar, construir, treinar e implantar modelos de aprendizado de máquina (ML) de alta qualidade rapidamente, reunindo um amplo conjunto de recursos criados especificamente para ML. O SageMaker acelera a inovação em sua organização fornecendo ferramentas específicas para cada etapa do desenvolvimento de ML, incluindo rotulagem, preparação de dados, engenharia de recursos, detecção de viés estatístico, AutoML, treinamento, ajuste, hospedagem, explicabilidade, monitoramento e automação de fluxo de trabalho.

As empresas estão cada vez mais treinando modelos de ML com base em dados de usuários individuais. Por exemplo, um serviço de compartilhamento de imagens projetado para permitir a descoberta de informações na Internet treina modelos personalizados com base nas imagens carregadas e no histórico de navegação de cada usuário para personalizar recomendações para esse usuário. A empresa também pode treinar modelos personalizados com base em tópicos de pesquisa para recomendar imagens por tópico. A criação de modelos de ML personalizados para cada caso de uso leva a uma maior precisão de inferência, mas aumenta o custo de implantação e gerenciamento de modelos. Esses desafios se tornam mais pronunciados quando nem todos os modelos são acessados ​​na mesma taxa, mas ainda precisam estar disponíveis o tempo todo.

SageMaker endpoints multi-modelo fornecem uma maneira escalável e econômica de implantar um grande número de modelos de ML na nuvem. Os terminais multimodelo do SageMaker permitem implantar vários modelos de ML atrás de um único terminal e servi-los usando um único contêiner de serviço. Seu aplicativo simplesmente precisa incluir uma chamada de API com o modelo de destino para esse endpoint para obter inferência de baixa latência e alta taxa de transferência. Em vez de pagar por um endpoint separado para cada modelo, você pode hospedar muitos modelos pelo preço de um único endpoint. Para obter mais informações sobre os endpoints multimodelo do SageMaker, consulte Economize em custos de inferência usando pontos de extremidade multi-modelo do Amazon SageMaker.

Nesta postagem, demonstramos como usar os endpoints multimodelo do SageMaker para hospedar dois modelos de visão computacional com diferentes arquiteturas de modelo e conjuntos de dados para classificação de imagens. Na prática, você pode implantar dezenas de milhares de modelos em endpoints multimodelos.

Visão geral da solução

Os terminais multimodelo do SageMaker funcionam com várias estruturas, como TensorFlow, PyTorch, MXNet e sklearn, e você pode construa seu próprio contêiner com um servidor multimodelo. Os endpoints de vários modelos também são suportados nativamente nos seguintes algoritmos integrados populares do SageMaker: XGBoostName, Aprendiz Linear, Floresta de Corte Aleatório (RCF) e Vizinhos mais próximos (KNN). Você pode usar diretamente os contêineres fornecidos pelo SageMaker ao usar esses algoritmos sem precisar criar seu próprio contêiner personalizado.

O diagrama a seguir é uma ilustração simplificada de como você pode hospedar vários modelos (para esta postagem, seis) usando endpoints de vários modelos do SageMaker. Na prática, endpoints multimodelos podem acomodar centenas a dezenas de milhares de modelos de ML atrás de um endpoint. Em nossa arquitetura, se hospedarmos mais modelos usando artefatos de modelo armazenados em Serviço de armazenamento simples da Amazon (Amazon S3), endpoints multimodelos descarregam dinamicamente alguns dos modelos menos usados ​​para acomodar modelos mais novos.

Nesta postagem, mostramos como hospedar dois modelos de visão computacional treinados usando a estrutura TensorFlow por trás de um único endpoint multimodelo do SageMaker. Nós usamos o Serviço TensorFlow contêiner habilitado para endpoints multimodelo para hospedar esses modelos. Para nosso primeiro modelo, treinamos uma versão menor de Alex Net CNN para classificar as imagens do CIFAR-10 conjunto de dados. Para o segundo modelo, usamos um VGG16 Modelo CNN pré-treinado no IMAGEnet conjunto de dados e ajustado no Conjunto de dados de dígitos de linguagem de sinais para classificar imagens de símbolos de mão. Nós também fornecemos um totalmente funcional caderno para demonstrar todas as etapas.

Modelo 1: classificação de imagem CIFAR-10

O CIFAR-10 é um conjunto de dados de referência para classificação de imagens em visão computacional e ML. As imagens CIFAR são coloridas (três canais) com variação dramática na forma como os objetos aparecem. Consiste em imagens coloridas 32 × 32 em 10 aulas, com 6,000 imagens por aula. Ele contém 50,000 imagens de treinamento e 10,000 imagens de teste. A imagem a seguir mostra uma amostra das imagens agrupadas pelos rótulos.

Para construir o classificador de imagens, usamos uma versão simplificada do clássico AlexNet CNN. A rede é composta por cinco camadas convolucionais e de agrupamento e três camadas totalmente conectadas. Nossa arquitetura simplificada empilha três camadas convolucionais e duas camadas totalmente conectadas (densas).

A primeira etapa é carregar o conjunto de dados nos objetos de treinamento e teste. A estrutura do TensorFlow fornece o conjunto de dados CIFAR para carregarmos usando o método load_data(). Em seguida, redimensionamos as imagens de entrada dividindo os valores de pixel por 255: [0,255] ⇒ [0,1]. Também precisamos preparar os rótulos usando codificação one-hot. Uma codificação quente é um processo pelo qual as variáveis ​​categóricas são convertidas em uma forma numérica. O trecho de código a seguir mostra essas etapas em ação:

from tensorflow.keras.datasets import cifar10 # load dataset
(X_train, y_train), (X_test, y_test) = cifar10.load_data() # rescale input images
X_train = X_train.astype('float32')/255
X_test = X_test.astype('float32')/255 # one hot encode target labels
num_classes = len(np.unique(y_train))
y_train = utils.to_categorical(y_train, num_classes)
y_test = utils.to_categorical(y_test, num_classes)

Depois que o conjunto de dados estiver preparado e pronto para treinamento, ele será salvo no Amazon S3 para ser usado pelo SageMaker. A arquitetura do modelo e o código de treinamento para o classificador de imagem são montados em um script de treinamento (cifar_train.py). Para gerar lotes de dados de imagem de tensor para o processo de treinamento, usamos ImageDataGenerator. Isso nos permite aplicar transformações de aumento de dados, como mudanças de rotação, largura e altura, aos nossos dados de treinamento.

Na próxima etapa, usamos o script de treinamento para criar um estimador do TensorFlow usando o SageMaker SDK (consulte o código a seguir). Usamos o estimador para ajustar o modelo CNN nas entradas CIFAR-10. Quando o treinamento é concluído, o modelo é salvo no Amazon S3.

from sagemaker.tensorflow import TensorFlow model_name = 'cifar-10' hyperparameters = {'epochs': 50} estimator_parameters = {'entry_point':'cifar_train.py', 'instance_type': 'ml.m5.2xlarge', 'instance_count': 2, 'model_dir': f'/opt/ml/model', 'role': role, 'hyperparameters': hyperparameters, 'output_path': f's3://{BUCKET}/{PREFIX}/cifar_10/out', 'base_job_name': f'mme-cv-{model_name}', 'framework_version': TF_FRAMEWORK_VERSION, 'py_version': 'py37', 'script_mode': True} estimator_1 = TensorFlow(**estimator_parameters) estimator_1.fit(inputs)

Posteriormente, demonstramos como hospedar esse modelo usando o endpoint multimodelo do SageMaker juntamente com nosso segundo modelo (o classificador de dígitos da linguagem de sinais).

Modelo 2: Classificação dos dígitos da língua de sinais

Para o nosso segundo modelo, usamos o conjunto de dados de dígitos da língua de sinais. Este conjunto de dados distingue os dígitos da língua de sinais de 0 a 9. A imagem a seguir mostra uma amostra do conjunto de dados.

O conjunto de dados contém 100 x 100 imagens em cores RGB e possui 10 classes (dígitos 0–9). O conjunto de treinamento contém 1,712 imagens, o conjunto de validação 300 e o conjunto de teste 50.

Este conjunto de dados é muito pequeno. Treinar uma rede do zero neste pequeno conjunto de dados não alcança bons resultados. Para obter maior precisão, usamos transferência aprendizagem. O aprendizado por transferência geralmente é a abordagem ideal ao iniciar um projeto de classificação, especialmente quando você não tem muitos dados de treinamento. Ele migra o conhecimento aprendido do conjunto de dados de origem para o conjunto de dados de destino, para economizar tempo de treinamento e custo computacional.

Para treinar esse modelo, usamos um modelo VGG16 CNN pré-treinado treinado no conjunto de dados ImageNet e o ajustamos para funcionar em nosso conjunto de dados de dígitos de língua de sinais. Um modelo pré-treinado é uma rede que foi previamente treinada em um grande conjunto de dados, geralmente em uma tarefa de classificação de imagem em larga escala. A arquitetura do modelo VGG16 que usamos tem 13 camadas convolucionais no total. Para o conjunto de dados da língua de sinais, como seu domínio é diferente do domínio de origem do conjunto de dados do ImageNet, ajustamos apenas as últimas camadas. O ajuste fino aqui se refere ao congelamento de algumas das camadas de rede usadas para extração de recursos e ao treinamento conjunto das camadas não congeladas e das camadas classificadoras recém-adicionadas do modelo pré-treinado.

O roteiro de treinamento (sign_idioma_train.py) encapsula a arquitetura do modelo e a lógica de treinamento para o classificador de dígitos da língua de sinais. Primeiro, carregamos os pesos pré-treinados da rede VGG16 treinados no conjunto de dados ImageNet. Em seguida, congelamos parte da parte do extrator de recursos e adicionamos as novas camadas do classificador. Por fim, compilamos a rede e executamos o processo de treinamento para otimizar o modelo para o conjunto de dados menor.

Em seguida, usamos esse script de treinamento para criar um estimador do TensorFlow usando o SageMaker SDK. Este estimador é usado para ajustar o classificador de dígitos da língua de sinais nas entradas fornecidas. Quando o treinamento é concluído, o modelo é salvo no Amazon S3 para ser hospedado pelos endpoints de vários modelos do SageMaker. Veja o seguinte código:

model_name = 'sign-language' hyperparameters = {'epochs': 50} estimator_parameters = {'entry_point':'sign_language_train.py', 'instance_type': 'ml.m5.2xlarge', 'instance_count': 2, 'hyperparameters': hyperparameters, 'model_dir': f'/opt/ml/model', 'role': role, 'output_path': f's3://{BUCKET}/{PREFIX}/sign_language/out', 'base_job_name': f'cv-{model_name}', 'framework_version': TF_FRAMEWORK_VERSION, 'py_version': 'py37', 'script_mode': True} estimator_2 = TensorFlow(**estimator_parameters) estimator_2.fit({'train': train_input, 'val': val_input})

Implante um endpoint multimodelo

Os terminais multimodelo SageMaker fornecem uma solução escalável e econômica para implantar um grande número de modelos. Ele usa um contêiner de serviço compartilhado que está habilitado para hospedar vários modelos. Isso reduz os custos de hospedagem melhorando a utilização do endpoint em comparação com o uso de endpoints de modelo único. Ele também reduz a sobrecarga de implantação porque o SageMaker gerencia o carregamento de modelos na memória e os dimensiona com base nos padrões de tráfego para eles.

Para criar o terminal multimodelo, primeiro precisamos copiar os modelos treinados para os estimadores individuais (1 e 2) de suas localizações S3 salvas para um prefixo S3 comum que pode ser usado pelo terminal multimodelo:

tf_model_1 = estimator_1.model_data
output_1 = f's3://{BUCKET}/{PREFIX}/mme/cifar.tar.gz' tf_model_2 = estimator_2.model_data
output_2 = f's3://{BUCKET}/{PREFIX}/mme/sign-language.tar.gz' !aws s3 cp {tf_model_1} {output_1}
!aws s3 cp {tf_model_2} {output_2}

Depois que os modelos são copiados para o local comum designado pelo prefixo S3, criamos um modelo de serviço usando a classe TensorFlowModel do SageMaker SDK. O modelo de serviço é criado para um dos modelos a serem hospedados no terminal multimodelo. Neste caso, usamos o primeiro modelo (o classificador de imagem CIFAR-10). Em seguida, usamos a classe MultiDataModel do SageMaker SDK para criar um modelo de dados multimodelo usando o modelo de serviço para model-1, que criamos na etapa anterior:

from sagemaker.tensorflow.serving import TensorFlowModel
from sagemaker.multidatamodel import MultiDataModel model_1 = TensorFlowModel(model_data=output_1, role=role, image_uri=IMAGE_URI) mme = MultiDataModel(name=f'mme-tensorflow-{current_time}', model_data_prefix=model_data_prefix, model=model_1, sagemaker_session=sagemaker_session)

Por fim, implantamos o MultiDataModel chamando o método deploy(), fornecendo os atributos necessários para criar a infraestrutura de hospedagem necessária para suportar o terminal multimodelo:

predictor = mme.deploy(initial_instance_count=2, instance_type='ml.m5.2xlarge', endpoint_name=f'mme-tensorflow-{current_time}')

A chamada de implantação retorna uma instância preditora, que podemos usar para fazer chamadas de inferência. Vemos isso na próxima seção.

Teste o endpoint multimodelo para inferência em tempo real

Endpoints de vários modelos permitem o compartilhamento de recursos de memória entre seus modelos. Se o modelo a ser referenciado já estiver armazenado em cache, os endpoints de vários modelos executam a inferência imediatamente. Por outro lado, se o modelo solicitado específico não estiver armazenado em cache, o SageMaker precisará fazer o download do modelo, o que aumenta a latência para essa solicitação inicial. No entanto, isso leva apenas uma fração do tempo que levaria para lançar uma infraestrutura totalmente nova (instâncias) para hospedar o modelo individualmente no SageMaker. Depois que um modelo é armazenado em cache no terminal multimodelo, as solicitações subsequentes são iniciadas em tempo real (a menos que o modelo seja removido). Como resultado, você pode executar muitos modelos a partir de uma única instância, dissociando efetivamente nossa quantidade de modelos de nosso custo de implantação. Isso facilita o gerenciamento de implantações de ML em escala e reduz os custos de implantação do modelo por meio do aumento do uso do endpoint e de suas instâncias de computação subjacentes. Para obter mais informações e uma demonstração de economia de custos de mais de 90% para um exemplo de 1,000 modelos, consulte Economize nos custos de inferência usando endpoints multimodelo do Amazon SageMaker.

Os endpoints multimodelos também descarregam modelos não utilizados do contêiner quando as instâncias que suportam o endpoint atingem a capacidade de memória e mais modelos precisam ser carregados em seu contêiner. O SageMaker exclui artefatos de modelo não utilizados do volume de armazenamento da instância quando o volume está atingindo a capacidade máxima e novos modelos precisam ser baixados. A primeira chamada para um modelo recém-adicionado leva mais tempo porque o endpoint leva tempo para baixar o modelo do Amazon S3 para a memória do contêiner das instâncias que suportam o endpoint multimodelo. Os modelos que são descarregados permanecem no volume de armazenamento da instância e podem ser carregados na memória do contêiner posteriormente sem serem baixados novamente do bucket do S3.

Vamos ver como fazer uma inferência a partir do classificador de imagem CIFAR-10 (modelo-1) hospedado no terminal multimodelo. Primeiro, carregamos uma imagem de amostra de uma das classes — avião — e a preparamos para ser enviada ao terminal multimodelo usando o preditor que criamos na etapa anterior.

Com esse preditor, podemos chamar o método predict() junto com o parâmetro initial_args, que especifica o nome do modelo de destino a ser invocado. Nesse caso, o modelo de destino é cifar.tar.gz. O trecho a seguir demonstra esse processo em detalhes:

img = load_img('./data/cifar_10/raw_images/airplane.png', target_size=(32, 32))
data = img_to_array(img)
data = data.astype('float32')
data = data / 255.0
data = data.reshape(1, 32, 32, 3)
payload = {'instances': data}
y_pred = predictor.predict(data=payload, initial_args={'TargetModel': 'cifar.tar.gz'})
predicted_label = CIFAR10_LABELS[np.argmax(y_pred)]
print(f'Predicted Label: [{predicted_label}]')

A execução do código anterior retorna a saída de previsão como o rótulo avião, que é interpretado corretamente por nosso modelo servido:

Predicted Label: [airplane]

Em seguida, vamos ver como carregar dinamicamente o classificador de dígitos da língua de sinais (modelo 2) em um terminal multimodelo invocando o terminal com linguagem de sinais.tar.gz como o modelo de destino.

Usamos a seguinte imagem de amostra do dígito 0 do sinal de mão.

O snippet a seguir mostra como invocar o ponto de extremidade multimodelo com a imagem de amostra para obter a resposta correta:

test_path = './data/sign_language/test'
img = mpimg.imread(f'{test_path}/0/IMG_4159.JPG') def path_to_tensor(img_path): # loads RGB image as PIL.Image.Image type img = image.load_img(img_path, target_size=(224, 224)) # convert PIL.Image.Image type to 3D tensor with shape (224, 224, 3) x = image.img_to_array(img) # convert 3D tensor to 4D tensor with shape (1, 224, 224, 3) and return 4D tensor return np.expand_dims(x, axis=0) data = path_to_tensor(f'{test_path}/0/IMG_4159.JPG')
payload = {'instances': data}
y_pred = predictor.predict(data=payload, initial_args={'TargetModel': 'sign-language.tar.gz'})predicted_label = np.argmax(y_pred)
print(f'Predicted Label: [{predicted_label}]')

O código a seguir é nossa resposta, com o rótulo 0:

Predicted Label: [0]

Conclusão

Nesta postagem, demonstramos o recurso SageMaker endpoints multi-modelo para otimizar os custos de inferência. Os endpoints multimodelos são úteis quando você está lidando com centenas a dezenas de milhares de modelos e onde não é necessário implantar cada modelo como um endpoint individual. Os modelos são carregados e descarregados dinamicamente, de acordo com o uso e a quantidade de memória disponível no endpoint.

Esta postagem discutiu como hospedar vários modelos de visão computacional treinados usando a estrutura do TensorFlow em um endpoint multimodelo do SageMaker. Os modelos de classificação de imagem eram de diferentes arquiteturas de modelo e treinados em diferentes conjuntos de dados. o caderno incluído no post fornece instruções detalhadas sobre treinamento e hospedagem dos modelos.

Experimente os endpoints multimodelo do SageMaker para o seu caso de uso e deixe seus comentários nos comentários.

Sobre os autores

Arunprasath Shankar é arquiteto de soluções especialista em inteligência artificial e aprendizado de máquina (AI / ML) da AWS, ajudando clientes globais a dimensionar suas soluções de IA de maneira eficaz e eficiente na nuvem. Em seu tempo livre, Arun gosta de assistir filmes de ficção científica e ouvir música clássica.

Marcos Roy é o principal arquiteto de aprendizado de máquina da AWS, ajudando os clientes da AWS a projetar e criar soluções de IA/ML. O trabalho de Mark abrange uma ampla variedade de casos de uso de ML, com interesse principal em visão computacional, aprendizado profundo e dimensionamento de ML em toda a empresa. Ele ajudou empresas em muitos setores, incluindo seguros, serviços financeiros, mídia e entretenimento, saúde, serviços públicos e manufatura. Mark possui seis certificações da AWS, incluindo a ML Specialty Certification. Antes de ingressar na AWS, Mark foi arquiteto, desenvolvedor e líder de tecnologia por mais de 25 anos, incluindo 19 anos em serviços financeiros.

Fonte: https://aws.amazon.com/blogs/machine-learning/host-multiple-tensorflow-computer-vision-models-using-amazon-sagemaker-multi-model-endpoints/