Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

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 al metodo batchPredict. Il metodo batchPredict annota i video rilevando e monitorando 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 aggiungere annotazioni ai video.

Esempio di previsione

Per richiedere un batch di previsioni da AutoML Video Object Tracking, crea un file CSV in cui siano elencati i percorsi di Cloud Storage dei video che vuoi 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 zero o maggiore e deve essere precedente all'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 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 anche specificare un percorso del file di output in cui il monitoraggio oggetti AutoML Video dovrebbe scrivere i risultati delle previsioni dal tuo modello. Questo percorso deve essere un oggetto e un bucket Cloud Storage in cui disponi delle autorizzazioni di scrittura.

Ogni video può durare al massimo 3 ore con una dimensione massima di 50 GB. Il monitoraggio degli oggetti video AutoML può generare previsioni per circa 100 ore di video in 12 ore di elaborazione.

UI web

  1. Apri l'interfaccia utente di monitoraggio degli oggetti video AutoML.
  2. Nell'elenco visualizzato, fai clic sul modello che vuoi utilizzare. Elenco di modelli di AutoML Video Intelligence in Cloud Console
  3. Nella scheda Testa e utilizza per il modello, procedi nel seguente modo:
    • Nella sezione Testa il tuo modello, seleziona un file CSV da utilizzare per la previsione. Il file CSV deve fornire un elenco di video a cui vuoi annotare.
    • Sempre in Testa il tuo modello, seleziona una directory all'interno del tuo bucket Cloud Storage per ricevere i risultati delle annotazioni.

      In realtà puoi creare una cartella 'results' specifica nel bucket Cloud Storage per conservare i risultati delle annotazioni.

    • Fai clic su Ottieni previsioni.
    Configurazione di una richiesta di previsione per AutoML Video Intelligence

Il processo per ottenere previsioni può richiedere del tempo, a seconda del numero di video che vuoi annotare.

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

  1. Nella sezione Previsioni recenti, nella colonna Previsioni, fai clic su Visualizza per la previsione da esaminare.
  2. In Video, seleziona il nome del video di cui vuoi visualizzare i risultati.

REST &AM; LINEA CMD

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 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: sostituisci con il nome del tuo file CSV che identifica i video da annotare.
  • output-storage-path: sostituisci con il percorso del bucket Cloud Storage in cui deve essere archiviato l'output delle previsioni. Il monitoraggio degli oggetti video AutoML crea una sottocartella per i risultati in questo percorso denominata utilizzando il seguente formato: prediction-model_name-timestamp. La sottocartella conterrà un file di previsione per ogni video incluso nella richiesta in 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, asia-east1. Se non viene specificata alcuna regione, verrà determinata una regione 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 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:

ricciolo

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

curl -X POST \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://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 application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://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 riportato di seguito mostra una risposta contenente l'ID dell'operazione di addestramento del modello VOT1741767155885539328.

Java

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;

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...");
      BatchPredictResult response = 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()
        )
    )

Conoscere lo stato dell'operazione di previsione

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

REST &AM; LINEA CMD

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

    • project-number: il numero del progetto
    • location-id: l'area geografica Cloud in cui deve avvenire l'annotazione. Le regioni cloud supportate sono: us-east1, us-west1, europe-west1, asia-east1. Se non viene specificata alcuna regione, verrà determinata una regione in base alla posizione del file video.
    • operation-id: l'ID dell'operazione a lunga esecuzione creato per la richiesta e fornito nella risposta quando hai avviato l'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:

ricciolo

Esegui questo comando:

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

PowerShell

Esegui questo comando:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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

Quando l'attività di previsione batch è stata completata, l'output della previsione viene archiviato nel bucket Cloud Storage specificato nel comando. È presente 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 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": [ ]
  }
}