Instructivo de la API de AutoML Vision

En este instructivo, se muestra cómo crear un modelo nuevo con tu propio conjunto de imágenes de entrenamiento, evaluar los resultados y predecir la clasificación de las imágenes de prueba con AutoML Vision.

También se usa un conjunto de datos con imágenes de cinco tipos diferentes de flores: girasoles, tulipanes, margaritas, rosas y dientes de león. Se explica el entrenamiento de un modelo personalizado, la evaluación del rendimiento del modelo y la clasificación de imágenes nuevas con el modelo personalizado.

Requisitos

Configura el entorno del proyecto

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

  2. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  4. Habilita las API de AutoML Vision.

    Habilita las API

    5.

  5. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  6. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  7. Habilita las API de AutoML Vision.

    Habilita las API

    8.
  8. Instala la CLI de Google Cloud.
  9. Sigue las instrucciones para crear una cuenta de servicio y descargar un archivo de claves.
  10. Establece la variable de entorno GOOGLE_APPLICATION_CREDENTIALS en la ruta de acceso al archivo de claves de la cuenta de servicio que descargaste cuando creaste la cuenta de servicio. Por ejemplo: 
    export GOOGLE_APPLICATION_CREDENTIALS=KEY_FILE
  11. Agrega la cuenta de servicio nueva a la función de IAM de editor de AutoML con los siguientes comandos. Reemplaza PROJECT_ID con el nombre de tu proyecto de Google Cloud y reemplaza SERVICE_ACCOUNT_NAME con el nombre de tu nueva cuenta de servicio, por ejemplo, service-account1@myproject.iam.gserviceaccount.com. 
    gcloud auth login
gcloud projects add-iam-policy-binding PROJECT_ID \
 --member="user:YOUR_USERID@YOUR_DOMAIN" \
 --role="roles/automl.admin"
gcloud projects add-iam-policy-binding PROJECT_ID \
 --member=serviceAccount:SERVICE_ACCOUNT_NAME \
 --role="roles/automl.editor"
  12. Permite que las cuentas de servicio de AutoML Vision accedan a los recursos del proyecto de Google Cloud:
    gcloud projects add-iam-policy-binding PROJECT_ID \
 --member="serviceAccount:custom-vision@appspot.gserviceaccount.com" \
 --role="roles/storage.admin"
  13. Instala la biblioteca cliente.
  14. Configura las variables de entorno PROJECT_ID y REGION_NAME.

    Reemplaza PROJECT_ID con el ID de tu proyecto de Google Cloud. En la actualidad, AutoML Vision requiere la ubicación us-central1. 
    export PROJECT_ID="PROJECT_ID"
export REGION_NAME="us-central1"
  15. Crea un bucket de Cloud Storage para almacenar los documentos que usarás para entrenar tu modelo personalizado.

    El nombre del depósito debe tener el siguiente formato: $PROJECT_ID-vcm. El siguiente comando crea un depósito de almacenamiento llamado $PROJECT_ID-vcm en la región us-central1. 
    gsutil mb -p PROJECT_ID -c regional -l us-central1 gs://PROJECT_ID-vcm/
  16. Configura la variable BUCKET. 
    export BUCKET=PROJECT_ID-vcm
  17. Copia el conjunto de datos de imágenes de flores público de gs://cloud-samples-data/img/flower_photos/ en el depósito de Google Cloud Storage.

    En tu sesión de Cloud Shell, ingresa lo siguiente: 
    gsutil -m cp -R gs://cloud-samples-data/ai-platform/flowers/ gs://BUCKET/img/

    La copia del archivo tarda unos 20 minutos en completarse.

    Este comando también copia el archivo all_data.csv, que enumera los nombres de archivo originales y sus etiquetas.

  18. El conjunto de datos de muestra contiene un archivo CSV con la ubicación y las etiquetas de cada imagen (consulta Prepara los datos de entrenamiento para obtener más detalles sobre el formato requerido). Actualiza el archivo CSV para que indique los archivos ubicados en tu bucket: 
    gsutil cat gs://BUCKET/img/flowers/all_data.csv | sed "s:cloud-ml-data/img/flower_photos/:BUCKET/img/flowers/:" > all_data.csv
    Luego, copia el archivo CSV actualizado en el bucket:
    gsutil cp all_data.csv gs://BUCKET/csv/

Ubicaciones de los archivos de código fuente

