Exportar modelos tabulares de AutoML

En esta página se describe cómo usar Vertex AI para exportar un modelo tabular de AutoML a Cloud Storage, descargar el modelo en un servidor local o en un servidor alojado por otro proveedor de servicios en la nube y, a continuación, usar Docker para que el modelo esté disponible para las predicciones.

Para obtener información sobre cómo exportar modelos de Edge de imagen y vídeo, consulta Exportar modelos de AutoML Edge.

Después de exportar tu modelo tabular, si quieres volver a importarlo a Vertex AI, consulta Importar modelos a Vertex AI.

Limitaciones

La exportación de modelos tabulares de AutoML tiene las siguientes limitaciones:

• Solo puedes exportar modelos de clasificación y regresión tabulares de AutoML. No se pueden exportar modelos de previsión tabular de AutoML.

• Vertex Explainable AI no está disponible con los modelos tabulares exportados. Si necesitas usar Vertex Explainable AI, debes servir predicciones de un modelo alojado en Vertex AI.

• El modelo tabular exportado solo se puede ejecutar en CPUs con arquitectura x86 que admitan conjuntos de instrucciones de extensiones de vector avanzadas (AVX).

Proceso de exportación

Para exportar tu modelo, sigue estos pasos:

1. Configura tu entorno.
2. Exporta el modelo.
3. Extrae y ejecuta el servidor de modelos.
4. Solicitar predicciones.

Antes de empezar

Para completar esta tarea, debes haber completado las siguientes:

• Configura tu proyecto como se describe en Configurar un proyecto y un entorno de desarrollo.
• Entrena el modelo que quieras descargar.
• Instala e inicializa Google Cloud CLI en el servidor que usarás para ejecutar el modelo exportado.
• Instala Docker en tu servidor.

Exportar el modelo

Consola

1. En la Google Cloud consola, en la sección Vertex AI, ve a la página Modelos.

   Ir a la página Modelos

2. Haga clic en el modelo tabular que quiera exportar para abrir su página de detalles.

3. Haz clic en Exportar en la barra de botones para exportar tu modelo.

4. Selecciona o crea una carpeta de Cloud Storage en la ubicación que quieras.

   El segmento debe cumplir los requisitos de los segmentos.

   No puedes exportar un modelo a un segmento de nivel superior. Debe usar al menos un nivel de carpeta.

   Para obtener los mejores resultados, crea una carpeta nueva y vacía. Copiará todo el contenido de la carpeta en un paso posterior.

5. Haz clic en Exportar.

   En la siguiente sección, descargará el modelo exportado en su servidor.

REST

Utiliza el método models.export para exportar un modelo a Cloud Storage.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

• LOCATION: tu región.
• PROJECT: tu ID de proyecto.
• MODEL_ID: el ID del modelo que quieres exportar.
• GCS_DESTINATION : la carpeta de destino en Cloud Storage. Por ejemplo, gs://export-bucket/exports.

  No puedes exportar un modelo a un segmento de nivel superior. Debes usar al menos un nivel de carpeta.

  La carpeta debe cumplir los requisitos de los segmentos.

  Para obtener los mejores resultados, crea una carpeta. En un paso posterior, copiará todo el contenido de la carpeta.

Método HTTP y URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export

Cuerpo JSON de la solicitud:

{
  "outputConfig": {
    "exportFormatId": "tf-saved-model",
    "artifactDestination": {
      "outputUriPrefix": "GCS_DESTINATION"
    }
  }
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la siguiente:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/models/MODEL_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.ExportModelOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-10-12T20:53:40.130785Z",
      "updateTime": "2020-10-12T20:53:40.130785Z"
    },
    "outputInfo": {
      "artifactOutputUri": "gs://OUTPUT_BUCKET/model-MODEL_ID/EXPORT_FORMAT/YYYY-MM-DDThh:mm:ss.sssZ"
    }
  }
}

Java

