Performing batch inference with TensorFlow Serving in Amazon SageMaker

por

Después de haber entrenado y exportado un modelo TensorFlow puede usar Amazon SageMaker para realizar inferencias usando su modelo.

Puede:
  • Implementar su modelo en un punto final para obtener inferencias en tiempo real de su modelo.
  • Use la transformación por lotes para obtener inferencias en un conjunto de datos completo almacenado en Amazon S3 .

En el caso de la transformación por lotes, cada vez es más necesario realizar una inferencia por lotes rápida y optimizada en grandes conjuntos de datos.

En esta publicación, aprenderá cómo usar la transformación por lotes de Amazon SageMaker para realizar inferencias en grandes conjuntos de datos.

El ejemplo en esta publicación utiliza un contenedor TensorFlow Serving (TFS) para hacer inferencia por lotes en un gran conjunto de datos de imágenes.

También puede ver cómo usar la nueva función de procesamiento previo y posterior del contenedor TFS de Amazon SageMaker. Esta característica permite que su modelo TensorFlow haga inferencias directamente en datos en S3 y también guarde inferencias procesadas posteriormente en S3.

Descripción general

El conjunto de datos en este ejemplo es el “ Desafío 2018/2019 ” subconjunto del Open Images V5 Dataset . Este subconjunto consta de 100.000 imágenes en formato JPG para un total de 10 GB.

El modelo que utiliza es un modelo de clasificación de imágenes basado en la arquitectura ResNet-50 que ha sido entrenado en el conjunto de datos de ImageNet y exportado como un TensorFlow SavedModel .

Use este modelo para predecir la clase de cada imagen (por ejemplo, barco, automóvil, pájaro). Usted escribe una secuencia de comandos de procesamiento previo y posterior y la empaqueta con el Modelo Guardado para realizar inferencias de manera rápida, eficiente y a escala.

Tutorial

Cuando ejecuta un trabajo de transformación por lotes, especifique:
  • Donde los datos de entrada se almacenan
  • Qué objeto de modelo de Amazon SageMaker (denominado “Modelo”) se usará para transformar sus datos
  • El número de instancias de clúster que se usarán para su trabajo de transformación por lotes

En nuestro caso de uso, un objeto Modelo es un servidor HTTP que sirve un artefacto modelo entrenado, un modelo guardado de TensorFlow, a través del contenedor TFS de Amazon SageMaker. La transformación por lotes de Amazon SageMaker distribuye sus datos de entrada entre las instancias.

Para cada instancia en el clúster, la transformación por lotes de Amazon SageMaker envía solicitudes HTTP para inferencias que contienen datos de entrada de S3 al Modelo. La transformación por lotes de Amazon SageMaker guarda estas inferencias nuevamente en S3.

Los datos a menudo deben convertirse de un formato a otro antes de que puedan pasar a un modelo para predicciones.

Por ejemplo, las imágenes pueden estar en formato PNG o JPG, pero deben convertirse a un formato que el modelo pueda aceptar. Además, a veces se debe realizar otro preprocesamiento de los datos, como el cambio de tamaño de las imágenes.

Usando la nueva función de procesamiento previo y posterior del contenedor Amazon SageMaker TFS, puede convertir fácilmente los datos que tiene en S3 (como datos de imagen sin procesar) en una solicitud TFS. Su TensorFlow SavedModel puede usar esta solicitud de inferencia.

Esto es lo que sucede:
  1. Su código de procesamiento previo se ejecuta en un servidor HTTP dentro del contenedor TFS y procesa las solicitudes entrantes antes de enviarlas a una instancia de TFS dentro del mismo contenedor.
  2. Su código de procesamiento posterior procesa las respuestas de TFS antes se guardan en S3.

El siguiente diagrama ilustra esta solución.

Realización de inferencias en datos de imágenes en bruto con una transformación por lotes de Amazon SageMaker

Estos son los tres pasos necesarios para la implementación: [19659017] Escriba una secuencia de comandos de procesamiento previo y posterior para datos de entrada JPEG.

  • Empaquete un modelo para datos de entrada JPEG.
  • Ejecute un trabajo de transformación por lotes de Amazon SageMaker para datos de entrada JPEG.

 

