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

Detecta contenido explícito en videos

La detección de contenido explícito detecta contenido para adultos en los videos. Por lo general, el contenido para adultos es inapropiado para menores de 18 años e incluye, entre otros, imágenes de desnudos, actividades sexuales y pornografía. También se identifica ese tipo de contenido detectado en dibujos animados o anime.

La respuesta incluye un valor de probabilidad en buckets, de VERY_UNLIKELY a VERY_LIKELY.

Cuando la detección de contenido explícito evalúa un video, lo hace por fotograma y considera solo el contenido visual. El componente de audio del video no se usa para evaluar el nivel de contenido explícito.

El siguiente es un ejemplo de cómo realizar un análisis de video para las funciones de detección de contenido explícito en un archivo ubicado en Cloud Storage.

LÍNEA DE REST Y CMD

Envía una solicitud de anotación de video

A continuación, se muestra cómo enviar una solicitud POST al método videos:annotate. En el ejemplo, se usa el token de acceso de una cuenta de servicio que se configuró para el proyecto con el SDK de Cloud. Si deseas obtener instrucciones para instalar el SDK de Cloud, configurar un proyecto con una cuenta de servicio y conseguir un token de acceso, consulta la guía de inicio rápido de Video Intelligence.

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

  • input-uri: Es el bucket de Cloud Storage que contiene el archivo que deseas anotar, incluido el nombre del archivo. Debe comenzar con gs://.
    Por ejemplo: "inputUri": "gs://cloud-videointelligence-demo/assistant.mp4",

Método HTTP y URL:

POST https://videointelligence.googleapis.com/v1/videos:annotate

Cuerpo JSON de la solicitud:

{
  "inputUri": "input-uri",
  "features": ["EXPLICIT_CONTENT_DETECTION"]
}

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "name": "projects/project-number/locations/location-id/operations/operation-id"
}

Si la respuesta es correcta, la API de Video Intelligence muestra name para tu operación. Lo anterior corresponde a un ejemplo de una respuesta en la que:

  • 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.
  • operation-id: Es el ID de la operación de larga duración creada para la solicitud y proporcionada en la respuesta cuando iniciaste la operación, por ejemplo 12345....

Obtén resultados de anotaciones

Para recuperar el resultado de la operación, realiza una solicitud GET con el nombre de la operación que se muestra de la llamada a videos:annotate, como se muestra en el siguiente ejemplo.

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

  • operation-name: Es el nombre de la operación que muestra la API de Video Intelligence. El nombre de la operación tiene el formato projects/project-number/locations/location-id/operations/operation-id.

Método HTTP y URL:

GET https://videointelligence.googleapis.com/v1/operation-name

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "name": "projects/project-number/locations/location-id/operations/operation-id",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.videointelligence.v1.AnnotateVideoProgress",
    "annotationProgress": [
     {
      "inputUri": "/demomaker/gbikes_dinosaur.mp4",
      "progressPercent": 100,
      "startTime": "2020-03-26T00:16:35.112404Z",
      "updateTime": "2020-03-26T00:16:55.937889Z"
     }
    ]
   },
   "done": true,
   "response": {
    "@type": "type.googleapis.com/google.cloud.videointelligence.v1.AnnotateVideoResponse",
    "annotationResults": [
     {
      "inputUri": "/demomaker/gbikes_dinosaur.mp4",
      "explicitAnnotation": {
       "frames": [
        {
         "timeOffset": "0.056149s",
         "pornographyLikelihood": "VERY_UNLIKELY"
        },
        {
         "timeOffset": "1.166841s",
         "pornographyLikelihood": "VERY_UNLIKELY"
        },
            ...
        {
         "timeOffset": "41.678209s",
         "pornographyLikelihood": "VERY_UNLIKELY"
        },
        {
         "timeOffset": "42.596413s",
         "pornographyLikelihood": "VERY_UNLIKELY"
        }
       ]
      }
     }
    ]
   }
  }
