Questa versione legacy di AutoML Video Intelligence è ritirata e non sarà più disponibile su Google Cloud dopo il 23 gennaio 2024. Tutte le funzionalità della versione precedente di AutoML Video Intelligence e le nuove funzionalità sono disponibili sulla piattaforma Vertex AI. Per scoprire come eseguire la migrazione delle risorse, vedi Migrazione a Vertex AI.

Monitoraggio degli oggetti nei video

Dopo aver creato (addestrato) un modello, puoi richiedere una previsione per uno o più video utilizzando il metodo batchPredict. Fornisci un file CSV con un elenco di video per il metodo batchPredict. Il metodo batchPredict annota i video rilevando e monitorando gli oggetti previsti dal modello.

La durata massima di un modello è due anni. Dopo due anni, devi creare e addestrare un nuovo modello per continuare ad annotare i video.

Esempio di previsione

Per richiedere un batch di previsioni da AutoML Video Object Tracking, crea un file CSV che elenchi i percorsi Cloud Storage dei video da annotare. Puoi anche specificare un'ora di inizio e di fine per indicare ad AutoML Video Object Tracking di annotare solo un segmento del video. L'ora di inizio deve essere pari a zero o superiore e deve essere precedente all'ora di fine. L'ora di fine deve essere superiore all'ora di inizio e inferiore o uguale alla durata del video.

L'esempio seguente mostra come annotare un intero video specificando un'ora di inizio e di fine come 0,inf.

gs://my-videos-vcm/cow_video.mp4,0,inf
gs://my-videos-vcm/bird_video.mp4,10.00000,15.50000

Devi inoltre specificare un percorso file di output in cui AutoML Video Object Tracking deve scrivere i risultati delle previsioni dal modello. Questo percorso deve essere un bucket e un oggetto Cloud Storage in cui disponi delle autorizzazioni di scrittura.

Ogni video può durare fino a 3 ore con una dimensione massima dei file di 50 GB. AutoML Video Object Tracking può generare previsioni per circa 100 ore di video in 12 ore di elaborazione.

UI web

Apri l'interfaccia utente di monitoraggio degli oggetti video AutoML.
Fai clic sul modello che vuoi utilizzare dall'elenco visualizzato.
Nella scheda Testa e utilizza del modello, segui questi passaggi:
- In Testa il modello, seleziona un file CSV da utilizzare per la previsione. Il file CSV deve fornire un elenco di video a cui vuoi aggiungere annotazioni.
- Sempre in Testa il modello, seleziona una directory all'interno del bucket Cloud Storage per ricevere i risultati delle annotazioni.
  
  Potresti voler creare una cartella "risultati" specifica nel tuo bucket Cloud Storage per contenere i risultati delle annotazioni.
- Fai clic su Ottieni previsioni.

La procedura per ottenere le previsioni può richiedere del tempo, a seconda del numero di video che vuoi che vengano annotati.

Al termine del processo, i risultati vengono visualizzati nella pagina del modello in Previsioni recenti. Per visualizzare i risultati:

Sotto Previsioni recenti nella colonna Previsioni, fai clic su Visualizza per visualizzare la previsione che vuoi esaminare.
In Video, seleziona il nome del video per cui vuoi vedere i risultati.

REST

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

model-id: sostituiscilo con l'ID del tuo modello. L'ID è l'ultimo elemento del nome del modello. Ad esempio, se il nome del modello è projects/project-number/locations/location-id/models/VOT6312181905852727296, l'ID del modello è VOT6312181905852727296.
request-id: assegna un valore digitale a questo campo.
bucket-name: sostituisci con il nome del tuo bucket Cloud Storage. Ad esempio: my-project-vcm.
input-file: sostituiscilo con il nome del tuo file CSV che identifica i video a cui aggiungere annotazioni.
output-storage-path: sostituiscilo con il percorso del bucket Cloud Storage in cui devono essere archiviati l'output delle previsioni. AutoML Video Object Tracking crea una sottocartella per i risultati in questo percorso, denominata nel seguente formato: prediction-model_name-timestamp. La sottocartella conterrà un file di previsione per ogni video nella richiesta batch. Devi disporre delle autorizzazioni di scrittura per questo percorso.
Nota:
- project-number: numero del progetto
- location-id: la regione Cloud in cui deve avvenire l'annotazione. Le regioni cloud supportate sono: us-east1, us-west1, europe-west1 e asia-east1. Se non viene specificata alcuna regione, verrà determinata in base alla posizione del file video.