Para escribir un pre– y secuencia de comandos de procesamiento posterior para datos de entrada JPEG

Para hacer inferencias, primero debe procesar previamente los datos de su imagen en S3 para que coincidan con la firma de publicación de su TensorFlow SavedModel que puede inspeccionar utilizando el saved_model_c li . La siguiente es la firma de publicación del modelo ResNet-50 v2 (NCHW, JPEG) :

 MetaGraphDef con el conjunto de etiquetas: 'serve' contiene los siguientes SignatureDefs:

[...]

firma_def ['serving_default']:
  El SignatureDef guardado del modelo guardado contiene las siguientes entradas:
    entradas ['image_bytes'] tensor_info:
        dtype: DT_STRING
        forma: (-1)
        nombre: input_tensor: 0
  El SignatureDef guardado del modelo guardado contiene los siguientes resultados:
    salidas ['classes'] tensor_info:
        dtype: DT_INT64
        forma: (-1)
        nombre: ArgMax: 0
    salidas ['probabilities'] tensor_info:
        dtype: DT_FLOAT
        forma: (-1, 1001)
        nombre: softmax_tensor: 0
  El nombre del método es: tensorflow / serving / predict

El contenedor TFS de Amazon SageMaker utiliza el SignatureDef del modelo llamado serving_default que se declara cuando se exporta el TensorFlow SavedModel.

Este SignatureDef dice que el modelo acepta una cadena de longitud arbitraria como entrada y responde con clases y sus probabilidades.

Con su modelo de clasificación de imágenes, la cadena de entrada es una cadena codificada en base64 que representa una imagen JPEG, que decodifica su modelo guardado.

El script de Python que utiliza para el procesamiento previo y posterior, inference.py se reproduce de la siguiente manera:
 import base64
importar io
importar json
solicitudes de importación

def input_handler (datos, contexto):
    "" "Entrada de solicitud de preproceso antes de enviarla a la API REST de TensorFlow Serving

    Args:
        datos (obj): la secuencia de datos de solicitud
        contexto (Contexto): un objeto que contiene detalles de solicitud y configuración

    Devoluciones:
        (dict): un dict serializable JSON que contiene encabezados y cuerpo de solicitud
    "" "

    if context.request_content_type == 'application / x-image':
        carga útil = data.read ()
        encoded_image = base64.b64encode (carga útil) .decode ('utf-8')
        instancia = [{"b64": encoded_image}]
        return json.dumps ({"instancias": instancia})
    más:
        _return_error (415, 'Tipo de contenido no compatible "{}"'. format (context.request_content_type o 'Unknown'))


def output_handler (respuesta, contexto):
    "" "Post-proceso TensorFlow Servir salida antes de que se devuelva al cliente.

    Args:
        respuesta (obj): la respuesta de servicio TensorFlow
        contexto (Contexto): un objeto que contiene detalles de solicitud y configuración

    Devoluciones:
        (bytes, cadena): datos para devolver al cliente, tipo de contenido de respuesta
    "" "
    if response.status_code! = 200:
        _return_error (response.status_code, response.content.decode ('utf-8'))
    response_content_type = context.accept_header
    predicción = respuesta.contenido
    predicción de retorno, tipo_contenido_respuesta


def _return_error (código, mensaje):
    raise ValueError ('Error: {}, {}'. format (str (code), message))

El input_handler intercepta las solicitudes de inferencia, base64 codifica el cuerpo de la solicitud y formatea el cuerpo de la solicitud para conforme a la TFS REST API .

El valor de retorno de la función input_handler se utiliza como el cuerpo de la solicitud en la solicitud de TensorFlow Serving. Los datos binarios deben usar la clave “b64”, de acuerdo con la TFS REST API .

Debido a que el tensor de entrada de su firma de servicio tiene el sufijo “_bytes”, los datos de imagen codificados bajo la clave “b64” se pasan a el tensor “image_bytes”.

Algunas firmas de servicio pueden aceptar un tensor de flotantes o enteros en lugar de una cadena codificada en base64.