Puedes descargar el código fuente desde la ubicación que se indica a continuación. Después de la descarga, puedes copiar el código fuente en la carpeta del proyecto de AutoML Vision.

Python

El instructivo consta de estos archivos de Python:

Java

El instructivo consta de estos archivos de Java:

Node.js

El instructivo consta de estos programas de Node.js:

Ejecuta la aplicación

Paso 1: Crea el conjunto de datos Flowers

El primer paso cuando se crea un modelo personalizado es crear un conjunto de datos vacío que, más adelante, tendrá los datos de entrenamiento para el modelo. Cuando creas un conjunto de datos, debes especificar el tipo de clasificación que deseas que realice el modelo personalizado:

  • MULTICLASS asigna una sola etiqueta a cada imagen clasificada.
  • MULTILABEL permite asignar varias etiquetas a una imagen.

En este instructivo, se crea un conjunto de datos llamado flowers y se usa MULTICLASS.

Copia el código

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# display_name = "your_datasets_display_name"

client = automl.AutoMlClient()

# A resource that represents Google Cloud Platform location.
project_location = f"projects/{project_id}/locations/us-central1"
# Specify the classification type
# Types:
# MultiLabel: Multiple labels are allowed for one example.
# MultiClass: At most one label is allowed per example.
# https://cloud.google.com/automl/docs/reference/rpc/google.cloud.automl.v1#classificationtype
metadata = automl.ImageClassificationDatasetMetadata(
    classification_type=automl.ClassificationType.MULTILABEL
)
dataset = automl.Dataset(
    display_name=display_name,
    image_classification_dataset_metadata=metadata,
)

# Create a dataset with the dataset metadata in the region.
response = client.create_dataset(
    parent=project_location, dataset=dataset, timeout=300
)

created_dataset = response.result()

# Display the dataset information
print(f"Dataset name: {created_dataset.name}")
print("Dataset id: {}".format(created_dataset.name.split("/")[-1]))

Java

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ClassificationType;
import com.google.cloud.automl.v1.Dataset;
import com.google.cloud.automl.v1.ImageClassificationDatasetMetadata;
import com.google.cloud.automl.v1.LocationName;
import com.google.cloud.automl.v1.OperationMetadata;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class VisionClassificationCreateDataset {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String displayName = "YOUR_DATASET_NAME";
    createDataset(projectId, displayName);
  }

  // Create a dataset
  static void createDataset(String projectId, String displayName)
      throws IOException, ExecutionException, InterruptedException {
    // 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 (AutoMlClient client = AutoMlClient.create()) {
      // A resource that represents Google Cloud Platform location.
      LocationName projectLocation = LocationName.of(projectId, "us-central1");

      // Specify the classification type
      // Types:
      // MultiLabel: Multiple labels are allowed for one example.
      // MultiClass: At most one label is allowed per example.
      ClassificationType classificationType = ClassificationType.MULTILABEL;
      ImageClassificationDatasetMetadata metadata =
          ImageClassificationDatasetMetadata.newBuilder()
              .setClassificationType(classificationType)
              .build();
      Dataset dataset =
          Dataset.newBuilder()
              .setDisplayName(displayName)
              .setImageClassificationDatasetMetadata(metadata)
              .build();
      OperationFuture<Dataset, OperationMetadata> future =
          client.createDatasetAsync(projectLocation, dataset);

      Dataset createdDataset = future.get();

      // Display the dataset information.
      System.out.format("Dataset name: %s\n", createdDataset.getName());
      // To get the dataset id, you have to parse it out of the `name` field. As dataset Ids are
      // required for other methods.
      // Name Form: `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}`
      String[] names = createdDataset.getName().split("/");
      String datasetId = names[names.length - 1];
      System.out.format("Dataset id: %s\n", datasetId);
    }
  }
}

Node.js

Si quieres obtener más información, consulta la documentación de referencia de la API de AutoML Vision Node.js.

Para autenticarte en AutoML Vision, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const displayName = 'YOUR_DISPLAY_NAME';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function createDataset() {
  // Construct request
  // Specify the classification type
  // Types:
  // MultiLabel: Multiple labels are allowed for one example.
  // MultiClass: At most one label is allowed per example.
  const request = {
    parent: client.locationPath(projectId, location),
    dataset: {
      displayName: displayName,
      imageClassificationDatasetMetadata: {
        classificationType: 'MULTILABEL',
      },
    },
  };

  // Create dataset
  const [operation] = await client.createDataset(request);

  // Wait for operation to complete.
  const [response] = await operation.promise();

  console.log(`Dataset name: ${response.name}`);
  console.log(`
    Dataset id: ${
      response.name
        .split('/')
        [response.name.split('/').length - 1].split('\n')[0]
    }`);
}