Antes de probar este ejemplo, sigue las Java instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de Vertex AI.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.ExportModelOperationMetadata;
import com.google.cloud.aiplatform.v1.ExportModelRequest;
import com.google.cloud.aiplatform.v1.ExportModelResponse;
import com.google.cloud.aiplatform.v1.GcsDestination;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.cloud.aiplatform.v1.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ExportModelTabularClassificationSample {
  public static void main(String[] args)
      throws InterruptedException, ExecutionException, TimeoutException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    String gcsDestinationOutputUriPrefix = "gs://your-gcs-bucket/destination_path";
    String project = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    exportModelTableClassification(gcsDestinationOutputUriPrefix, project, modelId);
  }

  static void exportModelTableClassification(
      String gcsDestinationOutputUriPrefix, String project, String modelId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    ModelServiceSettings modelServiceSettings =
        ModelServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings)) {
      String location = "us-central1";
      ModelName modelName = ModelName.of(project, location, modelId);

      GcsDestination.Builder gcsDestination = GcsDestination.newBuilder();
      gcsDestination.setOutputUriPrefix(gcsDestinationOutputUriPrefix);
      ExportModelRequest.OutputConfig outputConfig =
          ExportModelRequest.OutputConfig.newBuilder()
              .setExportFormatId("tf-saved-model")
              .setArtifactDestination(gcsDestination)
              .build();

      OperationFuture<ExportModelResponse, ExportModelOperationMetadata> exportModelResponseFuture =
          modelServiceClient.exportModelAsync(modelName, outputConfig);
      System.out.format(
          "Operation name: %s\n", exportModelResponseFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      ExportModelResponse exportModelResponse =
          exportModelResponseFuture.get(300, TimeUnit.SECONDS);
      System.out.format(
          "Export Model Tabular Classification Response: %s", exportModelResponse.toString());
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las Node.js instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de Vertex AI.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const gcsDestinationOutputUriPrefix ='YOUR_GCS_DESTINATION_\
// OUTPUT_URI_PREFIX'; eg. "gs://<your-gcs-bucket>/destination_path"
// const modelId = 'YOUR_MODEL_ID';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Model Service Client library
const {ModelServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const modelServiceClient = new ModelServiceClient(clientOptions);

async function exportModelTabularClassification() {
  // Configure the name resources
  const name = `projects/${project}/locations/${location}/models/${modelId}`;
  // Configure the outputConfig resources
  const outputConfig = {
    exportFormatId: 'tf-saved-model',
    artifactDestination: {
      outputUriPrefix: gcsDestinationOutputUriPrefix,
    },
  };
  const request = {
    name,
    outputConfig,
  };

  // Export Model request
  const [response] = await modelServiceClient.exportModel(request);
  console.log(`Long running operation : ${response.name}`);

  // Wait for operation to complete
  await response.promise();
  console.log(`Export model response : ${JSON.stringify(response.result)}`);
}
exportModelTabularClassification();

Python

Para saber cómo instalar o actualizar el SDK de Vertex AI para Python, consulta Instalar el SDK de Vertex AI para Python. Para obtener más información, consulta la documentación de referencia de la API Python.

from google.cloud import aiplatform_v1beta1


def export_model_tabular_classification_sample(
    project: str,
    model_id: str,
    gcs_destination_output_uri_prefix: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
    timeout: int = 300,
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform_v1beta1.ModelServiceClient(client_options=client_options)
    gcs_destination = {"output_uri_prefix": gcs_destination_output_uri_prefix}
    output_config = {
        "artifact_destination": gcs_destination,
        "export_format_id": "tf-saved-model",
    }
    name = client.model_path(project=project, location=location, model=model_id)
    response = client.export_model(name=name, output_config=output_config)
    print("Long running operation:", response.operation.name)
    print("output_info:", response.metadata.output_info)
    export_model_response = response.result(timeout=timeout)
    print("export_model_response:", export_model_response)

Obtener el estado de una operación de exportación

Algunas solicitudes inician operaciones de larga duración que requieren tiempo para completarse. Estas solicitudes devuelven un nombre de operación que puedes usar para ver el estado de la operación o cancelarla. Vertex AI proporciona métodos auxiliares para hacer llamadas a operaciones de larga duración. Para obtener más información, consulta Trabajar con operaciones de larga duración.

Extraer y ejecutar el servidor de modelos

En esta tarea, descargarás el modelo exportado de Cloud Storage e iniciarás el contenedor Docker para que el modelo esté listo para recibir solicitudes de predicción.

Para extraer y ejecutar el servidor de modelos, haz lo siguiente:

1. En el ordenador en el que vayas a ejecutar el modelo, ve al directorio en el que quieras guardar el modelo exportado.

2. Descarga el modelo exportado:

   gcloud storage cp <var>gcs-destination</var> . --recursive
   

   Donde gcs-destination es la ruta a la ubicación del modelo exportado en Cloud Storage.

   El modelo se copia en el directorio actual, en la siguiente ruta:

   ./model-<model-id>/tf-saved-model/<export-timestamp>

   La ruta puede contener tf-saved-model o custom-trained.

3. Cambia el nombre del directorio para quitar la marca de tiempo.

   mv model-<model-id>/tf-saved-model/<export-timestamp> model-<model-id>/tf-saved-model/<new-dir-name>
   

   La marca de tiempo hace que el directorio no sea válido para Docker.

4. Extrae la imagen Docker del servidor de modelos.

   sudo docker pull MODEL_SERVER_IMAGE
   

   La imagen del servidor de modelos que se va a extraer se encuentra en el archivo environment.json del directorio del modelo exportado. Debe tener la siguiente ruta:

   ./model-<model-id>/tf-saved-model/<new-dir-name>/environment.json

   Si no hay ningún archivo environment.json, usa lo siguiente:

   MULTI_REGION-docker.pkg.dev/vertex-ai/automl-tabular/prediction-server-v1

   Sustituye MULTI_REGION por us, europe o asia para seleccionar el repositorio de Docker del que quieras extraer la imagen de Docker. Cada repositorio proporciona la misma imagen Docker, pero elegir la multirregión de Artifact Registry más cercana a la máquina en la que ejecutas Docker puede reducir la latencia.

5. Inicia el contenedor de Docker con el nombre del directorio que acabas de crear:

   docker run -v `pwd`/model-<model-id>/tf-saved-model/<new-dir-name>:/models/default -p 8080:8080 -it MODEL_SERVER_IMAGE
   

Puedes detener el servidor del modelo en cualquier momento con Ctrl-C.

Actualizar el contenedor Docker del servidor de modelos

Como descargas el contenedor Docker del servidor del modelo al exportar el modelo, debes actualizar explícitamente el servidor del modelo para obtener actualizaciones y correcciones de errores. Debes actualizar el servidor del modelo periódicamente con el siguiente comando:

docker pull MODEL_SERVER_IMAGE

Asegúrate de que la URI de la imagen Docker coincida con la URI de la imagen Docker que has extraído anteriormente.

Obtener predicciones del modelo exportado

El servidor de modelos del contenedor de imágenes de Vertex AI gestiona las solicitudes de predicción y devuelve los resultados de las predicciones.

La predicción por lotes no está disponible para los modelos exportados.

Formato de datos de predicción

Proporciona los datos (campo payload) de tu solicitud de predicción en el siguiente formato JSON:

{ "instances": [ { "column_name_1": value, "column_name_2": value, … } , … ] }

Nota: Los modelos de Vertex AI exportados no validan el formato de los datos de las solicitudes de predicción. Esto significa que una solicitud de predicción que, por lo demás, esté bien formada, pero que tenga columnas que faltan, errores en los nombres de las columnas o incluso una solicitud para un modelo completamente diferente, devolverá una predicción (errónea o potencialmente sin sentido). Asegúrate de que las solicitudes de predicción a los modelos exportados sean correctas.

En el siguiente ejemplo se muestra una solicitud con tres columnas: una columna categórica, un array numérico y una estructura. La solicitud incluye dos filas.

{
  "instances": [
    {
      "categorical_col": "mouse",
      "num_array_col": [
        1,
        2,
        3
      ],
      "struct_col": {
        "foo": "piano",
        "bar": "2019-05-17T23:56:09.05Z"
      }
    },
    {
      "categorical_col": "dog",
      "num_array_col": [
        5,
        6,
        7
      ],
      "struct_col": {
        "foo": "guitar",
        "bar": "2019-06-17T23:56:09.05Z"
      }
    }
  ]
}

Enviar la solicitud de predicción

1. Incluya los datos de la solicitud en un archivo de texto, por ejemplo, tmp/request.json.

   El número de filas de datos de la solicitud de predicción, denominado tamaño de minilote, afecta a la latencia y al rendimiento de la predicción. Cuanto mayor sea el tamaño del mini-lote, mayores serán la latencia y el rendimiento. Para reducir la latencia, usa un tamaño de minilote más pequeño. Para aumentar el rendimiento, aumenta el tamaño del minilote. Los tamaños de minilote más habituales son 1, 32, 64, 128, 256, 512 y 1024.

2. Solicita la predicción:

   curl -X POST --data @/tmp/request.json http://localhost:8080/predict
   

Formato de los resultados de la predicción

El formato de los resultados depende del objetivo del modelo.

Resultados del modelo de clasificación

Los resultados de las predicciones de los modelos de clasificación (binaria y multiclase) devuelven una puntuación de probabilidad para cada valor posible de la columna de destino. Debes determinar cómo quieres usar las puntuaciones. Por ejemplo, para obtener una clasificación binaria a partir de las puntuaciones proporcionadas, debe identificar un valor de umbral. Si hay dos clases, "A" y "B", debes clasificar el ejemplo como "A" si la puntuación de "A" es superior al umbral elegido y como "B" en caso contrario. En el caso de los conjuntos de datos desequilibrados, el umbral puede acercarse al 100% o al 0%.

La carga útil de los resultados de un modelo de clasificación tiene un aspecto similar al de este ejemplo:

{
  "predictions": [
    {
      "scores": [
        0.539999994635582,
        0.2599999845027924,
        0.2000000208627896
      ],
      "classes": [
        "apple",
        "orange",
        "grape"
      ]
    },
    {
      "scores": [
        0.23999999463558197,
        0.35999998450279236,
        0.40000002086278963
      ],
      "classes": [
        "apple",
        "orange",
        "grape"
      ]
    }
  ]
}

Resultados del modelo de regresión

Se devuelve un valor previsto por cada fila válida de la solicitud de predicción. Los intervalos de predicción no se devuelven en los modelos exportados.

La carga útil de los resultados de un modelo de regresión es similar a este ejemplo:

{
  "predictions": [
    {
      "value": -304.3663330078125,
      "lower_bound": -56.32196807861328,
      "upper_bound": 126.51904296875
    },
    {
      "value": -112.3663330078125,
      "lower_bound": 16.32196807861328,
      "upper_bound": 255.51904296875
    }
  ]
}

Siguientes pasos

• Consulta cómo volver a importar a Vertex AI el modelo tabular que has exportado.