Sin embargo, para datos binarios (incluidos datos de imagen), su modelo debe aceptar una cadena codificada en base64 para datos binarios porque las representaciones JSON de datos binarios pueden ser grandes.

Cada solicitud entrante originalmente contiene una imagen JPEG serializada en su cuerpo de solicitud. Después de pasar por el input_handler el cuerpo de la solicitud contiene lo siguiente, que TFS acepta para inferencia:

 {"instancias": [{"b64":"[base-64 encoded JPEG image] "}]}

El primer campo en el valor de retorno de output_handler es lo que la transformación por lotes de Amazon SageMaker guarda en S3 como la predicción de este ejemplo. En este caso, output_handler pasa el contenido a S3 sin modificar.

Pre y postprocesamiento las funciones le permiten realizar inferencias con TFS en cualquier formato de datos, no solo en imágenes. Para obtener más información sobre input_handler y output_handler consulte Amazon SageMaker TFS Container README

Empaquetando un modelo para datos de entrada JPEG

Después de escribir una secuencia de comandos de procesamiento previo y posterior, empaquete su modelo guardado TensorFlow junto con su secuencia de comandos en un archivo model.tar.gz.

Luego, cargue el archivo en S3 para que lo use el contenedor TFS de Amazon SageMaker.

El siguiente es un ejemplo de un modelo empaquetado:
 ├── código
│ ├── inference.py
│ └── requerimientos.txt
└── 1538687370
    ├── saved_model.pb
    └── variables
       ├── variables.data-00000-of-00001
       └── variables.index

El número 1538687370 se refiere al número de versión del modelo de SavedModel, y este directorio contiene sus artefactos SavedModel.

El directorio del código contiene su script de pre y postprocesamiento, que debe llamarse inference.py .

También contiene un archivo opcional require.txt que se utiliza para instalar dependencias (con pip ) desde el índice del paquete Python antes de que comience el trabajo de transformación por lotes. En este caso de uso, no necesita dependencias adicionales.

Para empaquetar su modelo guardado y su código, cree un archivo tar GZIP llamado model.tar.gz ejecutando el siguiente comando:

tar -czvf model.tar.gz código –directory = resnet_v2_fp32_savedmodel_NCHW_jpg 1538687370

Utilice este model.tar.gz cuando cree un objeto Modelo para ejecutar trabajos de transformación por lotes. Para obtener más información sobre cómo empaquetar un modelo, consulte el README del Contenedor TFS de Amazon SageMaker .

Después de crear un paquete de artefactos modelo, cargue su model.tar.gz y cree un objeto Modelo que se refiere a su artefacto modelo empaquetado y al contenedor Amazon SageMaker TFS. Especifique que está ejecutando en la Región us-west-2 utilizando instancias TFS 1.13.1 y GPU.

Los siguientes ejemplos de código utilizan la CLI de AWS, que es útil para crear scripts de canalizaciones automáticas y Amazon SageMaker Python SDK .

Sin embargo, puede crear modelos y trabajos de transformación por lotes de Amazon SageMaker utilizando cualquier SDK de AWS.

AWS CLI
 marca de tiempo () {
  fecha +% Y-% m-% d-% H-% M-% S
}

MODEL_NAME = "imagen-clasificación-tfs - $ (marca de tiempo)"
MODEL_DATA_URL = "s3: //my-sagemaker-bucket/model/model.tar.gz"

aws s3 cp model.tar.gz $ MODEL_DATA_URL

REGIÓN = "us-west-2"
TFS_VERSION = "1.13.1"
PROCESSOR_TYPE = "gpu"

IMAGEN = "520713654638.dkr.ecr. $ REGION.amazonaws.com / sagemaker-tensorflow-serving: $ TFS_VERSION- $ PROCESSOR_TYPE"

# Consulte el siguiente documento para obtener más información sobre los roles de SageMaker:
# https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html
ROLE_ARN = "[SageMaker-compatible IAM Role ARN]"

aws sagemaker create-model 
    --model-name $ MODEL_NAME 
    --primary-container Image = $ IMAGE, ModelDataUrl = $ MODEL_DATA_URL 
    --execution-role-arn $ ROLE_ARN
    
