Como anotar vídeos

Beta

Este produto está sujeito aos "Termos de ofertas pré-GA" na seção "Termos de Serviço Gerais" dos Termos Específicos do Serviço. Os produtos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

Depois de treinar um modelo, você pode solicitar uma previsão fornecendo um arquivo CSV para o método batchPredict que lista seus vídeos. O método batchPredict aplica rótulos com base em predições feitas pelo modelo.

A vida útil máxima de um modelo é de dois anos. Em seguida, você precisa treinar um novo modelo.

Observação: para esta versão, apenas o local us-central1 tem suporte.

Exemplo de predição

Para solicitar um lote de predições do AutoML Video, crie um arquivo CSV que liste os caminhos do Cloud Storage para os vídeos que você quer anotar. Você também pode especificar um horário de início e término para instruir a classificação do AutoML Video a anotar apenas um segmento (nível do 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. O horário de término precisa ser posterior ao horário de início e anterior ou igual à duração do vídeo. Você também pode usar inf para indicar o final de um vídeo.

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

Você também precisa especificar um caminho de arquivo de saída em que o AutoML Video 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 AutoML Video pode gerar previsões para aproximadamente 100 horas de vídeo em 12 horas de processamento.

Ao solicitar uma previsão para seus vídeos, você pode definir as seguintes opções na seção params. Se você não especificar nenhuma dessas opções, o limite de pontuação padrão será aplicado, e o segment_classification será usado.

• score_threshold: um valor de 0,0 (sem confiança) a 1,0 (muito alta). Quando o modelo faz previsões para um vídeo, ele só produz resultados que tenham pelo menos a pontuação de confiança especificada. O padrão para a API é 0,5.

  Observação: ao anotar vídeos por meio da IU do console, o valor padrão é 0. Portanto, o usuário pode receber mais rótulos do que usar a API diretamente.

• segment_classification: defina como verdadeiro para ativar a classificação em nível de segmento. O AutoML Video retorna rótulos e as pontuações de confiança deles para todo o trecho de vídeo que você especificou na configuração da solicitação. O padrão é verdadeiro.

• shot_classification: defina como verdadeiro para ativar a classificação no nível de imagem. O AutoML Video determina os limites de cada imagem de câmera em todo o trecho do vídeo que você especificou na configuração da solicitação. O AutoML Video Intelligence retorna rótulos e as pontuações de confiança deles para cada imagem detectada, com o horário de início e término delas. O valor padrão é falso.

• 1s_interval_classification: defina como verdadeiro para ativar a classificação de um vídeo em intervalos de um segundo. O AutoML Video retorna rótulos e pontuações de confiança deles para cada segundo de todo o trecho de vídeo que você especificou na configuração da solicitação. O valor padrão é falso.

IU da Web

1. Abra a IU do AutoML Video.
2. Na lista exibida, clique no modelo que você quer usar.
3. 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. Ao fazer isso, você pode acessar mais facilmente as previsões mais antigas carregando o arquivo video_classification.csv contido no diretório de resultados.

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

1. Em Predições recentes na coluna Predições, clique em Exibir na predição que você quer examinar.
2. 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:

• input-uri: um bucket do Cloud Storage que contém o arquivo que você quer anotar, incluindo o nome do arquivo. Precisa começar com gs://. Por exemplo:
  "inputUris": ["gs://automl-video-demo-data/hmdb_split1_test_gs_predict.csv"]
• output-bucket substitua pelo nome do bucket no Cloud Storage. Por exemplo: my-project-vcm
• object-id: substitua pelo código da operação de importação de dados.
• 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:

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

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

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:

$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ê vai receber um ID de operação para a solicitação de previsão em lote. Por exemplo: VCN926615623331479552.

Resposta

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

Dependendo do número de vídeos especificado no arquivo CSV, a tarefa de predição em lote pode levar algum tempo para ser concluída. Quando a tarefa for concluída, você verá done: true no status da operação sem erros listados, conforme mostrado no exemplo a seguir.

{
  "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 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. Exemplo:

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

Para se autenticar no AutoML Video, 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

Para se autenticar no AutoML Video, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para se autenticar no AutoML Video, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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: a mensagem de erro “O modelo está aquecendo. Tente novamente mais tarde” indica que você precisa aguardar alguns minutos antes de tentar consultar o modelo novamente. Esse atraso de aquecimento pode ocorrer quando você consultar inicialmente seu modelo ou quando fizer uma solicitação de um modelo que não foi consultado recentemente.