Obtén predicciones por lotes

Cuando no necesites las predicciones de inmediato o tengas una cantidad grande de instancias para las que obtener predicciones, puedes usar el servicio de predicción por lotes. En esta página, se describe cómo iniciar trabajos de predicción por lotes de AI Platform Prediction. AI Platform Prediction solo admite la obtención de predicciones por lotes de los modelos de TensorFlow.

Consulta una comparación entre la predicción en línea y la predicción por lotes o lee una descripción general de los conceptos de predicción.

Antes de comenzar

Para solicitar predicciones, primero debes realizar las siguientes acciones:

  • Crea un recurso del modelo y un recurso de versión o coloca un modelo guardado de TensorFlow en una ubicación de Cloud Storage a la que tu proyecto tenga acceso.

  • Configura una ubicación de Cloud Storage a la que tengas acceso con tu proyecto para los siguientes archivos:

    • Archivos de datos de entrada. Se puede tratar de varias ubicaciones y se debe tener autorización para realizar operaciones de lectura de cada una de ellas con tu proyecto.

    • Archivos de salida. Solo puedes especificar una ruta de salida y se debe tener autorización para realizar operaciones de escritura a tu proyecto.

  • Verifica que tu archivo de entrada se encuentre en el formato correcto para realizar la predicción por lotes.

Configura un trabajo de predicción por lotes

Para iniciar tu trabajo de predicción por lotes, deberás recopilar algunos datos de configuración. Estos datos son los mismos que están contenidos en el objeto PredictionInput que usas cuando llamas directamente a la API:

Formato de los datos

El tipo de formato de entrada que usas para tus archivos de entrada. Todos tus archivos de entrada para un trabajo determinado deben usar el mismo formato de datos. Configúralo en uno de estos valores:

JSON

Tus archivos de entrada son texto sin formato con una instancia en cada línea. Este es el formato que se describe en la página de conceptos de predicción.

TF_RECORD

El formato TFRecord de TensorFlow se usa con tus archivos de entrada.

TF_RECORD_GZIP

Tus archivos de entrada son archivos TFRecord comprimidos en GZIP.

Rutas de entrada

Los URI de tus archivos de datos de entrada que se deben encontrar en ubicaciones de Cloud Storage. Puedes especificar las siguientes rutas de acceso:

  • Rutas de acceso a archivos específicos: 'gs://path/to/my/input/file.json'

  • Rutas de acceso a directorios con un solo comodín de asterisco, para indicar todos los archivos en ese directorio: 'gs://path/to/my/input/*'

  • Rutas de acceso a nombres de archivos parciales con un solo comodín de asterisco al final, para indicar todos los archivos que comienzan con la secuencia proporcionada: 'gs://path/to/my/input/file*'

Puedes combinar varios URI. En Python, puedes generar una lista de ellos. Si usas la CLI de Google Cloud o llamas a la API directamente, puedes hacer una lista de varios URI, separados por comas, pero sin espacio entre ellas. Este es el formato correcto para la marca --input-paths:

 --input-paths gs://a/directory/of/files/*,gs://a/single/specific/file.json,gs://a/file/template/data*
Ruta de salida

La ruta de acceso a la ubicación de Cloud Storage donde deseas que el servicio de predicción guarde tus resultados. Tu proyecto debe contar con permisos para realizar operaciones de escritura en esta ubicación.

Nombre del modelo y de la versión

El nombre del modelo y, de forma opcional, la versión de los que deseas obtener predicciones. Si no especificas una versión, se usa la versión predeterminada del modelo. Para la predicción por lotes, la versión debe usar el mls1-c1-m2tipo de máquina.

Si proporcionas un URI del modelo (consulta la siguiente sección), omite estos campos.

URI del modelo

Puedes obtener predicciones de un modelo que no se implementa en AI Platform Prediction si especificas el URI del modelo guardado que deseas usar. El modelo guardado se debe almacenar en Cloud Storage.

En resumen, tienes tres opciones a fin de especificar el modelo que usarás para la predicción de lotes. Puedes usar los siguientes elementos:

  • El nombre del modelo por sí mismo para usar la versión predeterminada del modelo.

  • Los nombres del modelo y de la versión para usar una versión específica del modelo.

  • El URI del modelo para usar un modelo guardado que se encuentre en Cloud Storage, pero que no se haya implementado en AI Platform Prediction.

Región

La región de Google Compute Engine en la que desees ejecutar tu trabajo. Si quieres obtener el mejor rendimiento, debes ejecutar el trabajo de predicción y almacenar tus datos de entrada y salida en la misma región, en especial, para conjuntos de datos muy grandes. La predicción por lotes de AI Platform Prediction está disponible en las siguientes regiones:

  -   us-central1
  -   us-east1
  -   europe-west1
  -   asia-east1

A fin de comprender por completo las regiones disponibles para los servicios de AI Platform Prediction, incluidos el entrenamiento de modelos y la predicción en línea, lee la guía de regiones.

Nombre del trabajo