tar -czvf model.tar.gz code --directory = resnet_v2_fp32_savedmodel_NCHW_jpg 1538687370
Amazon SageMaker Python SDK
 import os
sagemaker de importación
del modelo de importación sagemaker.tensorflow.serving

sagemaker_session = sagemaker.Session ()
# Consulte el siguiente documento para obtener más información sobre los roles de SageMaker:
# https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html
rol = '[SageMaker-compatible IAM Role ARN']
bucket = 'sagemaker-data-bucket'
prefijo = 'sagemaker / high-throughput-tfs-batch-transform'
s3_path = 's3: // {} / {}' .format (cubo, prefijo)

model_data = sagemaker_session.upload_data ('model.tar.gz',
                                           cangilón,
                                           os.path.join (prefijo, 'modelo'))
                                           
tensorflow_serving_model = Modelo (model_data = model_data,
                                 rol = rol,
                                 framework_version = '1.13',
                                 sagemaker_session = sagemaker_session)

Ejecutando un trabajo de transformación de Amazon SageMaker para datos de entrada JPEG

Ahora, use el objeto Modelo que creó para ejecutar predicciones por lotes con la transformación por lotes de Amazon SageMaker. Especifique los datos de entrada S3, el tipo de contenido de los datos de entrada, el depósito S3 de salida y el tipo de instancia y el recuento.

Debe especificar dos parámetros adicionales que afectan el rendimiento: max-payload-in-mb y max-concurrent-transforms .

El parámetro max-payload-in-mb determina cuán grandes pueden ser las cargas útiles de solicitud al enviar solicitudes a su modelo. Debido a que el objeto más grande en su entrada S3 es menor a un megabyte, establezca este parámetro en 1.

El parámetro max-concurrent-transforms determina cuántas solicitudes concurrentes enviar a su modelo. El valor que maximiza el rendimiento varía según su modelo y datos de entrada. Para esta publicación, se estableció en 64 después de experimentar con potencias de dos.

AWS CLI
 TRANSFORM_JOB_NAME = "tfs-image-clasificación-trabajo - $ (marca de tiempo)"
# Este prefijo S3 contiene archivos .jpg.
TRANSFORM_S3_INPUT = "s3: // your-sagemaker-input-data / jpeg-images /"
TRANSFORM_S3_OUTPUT = "s3: // your-sagemaker-output-data-bucket / output"

TRANSFORM_INPUT_DATA_SOURCE = {S3DataSource = {S3DataType = "S3Prefix", S3Uri = $ TRANSFORM_S3_INPUT}}
CONTENT_TYPE = "application / x-image"

INSTANCE_TYPE = "ml.p3.2xlarge"
INSTANCE_COUNT = 2

MAX_PAYLOAD_IN_MB = 1
MAX_CONCURRENT_TRANSFORMS = 64

aws sagemaker create-transform-job 
    --model-name $ MODEL_NAME 
    --transform-input DataSource = $ TRANSFORM_INPUT_DATA_SOURCE, ContentType = $ CONTENT_TYPE 
    --transform-output S3OutputPath = $ TRANSFORM_S3_OUTPUT 
    --transform-resources InstanceType = $ INSTANCE_TYPE, InstanceCount = $ INSTANCE_COUNT 
    --max-payload-in-mb $ MAX_PAYLOAD_IN_MB 
    --max-concurrent-transforms $ MAX_CONCURRENT_TRANSFORMS 
    --transform-job-name $ JOB_NAME
Amazon SageMaker Python SDK
 output_path = 's3: // your-sagemaker-output-data-bucket / output'
tensorflow_serving_transformer = tensorflow_serving_model.transformer (
                                     número_instancia = 2,
                                     instancia_tipo = 'ml.p3.2xlarge',
                                     max_concurrent_transforms = 64,
                                     max_payload = 1,
                                     output_path = output_path)

input_path = 's3: // your-sagemaker-input-data / jpeg-images /'
tensorflow_serving_transformer.transform (input_path, content_type = 'application / x-image')

