Anleitung zur AutoML Vision API

In dieser Anleitung wird gezeigt, wie Sie ein neues Modell mit eigenen Trainingsbildern erstellen, die Ergebnisse bewerten und die Klassifizierung der Testbilder mithilfe von AutoML Vision vorhersagen.

Es wird ein Dataset mit Bildern von fünf unterschiedlichen Blumenarten verwendet: Sonnenblumen, Tulpen, Gänseblümchen, Rosen und Löwenzahn. Sie erfahren, wie Sie ein benutzerdefiniertes Modell trainieren, die Modellleistung bewerten und neue Bilder mithilfe des benutzerdefinierten Modells klassifizieren.

Codebeispiele ansehen: Die meisten Codebeispiele in dieser Anleitung stammen aus größeren Codedateien in GitHub. Sie können die vollständige Datei, aus der ein Codebeispiel stammt, ansehen und herunterladen. Klicken Sie einfach über einem Beispiel auf die Schaltfläche "Auf GitHub ansehen".

Voraussetzungen

Projektumgebung konfigurieren

Region: Derzeit müssen sich Projektressourcen in der Region us-central1 befinden, um diese API verwenden zu können.

1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

   Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.

   Zur Projektauswahl

3. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

4. AutoML Vision APIs aktivieren.

   Aktivieren Sie die APIs

5. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

   Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.

   Zur Projektauswahl

6. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

7. AutoML Vision APIs aktivieren.

   Aktivieren Sie die APIs

8. Installieren Sie die Google Cloud CLI.
9. Folgen Sie der Anleitung zum Erstellen eines Dienstkontos und Herunterladen einer Schlüsseldatei.
10. Legen Sie die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS so fest, dass sie auf die Schlüsseldatei des Dienstkontos verweist. Die Schlüsseldatei haben Sie beim Erstellen des Dienstkontos heruntergeladen. Beispiel:

    export GOOGLE_APPLICATION_CREDENTIALS=KEY_FILE

11. Fügen Sie das neue Dienstkonto mit folgenden Befehlen zur IAM-Rolle AutoML Editor hinzu. Ersetzen Sie PROJECT_ID durch den Namen Ihres Google Cloud-Projekts und SERVICE_ACCOUNT_NAME durch den Namen Ihres neuen Dienstkontos, z. B. [e-mail]:

    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. Gewähren Sie dem AutoML Vision-Dienstkonto Zugriff auf Ihre Google Cloud-Projektressourcen.

    gcloud projects add-iam-policy-binding PROJECT_ID \
     --member="serviceAccount:[e-mail]" \
     --role="roles/storage.admin"

13. Installieren Sie die Clientbibliothek.
14. Legen Sie die Umgebungsvariablen PROJECT_ID und REGION_NAME fest.
    
    Ersetzen Sie PROJECT_ID durch die Projekt-ID Ihres Google Cloud-Projekts. AutoML Vision erfordert derzeit den Standort us-central1.

    export PROJECT_ID="PROJECT_ID"
    export REGION_NAME="us-central1"

15. Erstellen Sie einen Cloud Storage-Bucket zum Speichern der Dokumente, die Sie zum Trainieren Ihres AutoML-Modells verwenden.
    
    Der Bucket-Name muss das Format $PROJECT_ID-vcm haben. Mit dem folgenden Befehl wird ein Speicher-Bucket in der Region us-central1 mit der Bezeichnung $PROJECT_ID-vcm erstellt.

    gsutil mb -p PROJECT_ID -c regional -l us-central1 gs://PROJECT_ID-vcm/

16. Legen Sie die Variable BUCKET fest.

    export BUCKET=PROJECT_ID-vcm

17. Kopieren Sie das öffentlich verfügbare Dataset von Blumenbildern aus gs://cloud-samples-data/img/flower_photos/ in Ihren Google Cloud Storage-Bucket.
    
    Geben Sie in der Cloud Shell-Sitzung Folgendes ein:

    gsutil -m cp -R gs://cloud-samples-data/ai-platform/flowers/ gs://BUCKET/img/

    Das Kopieren der Datei dauert ungefähr 20 Minuten.

    Mit diesem Befehl wird auch die Datei all_data.csv kopiert, in der die ursprünglichen Dateinamen und deren Labels aufgelistet werden.

18. Das Beispiel-Dataset enthält eine CSV-Datei mit den Speicherorten und Labels für jedes Bild. Weitere Informationen zum erforderlichen Format finden Sie unter Trainingsdaten vorbereiten. Aktualisieren Sie die CSV-Datei so, dass sie auf die Dateien in Ihrem Bucket verweist:

    gsutil cat gs://BUCKET/img/flowers/all_data.csv | sed "s:cloud-ml-data/img/flower_photos/:BUCKET/img/flowers/:" > all_data.csv

    Kopieren Sie dann die aktualisierte CSV-Datei in Ihren Bucket:

    gsutil cp all_data.csv gs://BUCKET/csv/