Metodo HTTP e URL:

POST https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/models/model-id:batchPredict

Corpo JSON della richiesta:

{
  "request_id": "request-id",
  "inputConfig": {
    "gcsSource": {
      "inputUris": ["gs://bucket-name/input-file.csv"]
    }
  },
  "outputConfig": {
    "gcsDestination": {
      "outputUriPrefix": "gs://output-storage-path"
    }
  },
  "params": {
    "score_threshold": "0.0"
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando gcloud. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "x-goog-user-project: project-number" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/models/model-id:batchPredict"

PowerShell

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-number" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/models/model-id:batchPredict" | Select-Object -Expand Content

Dovresti ricevere un ID operazione per l'operazione di addestramento del modello. L'esempio seguente mostra una risposta contenente l'ID operazione di addestramento del modello VOT1741767155885539328.

Risposta

{
  "name": "projects/project-number/locations/location-id/operations/VOT1741767155885539328",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1beta1.OperationMetadata",
    "createTime": "2020-02-18T21:32:06.730258Z",
    "updateTime": "2020-02-18T21:32:06.730258Z",
    "createModelDetails": {}
  }
}

Java

Per eseguire l'autenticazione in AutoML Video Object Tracking, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1beta1.BatchPredictInputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictOutputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictRequest;
import com.google.cloud.automl.v1beta1.BatchPredictResult;
import com.google.cloud.automl.v1beta1.GcsDestination;
import com.google.cloud.automl.v1beta1.GcsSource;
import com.google.cloud.automl.v1beta1.ModelName;
import com.google.cloud.automl.v1beta1.OperationMetadata;
import com.google.cloud.automl.v1beta1.PredictionServiceClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

abstract class BatchPredict {

  static void batchPredict() throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String inputUri = "gs://YOUR_BUCKET_ID/path_to_your_input_csv_or_jsonl";
    String outputUri = "gs://YOUR_BUCKET_ID/path_to_save_results/";
    batchPredict(projectId, modelId, inputUri, outputUri);
  }

  static void batchPredict(String projectId, String modelId, String inputUri, String outputUri)
      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 (PredictionServiceClient client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);

      // Configure the source of the file from a GCS bucket
      GcsSource gcsSource = GcsSource.newBuilder().addInputUris(inputUri).build();
      BatchPredictInputConfig inputConfig =
          BatchPredictInputConfig.newBuilder().setGcsSource(gcsSource).build();

      // Configure where to store the output in a GCS bucket
      GcsDestination gcsDestination =
          GcsDestination.newBuilder().setOutputUriPrefix(outputUri).build();
      BatchPredictOutputConfig outputConfig =
          BatchPredictOutputConfig.newBuilder().setGcsDestination(gcsDestination).build();

      // Build the request that will be sent to the API
      BatchPredictRequest request =
          BatchPredictRequest.newBuilder()
              .setName(name.toString())
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .build();

      // Start an asynchronous request
      OperationFuture<BatchPredictResult, OperationMetadata> future =
          client.batchPredictAsync(request);

      System.out.println("Waiting for operation to complete...");
      future.get();
      System.out.println("Batch Prediction results saved to specified Cloud Storage bucket.");
    }
  }
}

Node.js

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

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

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

async function batchPredict() {
  // Construct request
  const request = {
    name: client.modelPath(projectId, location, modelId),
    inputConfig: {
      gcsSource: {
        inputUris: [inputUri],
      },
    },
    outputConfig: {
      gcsDestination: {
        outputUriPrefix: outputUri,
      },
    },
  };

  const [operation] = await client.batchPredict(request);

  console.log('Waiting for operation to complete...');
  // Wait for operation to complete.
  const [response] = await operation.promise();
  console.log(
    `Batch Prediction results saved to Cloud Storage bucket. ${response}`
  );
}