Las anotaciones de detección de calzado se muestran como una lista shotAnnotations. Nota: El campo done solo se muestra cuando su valor es True. No se incluye en las respuestas para las que no se completó la operación.

Descargar resultados de anotaciones

Copia la anotación del origen al depósito de destino (consulta Copiar archivos y objetos)

gsutil cp gcs_uri gs://my-bucket

Nota: Si el usuario proporciona el URI de gcs de salida, la anotación se almacena en esa URI.

C#

public static object AnalyzeExplicitContentGcs(string uri)
{
    var client = VideoIntelligenceServiceClient.Create();
    var request = new AnnotateVideoRequest()
    {
        InputUri = uri,
        Features = { Feature.ExplicitContentDetection }
    };
    var op = client.AnnotateVideo(request).PollUntilCompleted();
    foreach (var result in op.Result.AnnotationResults)
    {
        foreach (var frame in result.ExplicitAnnotation.Frames)
        {
            Console.WriteLine("Time Offset: {0}", frame.TimeOffset);
            Console.WriteLine("Pornography Likelihood: {0}", frame.PornographyLikelihood);
            Console.WriteLine();
        }
    }
    return 0;
}

Go


func explicitContentURI(w io.Writer, file string) error {
	ctx := context.Background()
	client, err := video.NewClient(ctx)
	if err != nil {
		return err
	}

	op, err := client.AnnotateVideo(ctx, &videopb.AnnotateVideoRequest{
		Features: []videopb.Feature{
			videopb.Feature_EXPLICIT_CONTENT_DETECTION,
		},
		InputUri: file,
	})
	if err != nil {
		return err
	}
	resp, err := op.Wait(ctx)
	if err != nil {
		return err
	}

	// A single video was processed. Get the first result.
	result := resp.AnnotationResults[0].ExplicitAnnotation

	for _, frame := range result.Frames {
		offset, _ := ptypes.Duration(frame.TimeOffset)
		fmt.Fprintf(w, "%s - %s\n", offset, frame.PornographyLikelihood.String())
	}

	return nil
}

Java

