Analyser les annotations de détection de contenu explicite des vidéos

La fonctionnalité de détection de contenu explicite détecte le contenu réservé aux adultes dans une vidéo. Le contenu réservé aux adultes est un contenu généralement destiné aux personnes de plus de 18 ans. Il concerne, mais sans s'y limiter, la nudité, les activités sexuelles et la pornographie (y compris dans les dessins animés).

La réponse comprend une valeur de probabilité compartimentée, allant de VERY_UNLIKELY à VERY_LIKELY.

Lorsque la fonctionnalité de détection de contenu explicite évalue une vidéo, elle le fait sur la base des prises de vue, et ne prend en compte que le contenu visuel. La partie audio de la vidéo n'est pas utilisée. Google ne garantit pas la justesse de ses prédictions relatives à la détection de contenu explicite.

Voici l'exemple d'une analyse de détection de contenu explicite d'un fichier vidéo se trouvant dans Google Cloud Storage.

Protocole

Reportez-vous au point de terminaison videos:annotate de l'API pour obtenir des informations complètes à ce sujet.

Pour lancer une détection de thèmes, utilisez une requête POST dont le corps approprié est :

POST https://videointelligence.googleapis.com/v1/videos:annotate?key=YOUR_API_KEY
{
  "inputUri": "gs://demomaker/gbikes_dinosaur.mp4",
  "features": ["EXPLICIT_CONTENT_DETECTION"]
}

Si une requête d'annotation Video Intelligence aboutit, elle renvoie une réponse qui ne contient qu'un champ de nom :

{
  "name": "us-west1.16680573"
}

Ce nom représente une opération de longue durée, qui peut être interrogée à l'aide de l'API v1.operations.

Pour récupérer la réponse de l'annotation vidéo, envoyez une requête GET au point de terminaison v1.operations, en transmettant la valeur de name dans l'URL. Si l'opération est terminée, elle renverra les résultats de l'annotation.

Les annotations de recherche de thèmes sont renvoyées sous la forme d'une liste explicitAnnotation.

{
  "name": "us-west1.10950655717927258341",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.videointelligence.v1.AnnotateVideoProgress",
    "annotationProgress": [
      {
        "inputUri": "/demomaker/gbikes_dinosaur.mp4",
        "progressPercent": 100,
        "startTime": "2017-08-26T00:16:35.112404Z",
        "updateTime": "2017-08-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"
            }
          ]
        }
      }
    ]
  }
}

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

Pour en savoir plus sur l'installation et l'utilisation de la bibliothèque cliente de l'API Cloud Video Intelligence pour Python, reportez-vous aux bibliothèques clientes de l'API Cloud Video Intelligence.
""" Detects explicit content from the GCS path to a video. """
video_client = videointelligence.VideoIntelligenceServiceClient()
features = [videointelligence.enums.Feature.EXPLICIT_CONTENT_DETECTION]

operation = video_client.annotate_video(path, features=features)
print('\nProcessing video for explicit content annotations:')

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

# first result is retrieved because a single video was processed
for frame in result.annotation_results[0].explicit_annotation.frames:
    likelihood = enums.Likelihood(frame.pornography_likelihood)
    frame_time = frame.time_offset.seconds + frame.time_offset.nanos / 1e9
    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.new

# Register a callback during the method call
operation = video.annotate_video input_uri: path, features: [:EXPLICIT_CONTENT_DETECTION] do |operation|
  raise operation.results.message? if operation.error?
  puts "Finished Processing."

  explicit_annotation = operation.results.annotation_results.first.explicit_annotation

  explicit_annotation.frames.each do |frame|
    frame_time = frame.time_offset.seconds + frame.time_offset.nanos / 1e9

    puts "Time: #{frame_time}"
    puts "pornography: #{frame.pornography_likelihood}"
  end
end

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

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Documentation de l'API Cloud Video Intelligence