Sus datos de entrada consisten en 100,000 imágenes JPEG. La ruta de datos de entrada S3 se ve así:

 2019-05-09 19:41:18 129216 00000b4dcff7f799.jpg
2019-05-09 19:41:18 118629 00001a21632de752.jpg
2019-05-09 19:41:18 154661 0000d67245642c5f.jpg
2019-05-09 19:41:18 163722 0001244aa8ed3099.jpg
2019-05-09 19:41:18 117780 000172d1dd1adce0.jpg
...

En las pruebas, el trabajo de transformación por lotes terminó de transformar las 100.000 imágenes en 12 minutos en dos ml.p3.2xlarge instancias. Puede escalar fácilmente sus trabajos de transformación por lotes para manejar conjuntos de datos más grandes o ejecutarlos más rápido aumentando el recuento de instancias.

Después de que se complete el trabajo de transformación por lotes, inspeccione la salida. En su ruta de salida, encontrará un objeto S3 por objeto en la entrada:

 2019-05-16 05:46:05 12.7 KiB 00000b4dcff7f799.jpg.out
2019-05-16 05:46:04 12.6 KiB 00001a21632de752.jpg.out
2019-05-16 05:46:05 12.7 KiB 0000d67245642c5f.jpg.out
2019-05-16 05:46:05 12.7 KiB 0001244aa8ed3099.jpg.out
2019-05-16 05:46:04 12.7 KiB 000172d1dd1adce0.jpg.out
...

Al inspeccionar uno de los objetos de salida, puede ver la predicción del modelo:

 {
    "predicciones": [
        {
            "probabilities": [6.08312e-07, 9.68555e-07, ...],
            "clases": 576
        }
    ]
}

Entonces, así es como obtener inferencias en un conjunto de datos que consiste en imágenes JPEG. En algunos casos, es posible que haya convertido sus datos a TFRecords para capacitación o para codificar múltiples vectores de características en un solo registro. La siguiente sección muestra cómo realizar inferencia por lotes con TFRecords.

Realización de inferencias en un conjunto de datos TFRecord con una transformación por lotes de Amazon SageMaker

TFRecord es un formato de ajuste de registros comúnmente utilizado con TensorFlow para almacenar múltiples instancias de tf. Ejemplo . Con TFRecord, puede almacenar múltiples imágenes (u otros datos binarios) en un solo objeto S3, junto con anotaciones y otros metadatos.

La transformación por lotes de Amazon SageMaker puede dividir un objeto S3 por el delimitador TFRecord, permitiéndole realizar inferencias en un ejemplo a la vez o en lotes de ejemplos.

Usar la transformación por lotes de Amazon SageMaker para realizar inferencia en datos TFRecord es similar a realizar inferencia directamente en datos de imagen, según el ejemplo anterior en esta publicación.

Para escribir un script de procesamiento previo y posterior para datos TFRecord

Suponga que Usted convirtió los datos de imagen utilizados anteriormente al formato TFRecord. En lugar de realizar inferencia en 100,000 objetos de imagen S3 separados.

Realice inferencia en 100 objetos S3, cada uno con 1000 imágenes agrupadas como un archivo TFRecord. Las imágenes se almacenan en la clave “imagen / codificada” en un tf. Ejemplo y estos tf.

Los ejemplos se envuelven en el formato TFRecord. Podemos realizar inferencias en estos TFRecords y emitirlos en cualquier formato de datos, como JSON o CSV.

Ahora, dígale a Amazon SageMaker transformación por lotes que divida cada objeto por un encabezado TFRecord y haga inferencia en un solo registro a la vez, de modo que cada solicitud contenga un tf.Ejemplo serializado . Utilice el siguiente script de preprocesamiento y posprocesamiento para realizar la inferencia:

 import base64
importar io
importar json
solicitudes de importación
importar tensorflow como tf
de google.protobuf.json_format import MessageToDict
desde el espacio en blanco de importación de cadena

