Exporta modelos tabulares de AutoML

En esta página, se describe cómo usar la Vertex AI para exportar el 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, luego, usar Docker para crear el modelo. disponible para las predicciones.

Para obtener información sobre cómo exportar modelos de Edge de imágenes y videos, consulta Exporta modelos de AutoML Edge.

Después de exportar el modelo tabular, si deseas importarlo de nuevo a Vertex AI, consulta Importa modelos a Vertex AI.

Limitaciones

Exportar los modelos tabulares de AutoML tiene las siguientes limitaciones:

• Solo puedes exportar modelos de clasificación tabular y de regresión de AutoML. No se admite la exportación de modelos de previsión tabular de AutoML.

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

• El modelo tabular exportado solo puede ejecutarse en las CPU de arquitectura x86 que admitan conjuntos de instrucciones de Advanced Vector Extensions (AVX).

Proceso de exportación

Los pasos para exportar tu modelo son los siguientes:

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

Antes de comenzar

Antes de completar esta tarea, debes realizar las siguientes tareas:

• Configura tu proyecto como se describe en Configura el entorno en la nube.
• Entrenar el modelo que deseas descargar
• Instalar y, luego, inicializar la Google Cloud CLI en el servidor que usarás para ejecutar el modelo exportado
• Instalar Docker en tu servidor

Exporta el modelo

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

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

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

$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 "http://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export" | Select-Object -Expand Content

{
  "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"
    }
  }
}

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());
    }
  }
}

/**
 * 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();

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)

Obtén 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 en operaciones de larga duración. Para obtener más información, consulta Trabaja con operaciones de larga duración.

Extrae y ejecuta el servidor de modelos

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

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

1. En la máquina donde vas a ejecutar el modelo, cambia el directorio donde deseas guardar el modelo exportado.

2. Descarga el modelo exportado:

   gsutil cp -r <var>gcs-destination</var> .
   

   En el ejemplo anterior, gcs-destination es la ruta de acceso a la ubicación del modelo exportado en Cloud Storage.

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

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

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

3. Cambia el nombre del directorio para que se quite 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 de Docker del servidor de modelos

   sudo docker pull MODEL_SERVER_IMAGE
   

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

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

   Si no hay un archivo environment.json, usa lo siguiente:

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

   Reemplaza MULTI_REGION por us, europe o asia para seleccionar el repositorio de Docker desde el que deseas extraer la imagen de Docker. Cada repositorio proporciona la misma imagen de 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 de modelo en cualquier momento con Ctrl-C.

Actualiza el contenedor de Docker del servidor de modelo

Debido a que descargas el contenedor de Docker del servidor de modelos cuando exportas el modelo, debes actualizar explícitamente el servidor de modelos para obtener actualizaciones y correcciones de errores. Debes actualizar el servidor del modelo de forma periódica mediante el siguiente comando:

docker pull MODEL_SERVER_IMAGE

Asegúrate de que el URI de la imagen de Docker coincida con el de la imagen de Docker que extrajiste antes.

Obtén predicciones a partir del modelo exportado

El servidor de modelos en el contenedor de imágenes de Vertex AI controla las solicitudes de predicción y muestra resultados de predicciones.

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

Formato de datos de predicción

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

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

En el siguiente ejemplo, se muestra una solicitud con tres columnas: una columna categórica, un arreglo 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"
      }
    }
  ]
}

Realiza la solicitud de predicción

1. Coloca los datos de tu solicitud en un archivo de texto, por ejemplo: tmp/request.json.

   La cantidad de filas de datos en la solicitud de predicción, que se denomina tamaño del minilote, afecta la latencia de predicción y la capacidad de procesamiento. Cuanto mayor sea el tamaño del minilote, mayor será la latencia y la capacidad de procesamiento. Para reducir la latencia, usa un tamaño del minilote más pequeño. Para aumentar la capacidad de procesamiento, aumenta el tamaño del minilote. Los tamaños de minilotes más comunes son 1, 32, 64, 128, 256, 512 y 1,024.

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 de tu modelo.

Resultados del modelo de clasificación

Los resultados de la predicción de los modelos de clasificación (binarios y de varias clases) muestran una puntuación de probabilidad para cada valor potencial de la columna objetivo. Debes determinar cómo quieres usar las puntuaciones. Por ejemplo, para obtener una clasificación binaria a partir de las puntuaciones proporcionadas, debes 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 mayor que el umbral elegido, y “B” en el caso opuesto. En el caso de los conjuntos de datos desequilibrados, el umbral podría aproximarse al 100% o al 0%.

La carga útil de los resultados de un modelo de clasificación es similar a 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 muestra un valor previsto para cada fila válida de la solicitud de predicción. No se muestran intervalos de predicción para 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
    }
  ]
}

¿Qué sigue?

• Obtén información sobre cómo volver a importar tu modelo tabular exportado a Vertex AI.