createDataset();

Solicitud

Ejecuta la función create_dataset para crear un conjunto de datos vacío. Debes modificar las siguientes líneas de código:

  • Establece project_id para tu PROJECT_ID.
  • Establece el display_name para el conjunto de datos (flowers).

  • Cambia MULTILABEL a MULTICLASS

Python

python3 vision_classification_create_dataset.py

Java

mvn compile exec:java -Dexec.mainClass="com.example.automl.VisionClassificationCreateDataset"

Node.js

node vision_classification_create_dataset.js

Respuesta

La respuesta incluye los detalles del conjunto de datos recién creado, incluido el ID del conjunto de datos que utilizarás para hacer referencia al conjunto de datos en solicitudes futuras. Te recomendamos que configures una variable de entorno DATASET_ID en el valor del ID del conjunto de datos mostrado.

Dataset name: projects/216065747626/locations/us-central1/datasets/ICN7372141011130533778
Dataset id: ICN7372141011130533778
Dataset display name: flowers
Image classification dataset specification:
       classification_type: MULTICLASS
Dataset example count: 0
Dataset create time:
       seconds: 1530251987
       nanos: 216586000

Paso 2: Importa imágenes al conjunto de datos

El siguiente paso es propagar el conjunto de datos con imágenes de entrenamiento etiquetadas con las etiquetas de destino.

La interfaz de la función import_data toma como entrada un archivo CSV que enumera las ubicaciones de todas las imágenes de entrenamiento y la etiqueta adecuada para cada una. Consulta Prepara los datos para obtener detalles sobre el formato requerido. Para este instructivo, usaremos las imágenes etiquetadas que copiaste en el bucket de Cloud Storage, que se enumeran en gs://$PROJECT_ID-vcm/csv/all_data.csv.

Copia el código

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# dataset_id = "YOUR_DATASET_ID"
# path = "gs://YOUR_BUCKET_ID/path/to/data.csv"

client = automl.AutoMlClient()
# Get the full path of the dataset.
dataset_full_id = client.dataset_path(project_id, "us-central1", dataset_id)
# Get the multiple Google Cloud Storage URIs
input_uris = path.split(",")
gcs_source = automl.GcsSource(input_uris=input_uris)
input_config = automl.InputConfig(gcs_source=gcs_source)
# Import data from the input URI
response = client.import_data(name=dataset_full_id, input_config=input_config)

print("Processing import...")
print(f"Data imported. {response.result()}")

Java

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.DatasetName;
import com.google.cloud.automl.v1.GcsSource;
import com.google.cloud.automl.v1.InputConfig;
import com.google.cloud.automl.v1.OperationMetadata;
import com.google.protobuf.Empty;
import java.io.IOException;
import java.util.Arrays;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

class ImportDataset {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String datasetId = "YOUR_DATASET_ID";
    String path = "gs://BUCKET_ID/path_to_training_data.csv";
    importDataset(projectId, datasetId, path);
  }

  // Import a dataset
  static void importDataset(String projectId, String datasetId, String path)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // 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 (AutoMlClient client = AutoMlClient.create()) {
      // Get the complete path of the dataset.
      DatasetName datasetFullId = DatasetName.of(projectId, "us-central1", datasetId);

      // Get multiple Google Cloud Storage URIs to import data from
      GcsSource gcsSource =
          GcsSource.newBuilder().addAllInputUris(Arrays.asList(path.split(","))).build();

      // Import data from the input URI
      InputConfig inputConfig = InputConfig.newBuilder().setGcsSource(gcsSource).build();
      System.out.println("Processing import...");

      // Start the import job
      OperationFuture<Empty, OperationMetadata> operation =
          client.importDataAsync(datasetFullId, inputConfig);

      System.out.format("Operation name: %s%n", operation.getName());

      // If you want to wait for the operation to finish, adjust the timeout appropriately. The
      // operation will still run if you choose not to wait for it to complete. You can check the
      // status of your operation using the operation's name.
      Empty response = operation.get(45, TimeUnit.MINUTES);
      System.out.format("Dataset imported. %s%n", response);
    } catch (TimeoutException e) {
      System.out.println("The operation's polling period was not long enough.");
      System.out.println("You can use the Operation's name to get the current status.");
      System.out.println("The import job is still running and will complete as expected.");
      throw e;
    }
  }
}

