Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Anotar videos

Después de haber entrenado un modelo, puedes solicitar una predicción si proporcionas un archivo CSV al método batchPredict que enumera tus videos. El método batchPredict aplica etiquetas en función de las predicciones que realice tu modelo.

La vida útil máxima de un modelo personalizado es de dos años. Luego debes entrenar un modelo nuevo.

Ejemplo de predicción

Para solicitar un lote de predicciones de AutoML Video, crea un archivo CSV que enumere las rutas de acceso de Cloud Storage a los videos que deseas anotar. También puedes especificar una hora de inicio y finalización para indicarle a AutoML Video que solo anotar un segmento (a nivel del segmento) del video. La hora de inicio debe ser anterior, e igual o mayor que la hora de finalización. La hora de finalización debe ser superior a la hora de inicio y menor o igual que la duración del video. También puedes usar inf para indicar el final de 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

También debes especificar una ruta de acceso del archivo de salida en la que AutoML Video escribirá los resultados de las predicciones de tu modelo. Esta ruta debe ser un objeto y un bucket de Cloud Storage en el que tengas permisos de escritura.

Cada video puede tener hasta 3 horas de duración con un tamaño máximo de archivo de 50 GB. AutoML Video puede generar predicciones para aproximadamente 100 horas de video en 12 horas de procesamiento.

Cuando solicitas una predicción de tus videos, puedes configurar las siguientes opciones en la sección params. Si no especificas ninguna de estas opciones, se aplica el umbral de puntuación predeterminado y se usa segment_classification.

  • score_threshold: valor de 0.0 (sin confianza) a 1.0 (confianza muy alta). Cuando el modelo hace predicciones para un video, solo producirá resultados que tengan al menos la puntuación de confianza que especificaste. El valor predeterminado para la API es 0.5.

  • segment_classification: configurado como verdadero para habilitar la clasificación a nivel de segmento. AutoML Video muestra las etiquetas y sus puntuaciones de confianza para todo el segmento de video que especificaste en la configuración de la solicitud. El valor predeterminado es verdadero.

  • shot_classification: configurado como verdadero para habilitar la clasificación a nivel de toma. AutoML Video determina los límites para cada toma de cámara en todo el segmento de video que especificaste en la configuración de la solicitud. Luego, AutoML Video Intelligence muestra etiquetas y sus puntuaciones de confianza para cada toma detectada, junto con la hora de inicio y finalización de la toma. El valor predeterminado es falso.

  • 1s_interval_classification: configurado como verdadero para habilitar la clasificación de un video en intervalos de un segundo. AutoML Video muestra las etiquetas y sus puntuaciones de confianza de cada segundo de todo el segmento de video que especificaste en la configuración de la solicitud. El valor predeterminado es falso.

IU web

  1. Abre la IU de AutoML Video.
  2. Haz clic en el modelo personalizado que deseas usar de la lista que se muestra.Lista de modelos personalizados de AutoML Video Intelligence en Cloud Console
  3. En la pestaña Probar y usar del modelo, haz lo siguiente:
    • En Prueba tu modelo, selecciona un archivo CSV para usar en la predicción. El archivo CSV debe proporcionar una lista de videos que deseas anotar.
    • También en Probar tu modelo, selecciona un directorio dentro de tu depósito de Cloud Storage para recibir los resultados de la anotación.

      Es posible que desees crear una carpeta específica “results” en tu bucket de Cloud Storage para almacenar los resultados de la anotación. Si lo haces, puedes acceder más fácilmente a las predicciones más antiguas si cargas el archivo video_classification.csv contenido en el directorio de resultados.

    • Haz clic en Obtener predicciones.
    Configura una solicitud de predicción para AutoML Video Intelligence

El proceso para obtener predicciones puede demorar un poco, según la cantidad de videos que quieras anotar.

Cuando se completa el proceso, los resultados aparecen en la página del modelo en Predicciones recientes. Para ver los resultados, haz lo siguiente:

  1. En Predicciones recientes de la columna Predictions, haz clic en Ver para la predicción que quieres ver.
  2. En Video, selecciona el nombre del video del que deseas ver los resultados.

Resultados de la predicción de AutoML Video Intelligence

LÍNEA DE REST Y CMD

Antes de usar cualquiera de los datos de solicitud siguientes, realiza estos reemplazos:

  • input-uri: Es el depósito de Cloud Storage que contiene el archivo que deseas anotar, incluido el nombre del archivo. Debe comenzar con gs://. Por ejemplo:
    "inputUris": ["gs://automl-video-demo-data/hmdb_split1_test_gs_predict.csv"]
  • output-bucket reemplaza por el nombre del depósito de Cloud Storage. Por ejemplo: my-project-vcm
  • Reemplaza object-id por el ID de la operación de importación de datos.
  • Nota:
    • project-number: Es el número de tu proyecto.
    • location-id: Es la región de Cloud en la que se debe realizar la anotación. Las regiones en la nube compatibles son: us-east1, us-west1, europe-west1, asia-east1. Si no se especifica ninguna región, se determinará una región en función de la ubicación del archivo de video.

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

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

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente 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

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente 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

Deberías recibir un ID de operación para la solicitud de predicción por lotes. Por ejemplo: VCN926615623331479552.

Según la cantidad de imágenes que especificaste en el archivo CSV, la tarea de predicción por lotes puede tomar un tiempo en completarse. Cuando la tarea de importación se complete, verás done: true en el estado de la operación sin errores, como se muestra en el siguiente ejemplo.

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

Cuando se completa la tarea de predicción por lotes, el resultado de la predicción se almacena en el bucket de Cloud Storage que especificaste en el comando. Hay un archivo JSON para cada segmento de video. Por ejemplo:

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

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