def input_handler (datos, contexto):
    "" "Entrada de solicitud de preproceso antes de enviarla a la API REST de TensorFlow Serving

    Args:
        datos (obj): la secuencia de datos de solicitud
        contexto (Contexto): un objeto que contiene detalles de solicitud y configuración

    Devoluciones:
        (dict): un dict serializable JSON que contiene encabezados y cuerpo de solicitud
    "" "

    if context.request_content_type == 'application / x-tfexample':
        carga útil = data.read ()
        ejemplo = tf.train.Example ()
        ejemplo.ParseFromString (carga útil)
        example_feature = MessageToDict (example.features) ['feature']
        encoded_image = example_feature ['image/encoded']['bytesList']['value'][0]
         instancia = [{"b64": encoded_image}]
        return json.dumps ({"instancias": instancia})
    más:
        _return_error (415, 'Tipo de contenido no compatible "{}"'. format (context.request_content_type o 'Unknown'))


def output_handler (respuesta, contexto):
    "" "Post-proceso TensorFlow Servir salida antes de que se devuelva al cliente.

    Args:
        datos (obj): la respuesta de servicio TensorFlow
        contexto (Contexto): un objeto que contiene detalles de solicitud y configuración

    Devoluciones:
        (bytes, cadena): datos para devolver al cliente, tipo de contenido de respuesta
    "" "
    if response.status_code! = 200:
        _return_error (response.status_code, response.content.decode ('utf-8'))
    response_content_type = context.accept_header
    # Eliminar espacios en blanco de la cadena JSON de salida.
    predicción = respuesta.contenido.decódigo ('utf-8'). traducir (dict.fromkeys (mapa (ord, espacio en blanco)))
    predicción de retorno, tipo_contenido_respuesta


def _return_error (código, mensaje):
    raise ValueError ('Error: {}, {}'. format (str (code), message))

Su manejador de entrada extrae los datos de la imagen del valor almacenado en la clave “imagen / codificada” del ejemplo. Luego, base64 codifica los datos de la imagen para inferencia en TFS, tal como en el ejemplo anterior para los datos de entrada JPEG.

Cada objeto de salida contiene 1000 predicciones (una por imagen en el objeto de entrada). Estas predicciones se ordenan de la misma manera que en el objeto de entrada.

Su output_handler elimina el espacio en blanco de la cadena con formato JSON de salida que representa cada predicción TFS. De esta manera, el objeto S3 de salida puede adherirse al formato JSONLines, lo que facilita su análisis. Más tarde, configure su trabajo de transformación por lotes para unir cada registro con un carácter de nueva línea.

El script de preprocesamiento requiere dependencias adicionales para analizar los datos de entrada. Agregue una dependencia de TensorFlow al archivo require.txt en el ejemplo anterior para que pueda analizar las instancias serializadas de tf. Ejemplo :

 tensorflow == 1.13.1 
TensorFlow 1.13.1 se instala cuando comienza cada trabajo de transformación. Hay otras opciones para incluir dependencias externas, incluidas las opciones para evitar instalar dependencias en tiempo de ejecución. Para obtener más información, consulte el  README de contenedor de Amazon SageMaker TFS .

 

Para empaquetar un modelo para datos de entrada TFRecord

 

Vuelva a crear su model.tar.gz para contener su nuevo script de preprocesamiento y luego cree un nuevo objeto Modelo que apunte al nuevo model.tar.gz . Este paso es idéntico al ejemplo anterior para los datos de entrada JPEG, así que consulte esa sección para obtener más detalles.

 

Para ejecutar un trabajo de transformación por lotes de Amazon SageMaker para datos de entrada TFRecord

 

Ahora ejecute un trabajo de transformación por lotes contra archivos TFRecord que contengan las imágenes:

 

AWS CLI

 

 TRANSFORM_JOB_NAME = "tfs-image-clasificación-trabajo - $ (marca de tiempo)"

TRANSFORM_S3_INPUT = "s3: // your-sagemaker-input-data / tfrecord-images /"
TRANSFORM_S3_OUTPUT = "s3: // your-sagemaker-output-data-bucket / tfrecord-output /"

TRANSFORM_INPUT_DATA_SOURCE = {S3DataSource = {S3DataType = "S3Prefix", S3Uri = $ TRANSFORM_S3_INPUT}}

SPLIT_TYPE = "TFRecord"
BATCH_STRATEGY = "SingleRecord"