Node.js

Si quieres obtener más información, consulta la documentación de referencia de la API de AutoML Vision Node.js.

Para autenticarte en AutoML Vision, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const datasetId = 'YOUR_DISPLAY_ID';
// const path = 'gs://BUCKET_ID/path_to_training_data.csv';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function importDataset() {
  // Construct request
  const request = {
    name: client.datasetPath(projectId, location, datasetId),
    inputConfig: {
      gcsSource: {
        inputUris: path.split(','),
      },
    },
  };

  // Import dataset
  console.log('Proccessing import');
  const [operation] = await client.importData(request);

  // Wait for operation to complete.
  const [response] = await operation.promise();
  console.log(`Dataset imported: ${response}`);
}

importDataset();

Solicitud

Ejecuta la función import_data para importar el contenido de entrenamiento. El primer fragmento de código que se cambiará es el ID del conjunto de datos del paso anterior y el segundo es el URI de all_data.csv. Debes modificar las siguientes líneas de código:

  • Establece el project_id en tu PROJECT_ID.
  • Establece el dataset_id para el conjunto de datos (a partir del resultado del paso anterior).

  • Establece la path que corresponde al URI del (gs://YOUR_PROJECT_ID-vcm/csv/all_data.csv).

  • python3 import_dataset.py {Python}

  • mvn compile exec:java -Dexec.mainClass="com.example.automl.ImportDataset" {Java}

  • node import_dataset.js {Node.js}

Respuesta

Processing import...
Dataset imported.

Paso 3: Crea (entrena) el modelo

Ahora que tienes un conjunto de datos con imágenes de entrenamiento etiquetadas, puedes entrenar un modelo nuevo.

Copia el código

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# dataset_id = "YOUR_DATASET_ID"
# display_name = "your_models_display_name"

client = automl.AutoMlClient()

# A resource that represents Google Cloud Platform location.
project_location = f"projects/{project_id}/locations/us-central1"
# Leave model unset to use the default base model provided by Google
# train_budget_milli_node_hours: The actual train_cost will be equal or
# less than this value.
# https://cloud.google.com/automl/docs/reference/rpc/google.cloud.automl.v1#imageclassificationmodelmetadata
metadata = automl.ImageClassificationModelMetadata(
    train_budget_milli_node_hours=24000
)
model = automl.Model(
    display_name=display_name,
    dataset_id=dataset_id,
    image_classification_model_metadata=metadata,
)

# Create a model with the model metadata in the region.
response = client.create_model(parent=project_location, model=model)

print(f"Training operation name: {response.operation.name}")
print("Training started...")

Java

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ImageClassificationModelMetadata;
import com.google.cloud.automl.v1.LocationName;
import com.google.cloud.automl.v1.Model;
import com.google.cloud.automl.v1.OperationMetadata;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class VisionClassificationCreateModel {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String datasetId = "YOUR_DATASET_ID";
    String displayName = "YOUR_DATASET_NAME";
    createModel(projectId, datasetId, displayName);
  }

  // Create a model
  static void createModel(String projectId, String datasetId, String displayName)
      throws IOException, ExecutionException, InterruptedException {
    // 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 (AutoMlClient client = AutoMlClient.create()) {
      // A resource that represents Google Cloud Platform location.
      LocationName projectLocation = LocationName.of(projectId, "us-central1");
      // Set model metadata.
      ImageClassificationModelMetadata metadata =
          ImageClassificationModelMetadata.newBuilder().setTrainBudgetMilliNodeHours(24000).build();
      Model model =
          Model.newBuilder()
              .setDisplayName(displayName)
              .setDatasetId(datasetId)
              .setImageClassificationModelMetadata(metadata)
              .build();

      // Create a model with the model metadata in the region.
      OperationFuture<Model, OperationMetadata> future =
          client.createModelAsync(projectLocation, model);
      // OperationFuture.get() will block until the model is created, which may take several hours.
      // You can use OperationFuture.getInitialFuture to get a future representing the initial
      // response to the request, which contains information while the operation is in progress.
      System.out.format("Training operation name: %s\n", future.getInitialFuture().get().getName());
      System.out.println("Training started...");
    }
  }
}

Node.js