// Instantiate a com.google.cloud.videointelligence.v1.VideoIntelligenceServiceClient
try (VideoIntelligenceServiceClient client = VideoIntelligenceServiceClient.create()) {
  // Create an operation that will contain the response when the operation completes.
  AnnotateVideoRequest request =
      AnnotateVideoRequest.newBuilder()
          .setInputUri(gcsUri)
          .addFeatures(Feature.EXPLICIT_CONTENT_DETECTION)
          .build();

  OperationFuture<AnnotateVideoResponse, AnnotateVideoProgress> response =
      client.annotateVideoAsync(request);

  System.out.println("Waiting for operation to complete...");
  // Print detected annotations and their positions in the analyzed video.
  for (VideoAnnotationResults result : response.get().getAnnotationResultsList()) {
    for (ExplicitContentFrame frame : result.getExplicitAnnotation().getFramesList()) {
      double frameTime =
          frame.getTimeOffset().getSeconds() + frame.getTimeOffset().getNanos() / 1e9;
      System.out.printf("Location: %.3fs\n", frameTime);
      System.out.println("Adult: " + frame.getPornographyLikelihood());
    }
  }

Node.js

// Imports the Google Cloud Video Intelligence library
const video = require('@google-cloud/video-intelligence').v1;

// Creates a client
const client = new video.VideoIntelligenceServiceClient();

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const gcsUri = 'GCS URI of video to analyze, e.g. gs://my-bucket/my-video.mp4';

const request = {
  inputUri: gcsUri,
  features: ['EXPLICIT_CONTENT_DETECTION'],
};

// Human-readable likelihoods
const likelihoods = [
  'UNKNOWN',
  'VERY_UNLIKELY',
  'UNLIKELY',
  'POSSIBLE',
  'LIKELY',
  'VERY_LIKELY',
];

// Detects unsafe content
const [opertaion] = await client.annotateVideo(request);
console.log('Waiting for operation to complete...');
const [operationResult] = await opertaion.promise();
// Gets unsafe content
const explicitContentResults =
  operationResult.annotationResults[0].explicitAnnotation;
console.log('Explicit annotation results:');
explicitContentResults.frames.forEach(result => {
  if (result.timeOffset === undefined) {
    result.timeOffset = {};
  }
  if (result.timeOffset.seconds === undefined) {
    result.timeOffset.seconds = 0;
  }
  if (result.timeOffset.nanos === undefined) {
    result.timeOffset.nanos = 0;
  }
  console.log(
    `\tTime: ${result.timeOffset.seconds}` +
      `.${(result.timeOffset.nanos / 1e6).toFixed(0)}s`
  );
  console.log(
    `\t\tPornography likelihood: ${likelihoods[result.pornographyLikelihood]}`
  );
});

Python

Para obtener más información sobre cómo instalar y usar la biblioteca cliente de la API de Cloud de Video Intelligence para Python, consulta Bibliotecas cliente de la API de Cloud Video Intelligence.
""" Detects explicit content from the GCS path to a video. """
video_client = videointelligence.VideoIntelligenceServiceClient()
features = [videointelligence.Feature.EXPLICIT_CONTENT_DETECTION]

operation = video_client.annotate_video(
    request={"features": features, "input_uri": path}
)
print("\nProcessing video for explicit content annotations:")

result = operation.result(timeout=90)
print("\nFinished processing.")

# Retrieve first result because a single video was processed
for frame in result.annotation_results[0].explicit_annotation.frames:
    likelihood = videointelligence.Likelihood(frame.pornography_likelihood)
    frame_time = frame.time_offset.seconds + frame.time_offset.microseconds / 1e6
    print("Time: {}s".format(frame_time))
    print("\tpornography: {}".format(likelihood.name))

PHP

use Google\Cloud\VideoIntelligence\V1\VideoIntelligenceServiceClient;
use Google\Cloud\VideoIntelligence\V1\Feature;
use Google\Cloud\VideoIntelligence\V1\Likelihood;

/** Uncomment and populate these variables in your code */
// $uri = 'The cloud storage object to analyze (gs://your-bucket-name/your-object-name)';
// $options = []; // Optional, can be used to increate "pollingIntervalSeconds"

$video = new VideoIntelligenceServiceClient();

# Execute a request.
$operation = $video->annotateVideo([
    'inputUri' => $uri,
    'features' => [Feature::EXPLICIT_CONTENT_DETECTION]
]);

# Wait for the request to complete.
$operation->pollUntilComplete($options);

# Print the result.
if ($operation->operationSucceeded()) {
    $results = $operation->getResult()->getAnnotationResults()[0];
    $explicitAnnotation = $results->getExplicitAnnotation();
    foreach ($explicitAnnotation->getFrames() as $frame) {
        $time = $frame->getTimeOffset();
        printf('At %ss:' . PHP_EOL, $time->getSeconds() + $time->getNanos()/1000000000.0);
        printf('  pornography: ' . Likelihood::name($frame->getPornographyLikelihood()) . PHP_EOL);
    }
} else {
    print_r($operation->getError());
}

Ruby

# path = "Path to a video file on Google Cloud Storage: gs://bucket/video.mp4"

require "google/cloud/video_intelligence"

video = Google::Cloud::VideoIntelligence.video_intelligence_service

# Register a callback during the method call
operation = video.annotate_video features: [:EXPLICIT_CONTENT_DETECTION], input_uri: path

puts "Processing video for label annotations:"
operation.wait_until_done!

raise operation.results.message? if operation.error?
puts "Finished Processing."

explicit_annotation = operation.results.annotation_results.first.explicit_annotation
print_explicit_annotation_frames explicit_annotation