Obtén predicciones por lotes

Cuando no necesites tus 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 los trabajos de predicción por lotes de AI Platform.

Obtén más información sobre la predicción en línea frente a la predicción por lotes o consulta 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 en el objeto PredictionInput que usas cuando llamas directamente a la API:

Formato de 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 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 herramienta de línea de comandos de gcloud o llamas a la API de forma directa, 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

Es 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 tener permisos para realizar operaciones de escritura en esta ubicación.

Nombre del modelo y de la versión

Es 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 está implementado en AI Platform 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 algunas de estas opciones:

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

  • Los nombres del modelo y 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

Región

Es la región de Google Compute Engine en la que desees ejecutar tu trabajo. Para obtener el mejor rendimiento, debes ejecutar tu 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 está disponible en las siguientes regiones:

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

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

Nombre del trabajo

Es el nombre para tu trabajo, que cumple con los siguientes requisitos:

  • 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 correctamente.
(Opcional) Recuento máximo de trabajadores

Es 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.

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

Es la versión de AI Platform para usar en el trabajo. Esta opción se incluye a fin de que puedas especificar una versión del entorno de ejecución para usarla con modelos que no están implementados en AI Platform. Siempre debes omitir este valor para las versiones del 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.

(Opcional) Nombre de la firma

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"

Python

Cuando usas la biblioteca cliente de las 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 de tu proyecto y al nombre de tu modelo o versión con la sintaxis que usan las API de REST de AI Platform:

    • 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 de trabajo 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 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
    

Envía 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

El inicio de un trabajo de predicción por lotes con la biblioteca cliente de las 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 de trabajo.

Puedes usar la biblioteca cliente de las API de Google para Python a fin de llamar a la API de entrenamiento y predicción de AI Platform sin crear 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

Un trabajo de predicción por lotes puede tardar mucho tiempo en finalizar. Puedes supervisar el progreso de tu trabajo con Google Cloud Platform Console:

  1. Ve a la página Trabajos de AI Platform en Google Cloud Platform Console.

    Ir a la página Trabajos de GCP Console

  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 Stackdriver Logging.

Hay otras formas de hacer un seguimiento del progreso de tu 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 denominados prediction.results-NNNNN-of-NNNNN contienen las predicciones en sí, tal como se definen en la salida de tu modelo.

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

A los resultados de predicción se les da formato como objetos JSON en archivos de texto. Puedes abrirlos con los editores de texto que desees. Para obtener una vista rápida de la línea de comandos, puedes usar gsutil cat:

gsutil 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.

Próximos pasos

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…

¿Necesitas ayuda? Visita nuestra página de asistencia.