Un nombre para tu trabajo, que cumple con lo siguiente:

  • Contiene únicamente letras en mayúsculas y minúsculas (distingue mayúsculas de minúsculas), dígitos y guiones bajos.
  • Comienza con una letra.
  • No contiene más de 128 caracteres.
  • Es exclusivo entre todos los nombres de trabajo de entrenamiento y predicción por lotes que se hayan usado en tu proyecto. Esto incluye todos los trabajos que creaste en tu proyecto, sin importar su estado o si se crearon de forma correcta.
Tamaño del lote (opcional)

La cantidad de registros por lote. El servicio almacenará en búfer la cantidad de registros de batch_size en la memoria antes de invocar tu modelo. El valor predeterminado es 64 si no se especifica.

Etiquetas (opcional)

Puedes agregar etiquetas a tu trabajo para organizar y ordenar los trabajos en categorías cuando visualices o supervises los recursos. Por ejemplo, puedes ordenar los trabajos por equipo (si agregas etiquetas como engineering o research) o por fase de desarrollo (prod o test). Si deseas agregar etiquetas a tu trabajo de predicción, proporciona una lista de pares KEY=VALUE.

Recuento máximo de trabajadores (opcional)

La cantidad máxima de nodos de predicción que se usarán en el clúster de procesamiento para este trabajo. Esta es la manera de poner un límite superior en la característica de ajuste de escalamiento automático de la predicción por lotes. Si no especificas un valor, el valor predeterminado es 10. Sin importar el valor que especifiques, la cuota de nodos de predicción limita el escalamiento.

Versión del entorno de ejecución (opcional)

Es la versión de AI Platform Prediction que se usará para el trabajo. Esta opción se incluye a fin de que puedas especificar una versión del entorno de ejecución para usar con modelos que no se implementan en AI Platform Prediction. Siempre debes omitir este valor para las versiones de modelo implementadas, lo que indica que el servicio debe usar la misma versión que se especificó cuando se implementó la versión del modelo.

Nombre de la firma (opcional)

Si tu modelo guardado tiene varias firmas, usa esta opción para especificar un nombre de firma de TensorFlow personalizado que te permita seleccionar un mapa de entrada/salida alternativo definido en el modelo guardado de TensorFlow. Consulta la documentación de TensorFlow en el modelo guardado a fin de ver una guía para usar firmas y especificar las salidas de un modelo personalizado. El valor predeterminado es DEFAULT_SERVING_SIGNATURE_DEF_KEY, que tiene el valor serving_default.

En los siguientes ejemplos, se definen las variables para conservar los datos de configuración.

gcloud

No es necesario crear variables cuando se usa la herramienta de línea de comandos de gcloud para iniciar un trabajo. Sin embargo, esto hace que sea mucho más fácil ingresar y leer el comando de envío de trabajos.

DATA_FORMAT="text" # JSON data format
INPUT_PATHS='gs://path/to/your/input/data/*'
OUTPUT_PATH='gs://your/desired/output/location'
MODEL_NAME='census'
VERSION_NAME='v1'
REGION='us-east1'
now=$(date +"%Y%m%d_%H%M%S")
JOB_NAME="census_batch_predict_$now"
MAX_WORKER_COUNT="20"
BATCH_SIZE="32"
LABELS="team=engineering,phase=test,owner=sara"

Python

Cuando usas la biblioteca cliente de la API de Google para Python, puedes usar los diccionarios de Python a fin de representar los recursos de trabajo y PredictionInput.

  1. Dale formato al nombre del proyecto y al nombre del modelo o versión con la sintaxis que usan las API de REST de AI Platform Prediction:

    • project_name -> 'projects/project_name'
    • model_name -> 'projects/project_name/models/model_name'
    • version_name -> 'projects/project_name/models/model_name/versions/version_name'

  2. Crea un diccionario para el recurso Job y propágalo con dos elementos:

    • Una clave llamada 'jobId' con el nombre del trabajo que deseas usar como su valor

    • Una clave llamada 'predictionInput' que contiene otro objeto de diccionario con todos los miembros necesarios de PredictionInput y cualquier miembro opcional que desees usar

    En el siguiente ejemplo, se muestra una función con la que se toma la información de configuración como variables de entrada y se muestra el cuerpo de la solicitud de predicción. Además de los conceptos básicos, en el ejemplo también se muestra la generación de un identificador de trabajo exclusivo según el nombre de tu proyecto, el nombre del modelo y la hora actual.

    import time
import re

def make_batch_job_body(project_name, input_paths, output_path,
        model_name, region, data_format='JSON',
        version_name=None, max_worker_count=None,
        runtime_version=None):

    project_id = 'projects/{}'.format(project_name)
    model_id = '{}/models/{}'.format(project_id, model_name)
    if version_name:
        version_id = '{}/versions/{}'.format(model_id, version_name)

    # Make a jobName of the format "model_name_batch_predict_YYYYMMDD_HHMMSS"
    timestamp = time.strftime('%Y%m%d_%H%M%S', time.gmtime())

    # Make sure the project name is formatted correctly to work as the basis
    # of a valid job name.
    clean_project_name = re.sub(r'\W+', '_', project_name)

    job_id = '{}_{}_{}'.format(clean_project_name, model_name,
                           timestamp)

    # Start building the request dictionary with required information.
    body = {'jobId': job_id,
            'predictionInput': {
                'dataFormat': data_format,
                'inputPaths': input_paths,
                'outputPath': output_path,
                'region': region}}

    # Use the version if present, the model (its default version) if not.
    if version_name:
        body['predictionInput']['versionName'] = version_id
    else:
        body['predictionInput']['modelName'] = model_id

    # Only include a maximum number of workers or a runtime version if specified.
    # Otherwise let the service use its defaults.
    if max_worker_count:
        body['predictionInput']['maxWorkerCount'] = max_worker_count

    if runtime_version:
        body['predictionInput']['runtimeVersion'] = runtime_version

    return body

