Obtén predicciones por lotes

Cuando no necesites tus predicciones de inmediato o tengas una cantidad grande de instancias para las que puedas 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 Cloud Machine Learning Engine.

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 modelo y una versión con Cloud ML Engine o coloca un modelo guardado de TensorFlow en una ubicación de Cloud Storage a la que puedas acceder con tu proyecto.

  • 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 comodín de asterisco único para indicar todos los archivos en el directorio: 'gs://path/to/my/input/*'.

  • Rutas de acceso a nombres de archivos parciales con un comodín de asterisco único 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 hacer una lista de ellos. Si usas la herramienta de línea de comandos de gcloud o llamas directamente a la API, puedes hacer una lista de varios URI separados por comas, pero sin espacio. 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. En su lugar, puedes usar la ruta de acceso de Cloud Storage para un modelo guardado no implementado, denominado modelo URI, si lo deseas.

URI del modelo

Puedes obtener predicciones de un modelo que no esté implementado en Cloud ML Engine 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 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 Cloud ML Engine.

Región

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 Cloud ML Engine 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 Cloud ML Engine, incluidos el entrenamiento de modelos y la predicción en línea, consulta 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 correctamente.
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)

La versión de Cloud ML Engine 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 usarla con modelos que no estén implementados en Cloud ML Engine. 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. La firma predeterminada 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="JSON"
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 Cloud ML Engine:

    • 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 denominada 'jobId' con el nombre de trabajo que desees usar como su valor.

    • Una clave denominada 'predictionInput' que contiene otro objeto de diccionario que aloja todos los miembros obligatorios 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 su herramienta de línea de comandos equivalente, gcloud ml-engine 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 ml-engine 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 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 Cloud Machine Learning Engine 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 Cloud ML Engine 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 con el nombre prediction.errors_stats-NNNNN-of-NNNNN contienen información sobre los problemas que se encontraron durante el trabajo.

  • Los archivos con el nombre prediction.results-NNNNN-of-NNNNN contienen las predicciones en sí, como se definen en tu salida de 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, en un trabajo que tiene seis archivos de resultados, se incluye prediction.results-00000-of-00006 a través de 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 consultar 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.

¿Qué sigue?

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

Enviar comentarios sobre…

Cloud ML Engine para TensorFlow