batchPredict();

Python

from google.cloud import automl_v1beta1 as automl

def batch_predict(
    project_id="YOUR_PROJECT_ID",
    model_id="YOUR_MODEL_ID",
    input_uri="gs://YOUR_BUCKET_ID/path/to/your/input/csv_or_jsonl",
    output_uri="gs://YOUR_BUCKET_ID/path/to/save/results/",
):
    """Batch predict"""
    prediction_client = automl.PredictionServiceClient()

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

    gcs_source = automl.GcsSource(input_uris=[input_uri])

    input_config = automl.BatchPredictInputConfig(gcs_source=gcs_source)
    gcs_destination = automl.GcsDestination(output_uri_prefix=output_uri)
    output_config = automl.BatchPredictOutputConfig(gcs_destination=gcs_destination)
    params = {}

    request = automl.BatchPredictRequest(
        name=model_full_id,
        input_config=input_config,
        output_config=output_config,
        params=params,
    )
    response = prediction_client.batch_predict(request=request)

    print("Waiting for operation to complete...")
    print(
        "Batch Prediction results saved to Cloud Storage bucket. {}".format(
            response.result()
        )
    )

Ottieni lo stato dell'operazione di previsione

Puoi eseguire una query sullo stato dell'operazione di previsione batch utilizzando i seguenti comandi curl o PowerShell.

REST

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

project-number: il numero del progetto
location-id: la regione Cloud in cui deve avvenire l'annotazione. Le regioni cloud supportate sono: us-east1, us-west1, europe-west1 e asia-east1. Se non viene specificata alcuna regione, verrà determinata in base alla posizione del file video.
operation-id: l'ID dell'operazione a lunga esecuzione creata per la richiesta e fornito nella risposta al momento dell'avvio dell'operazione, ad esempio VOT12345....

Metodo HTTP e URL:

GET https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/operations/operation-id

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Esegui questo comando:

curl -X GET \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "x-goog-user-project: project-number" \
    "https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/operations/operation-id"

PowerShell

Esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-number" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/operations/operation-id" | Select-Object -Expand Content

operation-name è il nome dell'operazione restituito dall'API AutoML Video Intelligence Object Tracking. Il nome dell'operazione ha il formato projects/project-number/locations/location-id/operations/operation-id

Risposta

{
  "name": "operation-name",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1beta1.OperationMetadata",
    "createTime": "2020-02-18T21:23:15.181451Z",
    "updateTime": "2020-02-18T21:26:10.354502Z",
    "importDataDetails": {}
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.protobuf.Empty"
  }
}

Quando l'attività di previsione batch è completa, l'output della previsione viene archiviato nel bucket Cloud Storage specificato nel comando. È disponibile un file JSON per ogni segmento video. I file JSON hanno un formato simile a my-video-01.avi.json, in cui l'estensione del file .json viene aggiunta al nome del file originale.

{
  "inputUris": ["automl-video-demo-data/sample_video.avi"],
  "object_annotations": [ {
    "annotation_spec": {
      "display_name": "Cat",
      "description": "Cat"
    },
    "confidence": 0.43253016
    "frames": [ {
      "frame": {
        "time_offset": {
          "seconds": 4,
          "nanos": 960000000
        },
        "normalized_bounding_box": {
          "x_min": 0.1,
          "y_min": 0.1,
          "x_max": 0.8,
          "y_max": 0.8
        }
      }
    }, {
      "frame": {
        "time_offset": {
          "seconds": 5,
          "nanos": 960000000
        },
        "normalized_bounding_box": {
          "x_min": 0.2,
          "y_min": 0.2,
          "x_max": 0.9,
          "y_max": 0.9
        }
      }
    } ],
    "segment": {
      "start_time_offset": {
          "seconds": 4,
          "nanos": 960000000
      },
      "end_time_offset": {
          "seconds": 5,
          "nanos": 960000000
      }
    }
  } ],
  "error": {
    "details": [ ]
  }
}