Cómo enviar un trabajo de predicción por lotes

Enviar tu trabajo es una simple llamada a projects.jobs.create o a tu herramienta de línea de comandos equivalente, gcloud ai-platform jobs submit prediction.

gcloud

En el siguiente ejemplo, se usan las variables definidas en la sección anterior para iniciar la predicción por lotes.

gcloud ai-platform jobs submit prediction $JOB_NAME \
    --model $MODEL_NAME \
    --input-paths $INPUT_PATHS \
    --output-path $OUTPUT_PATH \
    --region $REGION \
    --data-format $DATA_FORMAT

Python

Iniciar un trabajo de predicción por lotes con la biblioteca cliente de la API de Google para Python sigue un patrón similar al de otros procedimientos del SDK del cliente:

  1. Prepara el cuerpo de la solicitud que se usará para la llamada (esto se muestra en la sección anterior).

  2. Formula la solicitud con una llamada a ml.projects.jobs.create.

  3. Ejecuta la llamada en la solicitud para obtener una respuesta y asegúrate de comprobar si hay errores HTTP.

  4. Usa la respuesta como diccionario para obtener valores del recurso Job.

Puedes usar la biblioteca cliente de la API de Google para Python a fin de llamar a la API de AI Platform Training y de Prediction sin construir solicitudes HTTP de forma manual. Antes de ejecutar la siguiente muestra de código, debes configurar la autenticación.

    import googleapiclient.discovery as discovery

    project_id = 'projects/{}'.format(project_name)

    ml = discovery.build('ml', 'v1')
    request = ml.projects().jobs().create(parent=project_id,
                                          body=batch_predict_body)

    try:
        response = request.execute()

        print('Job requested.')

        # The state returned will almost always be QUEUED.
        print('state : {}'.format(response['state']))

    except errors.HttpError as err:
        # Something went wrong, print out some information.
        print('There was an error getting the prediction results.' +
              'Check the details:')
        print(err._get_reason())

Supervisa tu trabajo de predicción por lotes

Es posible que un trabajo de predicción por lotes tome mucho tiempo en finalizarse. Puedes supervisar el progreso del trabajo mediante la consola de Google Cloud:

  1. Ve a la página Trabajos de AI Platform Prediction en la consola de Google Cloud:

    Ir a la página Trabajos de la consola de Google Cloud

  2. Haz clic en el nombre de tu trabajo en la lista ID de trabajo. Esta acción abre la página Detalles del trabajo.

  3. El estado actual se muestra con el nombre del trabajo en la parte superior de la página.

  4. Si deseas obtener más detalles, puedes hacer clic en Ver registros para ver la entrada de tu trabajo en Cloud Logging.

Hay otras formas de hacer un seguimiento del progreso del trabajo de predicción por lotes. Siguen los mismos patrones que la supervisión de trabajos de entrenamiento. Encontrarás más información en la página en la que se describe cómo supervisar tus trabajos de entrenamiento. Es posible que debas ajustar un poco las instrucciones para realizar los trabajos de predicción, pero los mecanismos son los mismos.

Obtén resultados de predicción

El servicio realiza operaciones de escritura de predicciones en la ubicación de Cloud Storage que especifiques. Hay dos tipos de salida de archivos en los que se pueden incluir resultados interesantes:

  • Los archivos llamados prediction.errors_stats-NNNNN-of-NNNNN contienen información sobre cualquier problema encontrado durante el trabajo.

  • Los archivos líneas JSON llamados prediction.results-NNNNN-of-NNNNN contienen las predicciones en sí, como se definen en el resultado del modelo.

Los nombres de archivo incluyen números de índice (que se muestran arriba como una “N” para cada dígito) que indican la cantidad de archivos en total que deberías encontrar. Por ejemplo, un trabajo que tiene seis archivos de resultados incluye de prediction.results-00000-of-00006 a prediction.results-00005-of-00006.

Cada línea de cada archivo de predicción es un objeto JSON que representa un solo resultado de predicción. Puedes abrir los archivos de predicción con el editor de texto que desees. Para obtener una vista rápida de la línea de comandos, puedes usar gcloud storage cat:

gcloud storage cat $OUTPUT_PATH/prediction.results-NNNNN-of-NNNNN|less

Recuerda que los resultados de tu predicción no se muestran normalmente en el mismo orden que tus instancias de entrada, incluso si usas un archivo de entrada único. Puedes encontrar la predicción de una instancia si haces coincidir las claves de instancia.

¿Qué sigue?