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. Ejecutar 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 el SDK de Cloud en el servidor que usarás para ejecutar el modelo exportado
  • Instalar Docker en tu servidor
  • Extrae la imagen de Docker del servidor del modelo de Vertex AI:

    sudo docker pull 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.

Exporta el modelo

Console

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

    Ir a la página Modelos

  2. Haz clic en el modelo tabular que deseas 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 deseada.

    El bucket debe cumplir con los requisitos del bucket .

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

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

  5. Haz clic en Exportar (Export).

    En la siguiente sección, descargarás el modelo exportado a tu servidor.

LÍNEA DE REST Y CMD

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

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • LOCATION: Tu región.
  • PROJECT: Tu ID del proyecto o número de proyecto.
  • MODEL_ID: El ID del modelo que deseas exportar.
  • GCS_DESTINATION: tu carpeta de destino en Cloud Storage. Por ejemplo, gs://export-bucket/exports

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

    La carpeta debe cumplir con los requisitos del bucket.

    Para obtener mejores resultados, crea una carpeta nueva. Copiarás todo el contenido de la carpeta en un paso posterior.

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 application-default 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 application-default 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 que se muestra a continuación:

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

Si deseas obtener información para instalar y usar la biblioteca cliente de Vertex AI, consulta las bibliotecas cliente de Vertex AI. Si deseas obtener más información, consulta la documentación de referencia de la API de Vertex AI para Java.


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

Si deseas obtener información para instalar y usar la biblioteca cliente de Vertex AI, consulta las bibliotecas cliente de Vertex AI. Si quieres obtener más información, consulta la documentación de referencia de la API de Vertex AI para Node.js.

/**
 * 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Vertex AI, consulta las bibliotecas cliente de Vertex AI. Si deseas obtener más información, consulta la documentación de referencia de la API de Vertex AI para 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)

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

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.

El modelo debe ejecutarse dentro de un contenedor de Docker.

Para 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>

  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. 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 MULTI_REGION-docker.pkg.dev/vertex-ai/automl-tabular/prediction-server-v1
    

    Reemplaza MULTI_REGION por el mismo valor que usaste en la sección Antes de comenzar de esta guía (us, europe o asia), de modo que el URI de la imagen de Docker coincida con el de la imagen de Docker que extrajiste antes.

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 MULTI_REGION-docker.pkg.dev/vertex-ai/automl-tabular/prediction-server-v1

Reemplaza MULTI_REGION por el mismo valor que usaste en la sección Antes de comenzar de esta guía (us, europe o asia), de modo 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?