Si quieres obtener más información, consulta la documentación de referencia de la API de AutoML Vision Node.js.

Para autenticarte en AutoML Vision, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const dataset_id = 'YOUR_DATASET_ID';
// const displayName = 'YOUR_DISPLAY_NAME';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function createModel() {
  // Construct request
  const request = {
    parent: client.locationPath(projectId, location),
    model: {
      displayName: displayName,
      datasetId: datasetId,
      imageClassificationModelMetadata: {
        trainBudgetMilliNodeHours: 24000,
      },
    },
  };

  // Don't wait for the LRO
  const [operation] = await client.createModel(request);
  console.log(`Training started... ${operation}`);
  console.log(`Training operation name: ${operation.name}`);
}

createModel();

Solicitud

Llama a la función create_model para crear un modelo. El ID del conjunto de datos es de los pasos anteriores. Debes modificar las siguientes líneas de código:

  • Establece el project_id en tu PROJECT_ID.
  • Establece el dataset_id para el conjunto de datos (a partir del resultado del paso anterior).

  • Establece el display_name para tu modelo (flowers_model).

  • python3 vision_classification_create_model.py {Python}

  • mvn compile exec:java -Dexec.mainClass="com.example.automl.VisionClassificationCreateModel" {Java}

  • node vision_classification_create_model.js {Node.js}

Respuesta

La función create_model inicia una operación de entrenamiento y, luego, imprime el nombre de la operación. El entrenamiento se realiza de forma asíncrona y puede llevar un tiempo en completarse, por lo que puedes usar el ID de la operación para verificar el estado del entrenamiento. Cuando finaliza el entrenamiento, create_model muestra el ID del modelo. Al igual que con el ID del conjunto de datos, puedes establecer una variable de entorno MODEL_ID según el valor del ID del modelo que se muestra.

Training operation name: projects/216065747626/locations/us-central1/operations/ICN3007727620979824033
Training started...
Model name: projects/216065747626/locations/us-central1/models/ICN7683346839371803263
Model id: ICN7683346839371803263
Model display name: flowers_model
Image classification model metadata:
Training budget: 1
Training cost: 1
Stop reason:
Base model id:
Model create time:
        seconds: 1529649600
        nanos: 966000000
Model deployment state: deployed

Paso 4: Evaluar el modelo

Después del entrenamiento, puedes evaluar la preparación del modelo mediante la revisión de su puntuación F1, precisión y recuperación.

La función display_evaluation toma el ID del modelo como parámetro.

Copia el código

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# model_id = "YOUR_MODEL_ID"

client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, "us-central1", model_id)

print("List of model evaluations:")
for evaluation in client.list_model_evaluations(parent=model_full_id, filter=""):
    print(f"Model evaluation name: {evaluation.name}")
    print(f"Model annotation spec id: {evaluation.annotation_spec_id}")
    print(f"Create Time: {evaluation.create_time}")
    print(f"Evaluation example count: {evaluation.evaluated_example_count}")
    print(
        "Classification model evaluation metrics: {}".format(
            evaluation.classification_evaluation_metrics
        )
    )

Java


import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ListModelEvaluationsRequest;
import com.google.cloud.automl.v1.ModelEvaluation;
import com.google.cloud.automl.v1.ModelName;
import java.io.IOException;

class ListModelEvaluations {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    listModelEvaluations(projectId, modelId);
  }

  // List model evaluations
  static void listModelEvaluations(String projectId, String modelId) throws IOException {
    // 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 (AutoMlClient client = AutoMlClient.create()) {
      // Get the full path of the model.
      ModelName modelFullId = ModelName.of(projectId, "us-central1", modelId);
      ListModelEvaluationsRequest modelEvaluationsrequest =
          ListModelEvaluationsRequest.newBuilder().setParent(modelFullId.toString()).build();

      // List all the model evaluations in the model by applying filter.
      System.out.println("List of model evaluations:");
      for (ModelEvaluation modelEvaluation :
          client.listModelEvaluations(modelEvaluationsrequest).iterateAll()) {

        System.out.format("Model Evaluation Name: %s\n", modelEvaluation.getName());
        System.out.format("Model Annotation Spec Id: %s", modelEvaluation.getAnnotationSpecId());
        System.out.println("Create Time:");
        System.out.format("\tseconds: %s\n", modelEvaluation.getCreateTime().getSeconds());
        System.out.format("\tnanos: %s", modelEvaluation.getCreateTime().getNanos() / 1e9);
        System.out.format(
            "Evalution Example Count: %d\n", modelEvaluation.getEvaluatedExampleCount());
        System.out.format(
            "Classification Model Evaluation Metrics: %s\n",
            modelEvaluation.getClassificationEvaluationMetrics());
      }
    }
  }
}

