Esta versão legada do AutoML Video Intelligence está descontinuada e não estará mais disponível no Google Cloud após 23 de janeiro de 2024. Todas as funcionalidades do AutoML Video Intelligence legado e novos recursos estão disponíveis na plataforma Vertex AI. Consulte Migrar para a Vertex AI para saber como migrar seus recursos.

Como rastrear objetos em vídeos

Depois de criar (treinar) um modelo, é possível solicitar a previsão de um ou mais vídeos usando o método batchPredict. Você fornece um arquivo CSV com uma lista de vídeos para o método batchPredict. O método batchPredict anota vídeos detectando e rastreando objetos que seu modelo prevê.

A vida útil máxima de um modelo é de dois anos. Após dois anos, você precisa criar e treinar um modelo para continuar anotando seus vídeos.

Exemplo de predição

Para solicitar um lote de predições do rastreamento de objetos de vídeo do AutoML, crie um arquivo CSV que liste os caminhos do Cloud Storage para os vídeos que você quer anotar. Também é possível especificar um horário de início e término para informar ao rastreamento de objetos de vídeo do AutoML para anotar somente um segmento do vídeo. O horário de início precisa ser zero ou superior e precisa ser anterior ao horário de término. A hora final precisa ser maior que a hora inicial e menor ou igual à duração do vídeo.

O exemplo a seguir mostra como anotar um vídeo inteiro ao especificar um horário de início e término como 0,inf.

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

Você também precisa especificar um caminho de arquivo de saída em que o rastreamento de objetos de vídeo do AutoML precisa gravar os resultados das predições do seu modelo. Esse caminho precisa ser um bucket e um objeto do Cloud Storage em que você tenha permissões de gravação.

Cada vídeo pode ter até 3 horas de duração com tamanho máximo de arquivo de 50 GB. O rastreamento de objetos de vídeo do AutoML pode gerar previsões para aproximadamente 100 horas de vídeo em 12 horas de processamento.

IU da Web

Abra a IU de rastreamento de objetos do AutoML Video.
Na lista exibida, clique no modelo que você quer usar.
Na guia Testar e usar do modelo, faça o seguinte:
- Em Testar seu modelo, selecione um arquivo CSV que será usado na previsão. No arquivo CSV, é necessário fornecer uma lista de vídeos que você quer anotar.
- Ainda em Teste seu modelo, selecione um diretório no bucket do Cloud Storage para receber os resultados da anotação.
  
  Recomendamos que você crie uma pasta específica no bucket do Cloud Storage para armazenar os resultados da anotação.
- Clique em Receber predição.

O processo para receber predições leva algum tempo, dependendo do número de vídeos que você quer anotar.

Quando o processo é concluído, os resultados aparecem na página do modelo em Predições recentes. Para ver os resultados, faça o seguinte:

Em Predições recentes na coluna Predições, clique em Exibir na predição que você quer examinar.
Em Vídeo, selecione o nome do vídeo com os resultados que você quer ver.

REST

Antes de usar os dados da solicitação, faça as substituições a seguir:

model-id: substitua pelo ID do seu modelo. Ele é o último elemento no nome do modelo. Por exemplo, se o nome do seu modelo for projects/project-number/locations/location-id/models/VOT6312181905852727296, o ID do seu modelo será VOT6312181905852727296.
request-id: atribua qualquer valor digital a este campo.
Substitua bucket-name pelo nome do bucket no Cloud Storage. Por exemplo, my-project-vcm.
input-file: substitua pelo nome do arquivo CSV que identifica os vídeos a serem anotados.
output-storage-path: substitua pelo caminho para o intervalo do Cloud Storage em que os resultados das previsões serão armazenados. O rastreamento de objetos de vídeo do AutoML cria uma subpasta para os resultados nesse caminho usando o seguinte formato: prediction-model_name-timestamp. A subpasta conterá um arquivo de predição para cada vídeo na solicitação em lote. Você precisa ter permissões de gravação nesse caminho.
Observação:
- project-number: o número do seu projeto
- location-id: a região do Cloud em que a anotação deve ocorrer. As regiões de nuvem compatíveis são: us-east1, us-west1, europe-west1 e asia-east1. Se nenhuma região for especificada, uma região será determinada com base na localização do arquivo de vídeo.

Método HTTP e URL:

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

Corpo JSON da solicitação:

{
  "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"
  }
}

Para enviar a solicitação, escolha uma destas opções:

curl

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

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

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

$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

Você receberá um código para a operação de treinamento do modelo. O exemplo abaixo mostra uma resposta que contém o código da operação de treinamento do modelo VOT1741767155885539328.

Resposta

{
  "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

Para autenticar o rastreamento de objetos de vídeo do AutoML, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Ver o status da operação de predição

É possível consultar o status da operação de predição em lote usando os seguintes comandos curl ou do PowerShell.

REST

Antes de usar os dados da solicitação, faça as substituições a seguir:

project-number: o número do seu projeto
location-id: a região do Cloud em que a anotação deve ocorrer. As regiões de nuvem compatíveis são: us-east1, us-west1, europe-west1 e asia-east1. Se nenhuma região for especificada, uma região será determinada com base na localização do arquivo de vídeo.
operation-id: o ID da operação de longa duração criada para a solicitação e fornecida na resposta quando você iniciou a operação. Por exemplo, VOT12345....

Método HTTP e URL:

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

Para enviar a solicitação, escolha uma destas opções:

curl

execute o seguinte 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

execute o seguinte 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

O operation-name é o nome da operação retornado pela API AutoML Video Intelligence Object Tracking. O nome da operação tem o formato projects/project-number/locations/location-id/operations/operation-id

Resposta

{
  "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 a tarefa de previsão em lotes é concluída, a saída da previsão é armazenada no bucket do Cloud Storage especificado no seu comando. Há um arquivo JSON para cada trecho de vídeo. Os arquivos JSON têm um formato semelhante a my-video-01.avi.json, em que a extensão de arquivo .json é anexada ao nome do arquivo original.

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