不適切な動画コンテンツ検出のアノテーションの分析

不適切なコンテンツの検出では、動画内のアダルト コンテンツを検出します。通常、アダルト コンテンツは 18 歳以上を対象としたもので、ヌードや性的描写、ポルノに限定されるものではありません。漫画やアニメも対象になります。

レスポンスには、バケット化された可能性の値(VERY_UNLIKELY から VERY_LIKELY まで)が含まれます。

不適切なコンテンツの検出で動画を評価すると、フレーム単位で分析が実行されます。評価されるのはビジュアル コンテンツのみです。動画の音声部分は、不適切なコンテンツのレベルが評価されません。Google は、不適切なコンテンツの検出結果に対する正確性を保証しません。

ここでは、Google Cloud Storage にある動画ファイルに不適切なコンテンツ検出機能を実行し、動画の分析を行います。

プロトコル

詳細については、videos:annotate API エンドポイントをご覧ください。

ラベル検出を行うには、POST リクエストを作成して適切なリクエスト本文を提供します。

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

Video Intelligence のアノテーション リクエストに成功すると、次のような name フィールドを含むレスポンスが返されます。

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

この名前は長時間実行オペレーションを表しています。v1.operations API を使用すると、長時間実行オペレーションをクエリできます。

動画のアノテーション レスポンスを取得するには、v1.operations エンドポイントに GET リクエストを送信し、URL で name の値を渡します。オペレーションが完了すると、アノテーションの結果が返されます。

ラベル検索のアノテーションは、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

Python 用の Cloud Video Intelligence API クライアント ライブラリのインストールと使用方法については、Cloud Video Intelligence API クライアント ライブラリをご覧ください。
""" 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!

このページは役立ちましたか?評価をお願いいたします。

フィードバックを送信...

Cloud Video Intelligence API ドキュメント