Speicherorte der Quellcodedateien

Sie können den Quellcode aus dem unten angegebenen Speicherort herunterladen. Nach dem Download können Sie den Quellcode in den AutoML Vision-Projektordner kopieren.

Python

Die Anleitung besteht aus diesen Python-Dateien:

• vision_classification_create_dataset.py – Enthält Features zum Erstellen eines Datasets
• import_dataset.py – Enthält Features zum Importieren eines Datasets
• vision_classification_create_model.py – Enthält Features zum Erstellen eines Modells
• list_model_evaluations.py – Enthält Features zum Auflisten von Modellbewertungen
• vision_classification_predict.py – Enthält Features im Zusammenhang mit Vorhersagen
• delete_model.py – Enthält Features zum Löschen eines Modells

Java

Die Anleitung besteht aus diesen Java-Dateien:

• VisionClassificationCreateDataset.java – Enthält Features zum Erstellen eines Datasets
• ImportDataset.java – Enthält Features zum Importieren eines Datasets
• VisionClassificationCreateModel.java – Enthält Features zum Erstellen eines Modells
• ListModelEvaluations.java – Enthält Features zum Auflisten von Modellbewertungen
• VisionClassificationPredict.java – Enthält Features im Zusammenhang mit Vorhersagen
• DeleteModel.java – Enthält Features zum Löschen eines Modells

Node.js

Die Anleitung besteht aus diesen Node.js-Dateien:

• vision_classification_create_dataset.js – Enthält Features zum Erstellen eines Datasets
• import_dataset.js – Enthält Features zum Importieren eines Datasets
• vision_classification_create_model.js – Enthält Features zum Erstellen eines Modells
• list_model_evaluations.js – Enthält Features zum Auflisten von Modellbewertungen
• vision_classification_predict.js – Enthält Features im Zusammenhang mit Vorhersagen
• delete_model.js – Enthält Features zum Löschen eines Modells

Anwendung ausführen

Schritt 1: Blumen-Dataset erstellen

Der erste Schritt zum Erstellen eines benutzerdefinierten Modells besteht darin, ein leeres Dataset zu erstellen, das mit den Trainingsdaten für das Modell gefüllt wird. Wenn Sie ein Dataset erstellen, geben Sie den Klassifizierungstyp an, den das benutzerdefinierte Modell ausführen soll:

• MULTICLASS weist jedem klassifizierten Bild ein einzelnes Label zu
• MULTILABEL kann einem Bild mehrere Labels zuweisen.

In dieser Anleitung wird ein Dataset mit dem Namen flowers erstellt und MULTICLASS verwendet.

Code kopieren

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

Weitere Informationen finden Sie in der AutoML Vision Node.js API-Referenzdokumentation.

Richten Sie zur Authentifizierung bei AutoML Vision Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Anfrage

Führen Sie das Feature create_dataset aus, um ein leeres Dataset zu erstellen. Sie müssen die folgenden Codezeilen ändern:

• Setzen Sie die project_id auf Ihre PROJECT_ID.
• Legen Sie display_name für das Dataset flowers fest.

• Ändern Sie MULTILABEL zu 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

Antwort

Die Antwort enthält die Details des neu erstellten Datasets, darunter die Dataset-ID, mit der Sie bei zukünftigen Anfragen auf das Dataset verweisen. Es wird empfohlen, die Umgebungsvariable DATASET_ID auf den zurückgegebenen Wert der Dataset-ID festzulegen.

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

Schritt 2: Bilder in das Dataset importieren

Der nächste Schritt besteht darin, das Dataset mit Trainingsbildern zu füllen, die mit den Ziellabels versehen sind.

Die Feature-Schnittstelle import_data übernimmt als Eingabe eine CSV-Datei, in der die Speicherorte aller Trainingsbilder und das richtige Label für jedes Trainingsbild aufgeführt sind. Weitere Informationen zum erforderlichen Format finden Sie unter Daten vorbereiten. In dieser Anleitung werden die mit Labels versehenen Bilder verwendet, die Sie in Ihren Cloud Storage-Bucket kopiert haben. In gs://$PROJECT_ID-vcm/csv/all_data.csv finden Sie eine Liste dieser Bilder.

Code kopieren

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

Weitere Informationen finden Sie in der AutoML Vision Node.js API-Referenzdokumentation.

Richten Sie zur Authentifizierung bei AutoML Vision Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Anfrage

Führen Sie das Feature import_data aus, um den Trainingsinhalt zu importieren. Der erste zu ändernde Code ist die Dataset-ID aus dem vorherigen Schritt, der zweite ist der URI von all_data.csv. Sie müssen die folgenden Codezeilen ändern:

