Questa versione precedente di AutoML Video Intelligence è stata 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. Consulta Eseguire la migrazione a Vertex AI per scoprire come eseguire la migrazione delle risorse.

Questa pagina è stata tradotta dall'API Cloud Translation.

Monitoraggio degli oggetti nei video

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

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

Esempio di previsione

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

L'esempio seguente mostra come aggiungere annotazioni a un intero video che specifica 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 anche specificare un percorso del file di output in cui AutoML Video Object Tracking deve e scrivere i risultati delle previsioni dal modello. Questo percorso deve essere un Bucket e oggetto Cloud Storage di cui disponi delle autorizzazioni di scrittura.

Ogni video può avere una durata massima di 3 ore e una dimensione file massima di 50 GB. AutoML Video Object Tracking può generare previsioni per circa 100 ore. di video in 12 ore di tempo di elaborazione.

UI web

Apri l'interfaccia utente per il monitoraggio degli oggetti video AutoML.
Fai clic sul modello che vuoi utilizzare dall'elenco di lettura.
Nella scheda Test e Usa Tab per il modello, segui questi passaggi:
- In Testa il modello, seleziona un file CSV da utilizzare per la previsione. Il file CSV deve fornire un elenco dei video a cui vuoi aggiungere un'annotazione.
- Sempre nella sezione Testa il modello, seleziona una directory all'interno del bucket Cloud Storage per ricevere i risultati dell'annotazione.
  
  Magari vuoi creare dei "risultati" specifici cartella del bucket Cloud Storage per conservare i risultati dell'annotazione.
- Fai clic su Ottieni previsioni.

Il processo per ottenere previsioni può richiedere del tempo, a seconda sul numero di video a cui vuoi che vengano annotate.

Al termine del processo, i risultati vengono visualizzati nella pagina per il modello in Previsioni recenti. Per visualizzare segui questi passaggi:

Nella sezione Previsioni recenti della Nella colonna Previsioni, fai clic su Visualizza. per la previsione che vuoi esaminare.
In Video, seleziona il nome del video di cui vuoi visualizzare l'anteprima. risultati pertinenti.

REST

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

model-id: sostituisci con l'ID del tuo modello. L'ID è l'ultimo elemento della 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 di Cloud Storage di sincronizzare la directory di una VM con un bucket. Ad esempio: my-project-vcm.
input-file: sostituisci con il nome del tuo file CSV che identifica i video da annotare.
output-storage-path: sostituisci con il percorso della Bucket Cloud Storage in cui deve essere archiviato l'output delle previsioni. AutoML Video Object Tracking crea una sottocartella per i risultati in questo percorso e denominato nel seguente formato: prediction-model_name-timestamp. La sottocartella contiene un file di previsione per ogni video in la richiesta batch. Devi disporre delle autorizzazioni di scrittura per questo percorso.
Nota:
- project-number: il numero del progetto
- location-id: la regione Cloud in cui l'annotazione deve avvenire. Le regioni cloud supportate sono: us-east1, us-west1, europe-west1, asia-east1. Se non viene specificata alcuna regione, viene verrà determinato 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:

curl

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'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 di Google. 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. La l'esempio seguente mostra una risposta contenente l'operazione di addestramento del modello ID 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 ad AutoML Video Object Tracking, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 query sullo stato dell'operazione di previsione batch utilizzando: curl o PowerShell.

REST

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

project-number: il numero del tuo progetto
location-id: la regione Cloud in cui deve essere eseguita l'annotazione posto. Le regioni cloud supportate sono: us-east1, us-west1, europe-west1, asia-east1. Se nessuna regione è specificata, verrà determinata una regione in base alla posizione del file video.
operation-id: l'ID dell'operazione a lunga esecuzione creata della richiesta e fornito nella risposta quando hai avviato operativa, 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:

curl

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 restituita da l'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 è completata, l'output della previsione viene archiviato nel bucket Cloud Storage specificato nel comando. Là è un file JSON per ogni segmento video. I file JSON hanno un formato simile in my-video-01.avi.json, dove l'estensione del file .json viene aggiunta all'originale nome del file.

{
  "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": [ ]
  }
}