Annotazione dei video

Beta

Questo prodotto è soggetto ai "Termini delle offerte pre-GA" nella sezione Termini di servizio generali dei Termini specifici dei servizi. I prodotti pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Dopo aver addestrato un modello, puoi richiedere una previsione fornendo un file CSV al file batchPredict che elenca i tuoi video. Il metodo batchPredict applica le etichette in base sulle previsioni fatte dal modello.

La durata massima di un modello è di due anni. Devi poi addestrare un nuovo model.

Nota: per questa release è supportata solo la località us-central1.

Esempio di previsione

Per richiedere un batch di previsioni da AutoML Video, 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 AutoML Video per annotare solo un segmento (a livello di segmento) video. L'ora di inizio deve essere pari a 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 all'ora durata del video. Puoi anche utilizzare inf per indicare la fine di un video.

gs://my-videos-vcm/short_video_1.avi,0.0,5.566667
gs://my-videos-vcm/car_chase.avi,0.0,3.933333
gs://my-videos-vcm/northwest_wildlife_01.avi,0.0,3.7
gs://my-videos-vcm/northwest_wildlife_02.avi,0.0,1.666667
gs://my-videos-vcm/motorcycles_and_cars.avi,0.0,2.633333
gs://my-videos-vcm/drying_paint.avi,0.0,inf

Devi anche specificare un percorso del file di output in cui AutoML Video 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 può generare previsioni per circa 100 ore di video in 12 ore di tempo di elaborazione.

Quando richiedi una previsione per i tuoi video, puoi impostare quanto segue opzioni nella sezione params. Se non specifichi nessuna di queste opzioni, viene applicata la soglia di punteggio predefinita e viene utilizzato segment_classification.

• score_threshold - Un valore compreso tra 0,0 (nessuna confidenza) e 1,0 (molto alto) l'affidabilità). Quando il modello fa previsioni per un video, produrranno risultati con almeno il punteggio di confidenza che hai specificato. Il valore predefinito per l'API è 0,5.

  Nota :quando aggiungi annotazioni ai video tramite l'interfaccia utente della console, il valore predefinito è 0. Di conseguenza, l'utente potrebbe ricevere più etichette rispetto all'uso diretto dell'API.

• segment_classification: imposta su true per abilitare a livello di segmento per la classificazione. AutoML Video restituisce le etichette e la relativa affidabilità i punteggi dell'intero segmento video che hai specificato nella richiesta configurazione. Il valore predefinito è true.

• shot_classification: imposta su true per consentire la classificazione a livello di inquadratura. AutoML Video determina i confini per ogni ripresa l'intero segmento del video specificato nella richiesta configurazione. AutoML Video Intelligence restituisce quindi le etichette e i rispettivi punteggi di confidenza per ogni colpo rilevato, insieme all'ora di inizio e di fine dell'inquadratura. Il valore predefinito è false.

• 1s_interval_classification: imposta su true per abilitare la classificazione per un video a intervalli di 1 secondo. AutoML Video restituisce le etichette e i relativi punteggi di affidabilità per ogni secondo dell'intero segmento del video specificato nella configurazione della richiesta. Il valore predefinito è false.

UI web

1. Apri l'UI di AutoML Video.
2. Fai clic sul modello che vuoi utilizzare dall'elenco di lettura.
3. 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. In questo modo, puoi accedere più facilmente alle previsioni meno recenti caricando il file video_classification.csv contenuti nella directory dei risultati.

   • Fai clic su Ottieni previsioni.
   

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

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

1. Nella sezione Previsioni recenti della Nella colonna Previsioni, fai clic su Visualizza. per la previsione che vuoi esaminare.
2. 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:

• input-uri: un bucket Cloud Storage che contiene il file da annotare, incluso il nome del file. Deve iniziare con gs://. Ad esempio:
  "inputUris": ["gs://automl-video-demo-data/hmdb_split1_test_gs_predict.csv"]
• Sostituisci output-bucket con il nome di Cloud Storage di sincronizzare la directory di una VM con un bucket. Ad esempio: my-project-vcm
• object-id: sostituisci con l'ID operazione per l'operazione di importazione dei dati.
• 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:

{
  "inputConfig": {
    "gcsSource": {
      "inputUris": [input-uri]
    }
  },
  "outputConfig": {
    "gcsDestination": {
      "outputUriPrefix": "gs://output-bucket/object-id"
    }
  }
}

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 . 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

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 . 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:

$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 la richiesta di previsione in batch. Ad esempio: VCN926615623331479552

Risposta

{
  "name": "projects/project-number/locations/location-id/operations/VCN926615623331479552",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1beta1.OperationMetadata",
    "createTime": "2020-02-19T21:22:27.003694Z",
    "updateTime": "2020-02-19T21:22:27.003694Z",
    "batchPredictDetails": {}
  }
}

In base al numero di video che hai specificato nel file CSV, la di previsione batch può richiedere del tempo. Quando l'attività viene completato, vedrai done: true nello stato dell'operazione con non siano elencati errori, come mostrato nell'esempio seguente.

{
  "name": "projects/project-number/locations/location-id/operations/VCN926615623331479552",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1beta1.OperationMetadata",
    "createTime": "2020-02-11T21:39:19.832131Z",
    "updateTime": "2020-02-11T21:43:43.908318Z",
    "done": true,
    "batchPredictDetails": {
      "inputConfig": {
        "gcsSource": {
          "inputUris": [
            "gs://bucket-name/input-file.csv"
          ]
        }
      },
      "outputInfo": {
        "gcsOutputDirectory": "output-storage-path/prediction-test_model_01-2019-01-11T21:39:19.684Z"
      }
    }
  }
}

Quando l'attività di previsione batch è completata, l'output della previsione è archiviato nel bucket Cloud Storage che hai specificato . Esiste un file JSON per ogni segmento video. Ad esempio:

my-video-01.avi.json

{
  "input_uri": "automl-video-sample/sample_video.avi",
  "segment_classification_annotations": [ {
    "annotation_spec": {
      "display_name": "ApplyLipstick",
      "description": "ApplyLipstick"
    },
    "segments": [ {
      "segment": {
        "start_time_offset": {
        },
        "end_time_offset": {
          "seconds": 4,
          "nanos": 960000000
        }
      },
      "confidence": 0.43253016
    }, {
      "segment": {
        "start_time_offset": {
        },
        "end_time_offset": {
          "seconds": 4,
          "nanos": 960000000
        }
      },
      "confidence": 0.56746984
    } ],
    "frames": [ ]
  } ],
  "shot_classification_annotations": [ {
    "annotation_spec": {
      "display_name": "ApplyLipstick",
      "description": "ApplyLipstick"
    },
    "segments": [ {
      "segment": {
        "start_time_offset": {
        },
        "end_time_offset": {
          "seconds": 5
        }
      },
      "confidence": 0.43253016
    }, {
      "segment": {
        "start_time_offset": {
        },
        "end_time_offset": {
          "seconds": 5
        }
      },
      "confidence": 0.56746984
    } ],
    "frames": [ ]
  } ],
  "one_second_sliding_window_classification_annotations": [ {
    "annotation_spec": {
      "display_name": "ApplyLipstick",
      "description": "ApplyLipstick"
    },
    "segments": [ ],
    "frames": [ {
      "time_offset": {
        "nanos": 800000000
      },
      "confidence": 0.54533803
    }, {
      "time_offset": {
        "nanos": 800000000
      },
      ...
      "confidence": 0.57945728
    }, {
      "time_offset": {
        "seconds": 4,
        "nanos": 300000000
      },
      "confidence": 0.42054281
    } ]
  } ],
  "object_annotations": [ ],
  "error": {
    "details": [ ]
  }
}

Java

Per eseguire l'autenticazione su AutoML Video, 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

Per eseguire l'autenticazione su AutoML Video, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

/**
 * 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

Per eseguire l'autenticazione su AutoML Video, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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()
        )
    )

Importante: viene visualizzato il messaggio di errore "Il modello è in fase di preparazione. Riprova più tardi." indica devi attendere alcuni minuti prima di riprovare a eseguire una query sul modello. Questo il ritardo di riscaldamento può verificarsi quando esegui una query iniziale sul modello o quando esegui una da un modello che non è stato oggetto di query di recente.