• Setzen Sie project_id auf PROJECT_ID.
• Legen Sie dataset_id für das Dataset fest (aus der Ausgabe des vorherigen Schritts).

• Legen Sie den Pfadparameter path fest. Das ist der URI von 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}

Antwort

Processing import...
Dataset imported.

Schritt 3: Modell erstellen (trainieren)

Da Sie nun ein Dataset aus Trainingsbildern mit Labels haben, können Sie ein neues Modell trainieren.

Hinweis: Für Bildklassifizierungsmodelle ist fortsetzbares Training möglich. Weitere Informationen zum inkrementellen Training von Bildklassifizierungsmodellen finden Sie unter AutoML-Bildklassifizierungsmodell trainieren.

Code kopieren

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

Weitere Informationen finden Sie in der AutoML Vision Node.js API-Referenzdokumentation.

Richten Sie zur Authentifizierung bei AutoML Vision Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Anfrage

Rufen Sie die Funktion create_model auf, um ein Modell zu erstellen. Die Dataset-ID stammt aus den vorherigen Schritten. Sie müssen die folgenden Codezeilen ändern:

• Setzen Sie project_id auf PROJECT_ID.
• Legen Sie dataset_id für das Dataset fest (aus der Ausgabe des vorherigen Schritts).

• Legen Sie display_name für Ihr Modell flowers_model fest.

• 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}

Antwort

Das Feature create_model startet einen Trainingsvorgang und gibt den Namen des Vorgangs aus. Das Training erfolgt asynchron und kann einige Zeit in Anspruch nehmen. Anhand der Vorgangs-ID können Sie den Trainingsstatus abrufen. Nach Abschluss des Trainings gibt create_model die Modell-ID zurück. Wie bei der Dataset-ID kann es auch hier sinnvoll sein, eine Umgebungsvariable MODEL_ID für den zurückgegebenen Wert der Modell-ID festzulegen.

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

Schritt 4: Modell bewerten

Nach dem Training können Sie die Bereitschaft des Modells bewerten. Dazu prüfen Sie die Genauigkeit, die Trefferquote und den F1-Wert.

Das Feature display_evaluation verwendet die Modell-ID als Parameter.

Code kopieren

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

Weitere Informationen finden Sie in der AutoML Vision Node.js API-Referenzdokumentation.

Richten Sie zur Authentifizierung bei AutoML Vision Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Anfrage

Stellen Sie eine Anfrage, um die Gesamtbewertung des Modells aufzurufen. Führen Sie zu diesem Zweck die folgende Anfrage aus. Sie müssen die folgenden Codezeilen ändern:

• Setzen Sie project_id auf PROJECT_ID.

• Setzen Sie die model_id auf die ID Ihres Modells.

• python3 list_model_evaluations.py {Python}

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

• node list_model_evaluations.js {Node.js}

Antwort

Wenn die Werte für Genauigkeit und Trefferquote zu niedrig sind, können Sie das Trainings-Dataset verbessern und Ihr Modell neu trainieren. Weitere Informationen finden Sie unter Modelle bewerten.

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%

Schritt 5: Modell verwenden, um eine Vorhersage zu treffen

Wenn Ihr benutzerdefiniertes Modell Ihren Qualitätsstandards entspricht, können Sie damit neue Blumenbilder klassifizieren.

Code kopieren

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

Weitere Informationen finden Sie in der AutoML Vision Node.js API-Referenzdokumentation.

Richten Sie zur Authentifizierung bei AutoML Vision Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Anfrage

Für das Feature predict müssen Sie die folgenden Codezeilen ändern:

• Setzen Sie project_id auf PROJECT_ID.
• Setzen Sie die model_id auf die ID Ihres Modells.

• Setzen Sie file_path auf die heruntergeladene Datei: 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}

Antwort

Die Funktion gibt den Klassifizierungswert zurück. Der Klassifizierungswert gibt an, wie gut ein Bild mit einer Kategorie übereinstimmt und dabei den angegebenen Konfidenzschwellenwert von 0,7 überschreitet.

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

Schritt 6: Modell löschen

Wenn Sie dieses Beispielmodell nicht mehr verwenden, können Sie es dauerhaft löschen. Anschließend können Sie das Modell nicht mehr für Vorhersagen verwenden.

Code kopieren

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

Weitere Informationen finden Sie in der AutoML Vision Node.js API-Referenzdokumentation.

Richten Sie zur Authentifizierung bei AutoML Vision Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Anfrage

Stellen Sie eine Anfrage mit dem Vorgangstyp delete_model, um ein Modell zu löschen. Übergeben Sie die Modell-ID als Argument.

• Setzen Sie project_id auf PROJECT_ID.

• Setzen Sie die model_id auf die ID Ihres Modells.

• python3 delete_model.py {Python}

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

• node delete_model.js {Node.js}

Antwort

Model deleted.