CONTENT_TYPE = "application / x-tfexample"
DATA_SOURCE = $ TRANSFORM_INPUT_DATA_SOURCE, ContentType = $ CONTENT_TYPE, SplitType = $ SPLIT_TYPE

ASSEMBLE_WITH = "Línea"
INSTANCE_TYPE = "ml.p3.2xlarge"
INSTANCE_COUNT = 2

MAX_PAYLOAD_IN_MB = 1
MAX_CONCURRENT_TRANSFORMS = 64

aws sagemaker create-transform-job 
    --model-name $ MODEL_NAME 
    --transform-input DataSource = $ DATA_SOURCE 
    --transform-output S3OutputPath = $ TRANSFORM_S3_OUTPUT, AssembleWith = $ ASSEMBLE_WITH 
    --transform-resources InstanceType = $ INSTANCE_TYPE, InstanceCount = $ INSTANCE_COUNT 
    --max-payload-in-mb $ MAX_PAYLOAD_IN_MB 
    --max-concurrent-transforms $ MAX_CONCURRENT_TRANSFORMS 
    --transform-job-name $ JOB_NAME 
    - estrategia de lote $ BATCH_STRATEGY 
    --environment SAGEMAKER_TFS_ENABLE_BATCHING = true, SAGEMAKER_TFS_BATCH_TIMEOUT_MICROS =, SAGEMAKER_TFS_MAX_BATCH_SIZE =
Amazon SDK Python SageMaker “16” “50000”
 env = { 'SAGEMAKER_TFS_ENABLE_BATCHING': 'verdadero', 'SAGEMAKER_TFS_BATCH_TIMEOUT_MICROS': '50000', 'SAGEMAKER_TFS_MAX_BATCH_SIZE' : 'dieciséis'}
output_path = 's3: // sagemaker-output-data-bucket / tfrecord-output /'
tensorflow_serving_transformer = tensorflow_serving_model.transformer (
                                     número_instancia = 2,
                                     split_type = 'TFRecord',
                                     assemble_with = 'Línea'
                                     instancia_tipo = 'ml.p3.2xlarge',
                                     max_concurrent_transforms = 64,
                                     max_payload = 1,
                                     output_path = output_path, env = env)

input_path = 's3: // your-sagemaker-input-data / tfrecord-images /'
tensorflow_serving_transformer.transform (input_path, content_type = 'application / x-tfexample')
El comando es casi idéntico al del ejemplo anterior para datos de entrada JPEG, con algunas diferencias notables:
  • Usted especifica SplitType como ” TFRecord “. Este es el delimitador que utiliza la transformación por lotes de Amazon SageMaker. Otros delimitadores compatibles son “Línea” para los caracteres de nueva línea y “RecordIO” para el formato de datos RecordIO .
  • Usted especifica BatchStrategy como “SingleRecord” (en lugar de “MultiRecord”). Esto significa que se envía un registro a la vez al modelo después de dividirlo por el delimitador TFRecord. En este caso, elija “SingleRecord” para evitar tener que quitar los registros del encabezado TFRecord en su script de preprocesamiento. Si elige “MultiRecord”, cada solicitud enviada a su modelo contiene hasta 1 MB de registros (ya que eligió MaxPayloadInMB para que sea 1 MB).
  • Usted especifica AssembleWith como “Line”. Esto le indica a su trabajo de transformación por lotes que reúna las predicciones individuales en cada objeto mediante caracteres de nueva línea en lugar de concatenarlos.
  • Usted especifica las variables de entorno que se pasarán al contenedor de Amazon SageMaker TFS. Estas variables de entorno particulares permiten el procesamiento por lotes de solicitudes, una función TFS que permite agrupar registros de múltiples solicitudes. El parámetro MaxConcurrentTransforms se incrementa a 100, ya que TFS pone en cola lotes de solicitudes. El procesamiento por lotes de solicitudes es una característica avanzada que, cuando se configura correctamente, puede mejorar significativamente el rendimiento, especialmente en instancias habilitadas para GPU. Para obtener más información sobre cómo configurar el procesamiento por lotes de solicitudes, consulte Contenedor TFS de Amazon SageMaker