Node.js

Si quieres obtener más información, consulta la documentación de referencia de la API de AutoML Vision Node.js.

Para autenticarte en AutoML Vision, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const modelId = 'YOUR_MODEL_ID';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function listModelEvaluations() {
  // Construct request
  const request = {
    parent: client.modelPath(projectId, location, modelId),
    filter: '',
  };

  const [response] = await client.listModelEvaluations(request);

  console.log('List of model evaluations:');
  for (const evaluation of response) {
    console.log(`Model evaluation name: ${evaluation.name}`);
    console.log(`Model annotation spec id: ${evaluation.annotationSpecId}`);
    console.log(`Model display name: ${evaluation.displayName}`);
    console.log('Model create time');
    console.log(`\tseconds ${evaluation.createTime.seconds}`);
    console.log(`\tnanos ${evaluation.createTime.nanos / 1e9}`);
    console.log(
      `Evaluation example count: ${evaluation.evaluatedExampleCount}`
    );
    console.log(
      `Classification model evaluation metrics: ${evaluation.classificationEvaluationMetrics}`
    );
  }
}

listModelEvaluations();

Solicitud

Realiza una solicitud para mostrar el rendimiento general de la evaluación del modelo mediante la ejecución de la siguiente solicitud. Debes modificar las siguientes líneas de código:

  • Establece el project_id en tu PROJECT_ID.

  • Establece model_id para el ID de tu modelo.

  • python3 list_model_evaluations.py {Python}

  • mvn compile exec:java -Dexec.mainClass="com.example.automl.ListModelEvaluations" {Java}

  • node list_model_evaluations.js {Node.js}

Respuesta

Si la puntuación de precisión y recuperación es demasiado baja, puedes fortalecer el conjunto de datos de entrenamiento y volver a entrenar a tu modelo. Para obtener más información, consulta Evalúa modelos.

Precision and recall are based on a score threshold of 0.5
Model Precision: 96.3%
Model Recall: 95.7%
Model F1 score: 96.0%
Model Precision@1: 96.33%
Model Recall@1: 95.74%
Model F1 score@1: 96.04%

Paso 5: Usa un modelo para hacer una predicción

Cuando el modelo personalizado cumpla con tus estándares de calidad, podrás usarlo para clasificar imágenes de flores nuevas.

Copia el código

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# model_id = "YOUR_MODEL_ID"
# file_path = "path_to_local_file.jpg"

prediction_client = automl.PredictionServiceClient()

# Get the full path of the model.
model_full_id = automl.AutoMlClient.model_path(project_id, "us-central1", model_id)

# Read the file.
with open(file_path, "rb") as content_file:
    content = content_file.read()

image = automl.Image(image_bytes=content)
payload = automl.ExamplePayload(image=image)

# params is additional domain-specific parameters.
# score_threshold is used to filter the result
# https://cloud.google.com/automl/docs/reference/rpc/google.cloud.automl.v1#predictrequest
params = {"score_threshold": "0.8"}

request = automl.PredictRequest(name=model_full_id, payload=payload, params=params)
response = prediction_client.predict(request=request)

print("Prediction results:")
for result in response.payload:
    print(f"Predicted class name: {result.display_name}")
    print(f"Predicted class score: {result.classification.score}")

Java

import com.google.cloud.automl.v1.AnnotationPayload;
import com.google.cloud.automl.v1.ExamplePayload;
import com.google.cloud.automl.v1.Image;
import com.google.cloud.automl.v1.ModelName;
import com.google.cloud.automl.v1.PredictRequest;
import com.google.cloud.automl.v1.PredictResponse;
import com.google.cloud.automl.v1.PredictionServiceClient;
import com.google.protobuf.ByteString;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