Sus datos de entrada S3 constaban de 100 objetos correspondientes a archivos TFRecord:

 2019-05-20 21:07:12 99.3 MiB train-00000-of-00100
2019-05-20 21:07:12 100.8 MiB train-00001-of-00100
2019-05-20 21:07:12 100.4 MiB train-00002-de-00100
2019-05-20 21:07:12 99.2 MiB train-00003-de-00100
2019-05-20 21:07:12 101.5 MiB train-00004-de-00100
2019-05-20 21:07:14 99.8 MiB train-00005-of-00100
...

Su trabajo de transformación por lotes en las imágenes en formato TFRecord debería finalizar en aproximadamente 8 minutos en dos ml.p3.2xlarge instancias con el procesamiento por lotes de solicitudes habilitado. Ahora, su ruta de datos de salida S3 consta de un objeto de salida para cada uno de los 100 objetos de entrada:

 2019-05-20 23:21:23 11.3 MiB train-00000-of-00100.out
2019-05-20 23:21:35 11.4 MiB train-00001-of-00100.out
2019-05-20 23:21:30 11.4 MiB train-00002-of-00100.out
2019-05-20 23:21:40 11.3 MiB train-00003-of-00100.out
2019-05-20 23:21:35 11.4 MiB train-00004-of-00100.out
...

Cada objeto en la salida sigue el formato JSONLines y contiene 1000 líneas, con cada línea que contiene la salida TFS para una imagen:

 {"predicciones": [{"probabilities":[2.58252e-08,...]"clases": 636}] }
{"predicciones": [{"probabilities":[2.9319e-07,...]"clases": 519}]}
...

Para cada archivo, el orden de las imágenes en la salida sigue siendo el mismo que en la entrada. En otras palabras, la primera imagen de cada archivo de entrada corresponde a la primera línea del archivo de salida correspondiente, la segunda imagen a la segunda línea, etc.

Conclusión

La ​​transformación por lotes de Amazon SageMaker puede transformar grandes conjuntos de datos rápidamente y a escala. Viste cómo usar el contenedor Amazon SageMaker TFS para realizar inferencias con instancias aceleradas por GPU en datos de imagen y archivos TFRecord.

Mientras que el contenedor Amazon SageMaker TFS admite datos CSV y JSON listos para usar, su La nueva función de procesamiento previo y posterior también le permite ejecutar trabajos de transformación por lotes en datos de cualquier formato.

El mismo contenedor también se puede utilizar para la inferencia en tiempo real, utilizando un punto final del modelo alojado en Amazon SageMaker.

Nuestro ejemplo en el texto de la publicación de blog anterior utiliza el conjunto de datos Open Images.

Sin embargo, hemos puesto a disposición varios ejemplos para satisfacer sus limitaciones de tiempo, caso de uso y flujo de trabajo preferido.

Están disponibles en GitHub (haga clic en los enlaces a continuación) y en las instancias del cuaderno SageMaker.

  • Ejemplo CIFAR-10 : el conjunto de datos CIFAR-10 es mucho más pequeño que Open Images, por lo que este ejemplo está destinado a un demostración rápida de las características anteriores.
  • Ejemplo de imágenes abiertas, datos de imagen : este ejemplo utiliza el conjunto de datos de imágenes abiertas y realiza inferencia en archivos de imágenes sin procesar. Hay dos versiones disponibles: una usa el SDK de SageMaker Python, mientras que la otra usa la CLI de AWS.
  • Ejemplo de Open Images, TFRecord data : este ejemplo usa el conjunto de datos Open Images y realiza inferencia sobre los datos almacenados en el formato binario TensorFlow, TFRecord. Hay dos versiones disponibles: una usa el SDK de SageMaker Python, mientras que la otra usa la CLI de AWS.

Para comenzar con estos ejemplos, vaya a Consola Amazon SageMaker y cree una instancia de computadora portátil SageMaker o abrir uno existente. Luego vaya a la pestaña Ejemplos de SageMaker y seleccione los ejemplos relevantes del menú desplegable Transformación por lotes de SageMaker .

Dejá un comentario