class VisionClassificationPredict {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String filePath = "path_to_local_file.jpg";
    predict(projectId, modelId, filePath);
  }

  static void predict(String projectId, String modelId, String filePath) throws IOException {
    // 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 (PredictionServiceClient client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);
      ByteString content = ByteString.copyFrom(Files.readAllBytes(Paths.get(filePath)));
      Image image = Image.newBuilder().setImageBytes(content).build();
      ExamplePayload payload = ExamplePayload.newBuilder().setImage(image).build();
      PredictRequest predictRequest =
          PredictRequest.newBuilder()
              .setName(name.toString())
              .setPayload(payload)
              .putParams(
                  "score_threshold", "0.8") // [0.0-1.0] Only produce results higher than this value
              .build();

      PredictResponse response = client.predict(predictRequest);

      for (AnnotationPayload annotationPayload : response.getPayloadList()) {
        System.out.format("Predicted class name: %s\n", annotationPayload.getDisplayName());
        System.out.format(
            "Predicted class score: %.2f\n", annotationPayload.getClassification().getScore());
      }
    }
  }
}

Node.js

Si quieres obtener más información, consulta la documentación de referencia de la API de AutoML Vision Node.js.

Para autenticarte en AutoML Vision, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const modelId = 'YOUR_MODEL_ID';
// const filePath = 'path_to_local_file.jpg';

// Imports the Google Cloud AutoML library
const {PredictionServiceClient} = require('@google-cloud/automl').v1;
const fs = require('fs');

// Instantiates a client
const client = new PredictionServiceClient();

// Read the file content for translation.
const content = fs.readFileSync(filePath);

async function predict() {
  // Construct request
  // params is additional domain-specific parameters.
  // score_threshold is used to filter the result
  const request = {
    name: client.modelPath(projectId, location, modelId),
    payload: {
      image: {
        imageBytes: content,
      },
    },
  };

  const [response] = await client.predict(request);

  for (const annotationPayload of response.payload) {
    console.log(`Predicted class name: ${annotationPayload.displayName}`);
    console.log(
      `Predicted class score: ${annotationPayload.classification.score}`
    );
  }
}

predict();

Solicitud

Para la función predict, debes modificar las siguientes líneas de código:

  • Establece el project_id en tu PROJECT_ID.
  • Establece model_id en el ID del modelo.

  • Establece la file_path para el archivo descargado ("resources/test.png").

  • python3 vision_classification_predict.py {Python}

  • mvn compile exec:java -Dexec.mainClass="com.example.automl.VisionClassificationPredict" {Java}

  • node vision_classification_predict.js {Node.js}

Respuesta

La función muestra la puntuación de clasificación que indica el grado de coincidencia de la imagen con cada categoría, por encima del umbral de confianza de 0.7.

Prediction results:
Predicted class name: dandelion
Predicted class score: 0.9702693223953247

Paso 6: Borra el modelo

Cuando hayas terminado de usar este modelo de muestra, puedes borrarlo de forma permanente. Ya no podrás usar el modelo para predicción.

Copia el código

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# model_id = "YOUR_MODEL_ID"

client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, "us-central1", model_id)
response = client.delete_model(name=model_full_id)

print(f"Model deleted. {response.result()}")

Java

import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ModelName;
import com.google.protobuf.Empty;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class DeleteModel {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    deleteModel(projectId, modelId);
  }

  // Delete a model
  static void deleteModel(String projectId, String modelId)
      throws IOException, ExecutionException, InterruptedException {
    // 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 (AutoMlClient client = AutoMlClient.create()) {
      // Get the full path of the model.
      ModelName modelFullId = ModelName.of(projectId, "us-central1", modelId);

      // Delete a model.
      Empty response = client.deleteModelAsync(modelFullId).get();

      System.out.println("Model deletion started...");
      System.out.println(String.format("Model deleted. %s", response));
    }
  }
}

Node.js

Si quieres obtener más información, consulta la documentación de referencia de la API de AutoML Vision Node.js.

Para autenticarte en AutoML Vision, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const modelId = 'YOUR_MODEL_ID';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function deleteModel() {
  // Construct request
  const request = {
    name: client.modelPath(projectId, location, modelId),
  };

  const [response] = await client.deleteModel(request);
  console.log(`Model deleted: ${response}`);
}

deleteModel();

Solicitud

Realiza una solicitud con el tipo de operación delete_model para borrar un modelo que creaste. Debes modificar las siguientes líneas de código:

  • Establece el project_id en tu PROJECT_ID.

  • Establece model_id para el ID de tu modelo.

  • python3 delete_model.py {Python}

  • mvn compile exec:java -Dexec.mainClass="com.example.automl.DeleteModel" {Java}

  • node delete_model.js {Node.js}

Respuesta

Model deleted.