Analisar conteúdo de vídeo para material censurável em C #Analyze video content for objectionable material in C#

Este artigo fornece informações e amostras de código para ajudá-lo a começar a usar o SDK moderador de conteúdo para .NET para digitalizar conteúdo sonoro para conteúdos adultos ou picantes.This article provides information and code samples to help you get started using the Content Moderator SDK for .NET to scan video content for adult or racy content.

Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar.If you don't have an Azure subscription, create a free account before you begin.

Pré-requisitosPrerequisites

Configurar recursos do AzureSet up Azure resources

A capacidade de moderação de vídeo do Moderador de Conteúdo está disponível como um processador de visualização pública gratuito em Azure Media Services (AMS).The Content Moderator's video moderation capability is available as a free public preview media processor in Azure Media Services (AMS). O Azure Media Services é um serviço Azure especializado para armazenar e transmitir conteúdos de vídeo.Azure Media Services is a specialized Azure service for storing and streaming video content.

Criar uma conta dos Media Services do AzureCreate an Azure Media Services account

Siga as instruções na Create a Azure Media Services para subscrever a AMS e criar uma conta de armazenamento Azure associada.Follow the instructions in Create an Azure Media Services account to subscribe to AMS and create an associated Azure storage account. Nessa conta de armazenamento, crie um novo recipiente de armazenamento Blob.In that storage account, create a new Blob storage container.

Criar uma aplicação azure ative diretórioCreate an Azure Active Directory application

Navegue para a sua nova subscrição AMS no portal Azure e selecione o acesso a API a partir do menu lateral.Navigate to your new AMS subscription in the Azure portal and select API access from the side menu. Selecione Connect to Azure Media Services com o diretor de serviço.Select Connect to Azure Media Services with service principal. Note o valor no campo final da API REST; Vai precisar disto mais tarde.Note the value in the REST API endpoint field; you will need this later.

Na secção de aplicações Azure AD, selecione Create New e nomeie o seu novo registo de aplicação Azure AD (por exemplo, "VideoModADApp").In the Azure AD app section, select Create New and name your new Azure AD application registration (for example, "VideoModADApp"). Clique em Guardar e aguarde alguns minutos enquanto a aplicação estiver configurada.Click Save and wait a few minutes while the application is configured. Em seguida, deverá ver o seu novo registo de aplicações na secção de aplicações Azure AD da página.Then, you should see your new app registration under the Azure AD app section of the page.

Selecione o registo da sua aplicação e clique no botão 'Gerir' abaixo.Select your app registration and click the Manage application button below it. Note o valor no campo de ID da aplicação; Vai precisar disto mais tarde.Note the value in the Application ID field; you will need this later. Selecione Teclasde > Definiçõese introduza uma descrição para uma nova tecla (como "VideoModKey").Select Settings > Keys, and enter a description for a new key (such as "VideoModKey"). Clique em Guardare, em seguida, note o novo valor-chave.Click Save, and then notice the new key value. Copie esta corda e guarde-a em algum lugar seguro.Copy this string and save it somewhere secure.

Para uma passagem mais completa do processo acima, Veja Começar com a autenticação Azure AD.For a more thorough walkthrough of the above process, See Get started with Azure AD authentication.

Uma vez feito isto, pode usar o processador de mídia de moderação de vídeo de duas maneiras diferentes.Once you've done this, you can use the video moderation media processor in two different ways.

Utilizar o Azure Media Services ExplorerUse Azure Media Services Explorer

O Azure Media Services Explorer é um frontend amigável para a AMS.The Azure Media Services Explorer is a user-friendly frontend for AMS. Use-a para navegar na sua conta AMS, fazer upload de vídeos e digitalizar conteúdos com o processador de mídia Moderador de Conteúdo.Use it to browse your AMS account, upload videos, and scan content with the Content Moderator media processor. Descarregue e instale-o a partir do GitHub,ou consulte o post do blog Azure Media Services Explorer para obter mais informações.Download and install it from GitHub, or see the Azure Media Services Explorer blog post for more information.

Explorador de Serviços De Mídia Azure com Moderador de Conteúdo

Criar o projeto do Visual StudioCreate the Visual Studio project

  1. No Estúdio Visual, crie um novo projeto de aplicação de consola (.NET Framework) e nomeie-o VideoModeration.In Visual Studio, create a new Console app (.NET Framework) project and name it VideoModeration.
  2. Se houver outros projetos na sua solução, selecione esta como o único projeto de arranque.If there are other projects in your solution, select this one as the single startup project.
  3. Obtenha os pacotes NuGet necessários.Get the required NuGet packages. Clique com o botão direito do rato no seu projeto no Explorador de Soluções e selecione Manage NuGet Packages (Gerir Pacotes NuGet); em seguida, localize e instale os pacotes seguintes:Right-click on your project in the Solution Explorer and select Manage NuGet Packages; then find and install the following packages:
    • windowsazure.mediaserviceswindowsazure.mediaservices
    • windowsazure.mediaservices.extensionswindowsazure.mediaservices.extensions

Adicione código de moderação de vídeoAdd video moderation code

Depois, vai copiar e colar o código neste guia no projeto, para implementar um cenário de moderação de conteúdos simples.Next, you'll copy and paste the code from this guide into your project to implement a basic content moderation scenario.

Atualizar as instruções de utilização do programaUpdate the program's using statements

Adicione as declarações using seguintes à parte superior do ficheiro Program.cs.Add the following using statements to the top of your Program.cs file.

using System;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.WindowsAzure.MediaServices.Client;
using System.IO;
using System.Threading;
using Microsoft.WindowsAzure.Storage.Blob;
using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Auth;
using System.Collections.Generic;

Configurar referências de recursosSet up resource references

Adicione os seguintes campos estáticos à classe Programa em Program.cs.Add the following static fields to the Program class in Program.cs. Estes campos possuem as informações necessárias para a ligação à sua subscrição AMS.These fields hold the information necessary for connecting to your AMS subscription. Preencha-os com os valores que obteve nos degraus acima.Fill them in with the values you got in the steps above. Tenha em anote que CLIENT_ID é o valor de ID de aplicação da sua aplicação Azure AD, e CLIENT_SECRET é o valor do "VideoModKey" que criou para essa aplicação.Note that CLIENT_ID is the Application ID value of your Azure AD app, and CLIENT_SECRET is the value of the "VideoModKey" that you created for that app.

// declare constants and globals
private static CloudMediaContext _context = null;
private static CloudStorageAccount _StorageAccount = null;

// Azure Media Services (AMS) associated Storage Account, Key, and the Container that has 
// a list of Blobs to be processed.
static string STORAGE_NAME = "YOUR AMS ASSOCIATED BLOB STORAGE NAME";
static string STORAGE_KEY = "YOUR AMS ASSOCIATED BLOB STORAGE KEY";
static string STORAGE_CONTAINER_NAME = "YOUR BLOB CONTAINER FOR VIDEO FILES";

private static StorageCredentials _StorageCredentials = null;

// Azure Media Services authentication. 
private const string AZURE_AD_TENANT_NAME = "microsoft.onmicrosoft.com";
private const string CLIENT_ID = "YOUR CLIENT ID";
private const string CLIENT_SECRET = "YOUR CLIENT SECRET";

// REST API endpoint, for example "https://accountname.restv2.westcentralus.media.azure.net/API".      
private const string REST_API_ENDPOINT = "YOUR API ENDPOINT";

// Content Moderator Media Processor Nam
private const string MEDIA_PROCESSOR = "Azure Media Content Moderator";

// Input and Output files in the current directory of the executable
private const string INPUT_FILE = "VIDEO FILE NAME";
private const string OUTPUT_FOLDER = "";

// JSON settings file
private static readonly string CONTENT_MODERATOR_PRESET_FILE = "preset.json";

Se desejar utilizar um ficheiro de vídeo local (caso mais simples), adicione-o ao projeto e entre no seu caminho como valor INPUT_FILE (os caminhos relativos são relativos ao diretório de execução).If you wish to use a local video file (simplest case), add it to the project and enter its path as the INPUT_FILE value (relative paths are relative to the execution directory).

Também terá de criar o ficheiro preset.json no diretório atual e usá-lo para especificar um número de versão.You will also need to create the preset.json file in the current directory and use it to specify a version number. Por exemplo:For example:

{
    "version": "2.0"
}

Carregar os vídeos de entrada(s)Load the input video(s)

O método principal da classe Program criará um Contexto Azure Media e, em seguida, um Contexto de Armazenamento Azure (caso os seus vídeos estejam no armazenamento de blob).The Main method of the Program class will create an Azure Media Context and then an Azure Storage Context (in case your videos are in blob storage). O código restante digitaliza um vídeo de uma pasta local, blob ou múltiplas bolhas dentro de um recipiente de armazenamento Azure.The remaining code scans a video from a local folder, blob, or multiple blobs within an Azure storage container. Pode experimentar todas as opções comentando as outras linhas de código.You can try all options by commenting out the other lines of code.

// Create Azure Media Context
CreateMediaContext();

// Create Storage Context
CreateStorageContext();

// Use a file as the input.
IAsset asset = CreateAssetfromFile();

// -- OR ---

// Or a blob as the input
// IAsset asset = CreateAssetfromBlob((CloudBlockBlob)GetBlobsList().First());

// Then submit the asset to Content Moderator
RunContentModeratorJob(asset);

//-- OR ----

// Just run the content moderator on all blobs in a list (from a Blob Container)
// RunContentModeratorJobOnBlobs();

Criar um contexto azure mediaCreate an Azure Media Context

Adicione o seguinte método à classe Programa.Add the following method to the Program class. Isto utiliza as suas credenciais AMS para permitir a comunicação com a AMS.This uses your AMS credentials to allow communication with AMS.

// Creates a media context from azure credentials
static void CreateMediaContext()
{
    // Get Azure AD credentials
    var tokenCredentials = new AzureAdTokenCredentials(AZURE_AD_TENANT_NAME,
        new AzureAdClientSymmetricKey(CLIENT_ID, CLIENT_SECRET),
        AzureEnvironments.AzureCloudEnvironment);

    // Initialize an Azure AD token
    var tokenProvider = new AzureAdTokenProvider(tokenCredentials);

    // Create a media context
    _context = new CloudMediaContext(new Uri(REST_API_ENDPOINT), tokenProvider);
}

Adicione o código para criar um contexto de armazenamento azureAdd the code to create an Azure Storage Context

Adicione o seguinte método à classe Programa.Add the following method to the Program class. Utiliza o Contexto de Armazenamento, criado a partir das suas credenciais de armazenamento, para aceder ao seu armazenamento de blob.You use the Storage Context, created from your storage credentials, to access your blob storage.

// Creates a storage context from the AMS associated storage name and key
static void CreateStorageContext()
{
    // Get a reference to the storage account associated with a Media Services account. 
    if (_StorageCredentials == null)
    {
        _StorageCredentials = new StorageCredentials(STORAGE_NAME, STORAGE_KEY);
    }
    _StorageAccount = new CloudStorageAccount(_StorageCredentials, false);
}

Adicione o código para criar ativos azure media a partir de arquivo local e blobAdd the code to create Azure Media Assets from local file and blob

O processador de mídia Content Moderator gere empregos em Ativos dentro da plataforma Azure Media Services.The Content Moderator media processor runs jobs on Assets within the Azure Media Services platform. Estes métodos criam os Ativos a partir de um ficheiro local ou de uma bolha associada.These methods create the Assets from a local file or an associated blob.

// Creates an Azure Media Services Asset from the video file
static IAsset CreateAssetfromFile()
{
    return _context.Assets.CreateFromFile(INPUT_FILE, AssetCreationOptions.None); ;
}

// Creates an Azure Media Services asset from your blog storage
static IAsset CreateAssetfromBlob(CloudBlockBlob Blob)
{
    // Create asset from the FIRST blob in the list and return it
    return _context.Assets.CreateFromBlob(Blob, _StorageCredentials, AssetCreationOptions.None);
}

Adicione o código para digitalizar uma coleção de vídeos (como bolhas) dentro de um recipienteAdd the code to scan a collection of videos (as blobs) within a container

// Runs the Content Moderator Job on all Blobs in a given container name
static void RunContentModeratorJobOnBlobs()
{
    // Get the reference to the list of Blobs. See the following method.
    var blobList = GetBlobsList();

    // Iterate over the Blob list items or work on specific ones as needed
    foreach (var sourceBlob in blobList)
    {
        // Create an Asset
        IAsset asset = _context.Assets.CreateFromBlob((CloudBlockBlob)sourceBlob,
                            _StorageCredentials, AssetCreationOptions.None);
        asset.Update();

        // Submit to Content Moderator
        RunContentModeratorJob(asset);
    }
}

// Get all blobs in your container
static IEnumerable<IListBlobItem> GetBlobsList()
{
    // Get a reference to the Container within the Storage Account
    // that has the files (blobs) for moderation
    CloudBlobClient CloudBlobClient = _StorageAccount.CreateCloudBlobClient();
    CloudBlobContainer MediaBlobContainer = CloudBlobClient.GetContainerReference(STORAGE_CONTAINER_NAME);

    // Get the reference to the list of Blobs 
    var blobList = MediaBlobContainer.ListBlobs();
    return blobList;
}

Adicione o método para executar o Trabalho de Moderador de ConteúdoAdd the method to run the Content Moderator Job

// Run the Content Moderator job on the designated Asset from local file or blob storage
static void RunContentModeratorJob(IAsset asset)
{
    // Grab the presets
    string configuration = File.ReadAllText(CONTENT_MODERATOR_PRESET_FILE);

    // grab instance of Azure Media Content Moderator MP
    IMediaProcessor mp = _context.MediaProcessors.GetLatestMediaProcessorByName(MEDIA_PROCESSOR);

    // create Job with Content Moderator task
    IJob job = _context.Jobs.Create(String.Format("Content Moderator {0}",
            asset.AssetFiles.First() + "_" + Guid.NewGuid()));

    ITask contentModeratorTask = job.Tasks.AddNew("Adult and racy classifier task",
            mp, configuration,
            TaskOptions.None);
    contentModeratorTask.InputAssets.Add(asset);
    contentModeratorTask.OutputAssets.AddNew("Adult and racy classifier output",
        AssetCreationOptions.None);

    job.Submit();


    // Create progress printing and querying tasks
    Task progressPrintTask = new Task(() =>
    {
        IJob jobQuery = null;
        do
        {
            var progressContext = _context;
            jobQuery = progressContext.Jobs
            .Where(j => j.Id == job.Id)
                .First();
                Console.WriteLine(string.Format("{0}\t{1}",
                DateTime.Now,
                jobQuery.State));
                Thread.Sleep(10000);
            }
            while (jobQuery.State != JobState.Finished &&
            jobQuery.State != JobState.Error &&
            jobQuery.State != JobState.Canceled);
    });
    progressPrintTask.Start();

    Task progressJobTask = job.GetExecutionProgressTask(
    CancellationToken.None);
    progressJobTask.Wait();

    // If job state is Error, the event handling 
    // method for job progress should log errors.  Here we check 
    // for error state and exit if needed.
    if (job.State == JobState.Error)
    {
        ErrorDetail error = job.Tasks.First().ErrorDetails.First();
        Console.WriteLine(string.Format("Error: {0}. {1}",
        error.Code,
        error.Message));
    }

    DownloadAsset(job.OutputMediaAssets.First(), OUTPUT_FOLDER);
}

Adicionar funções de ajudanteAdd helper functions

Estes métodos descarregam o ficheiro de saída do Moderador de Conteúdo (JSON) do ativo azure Media Services e ajudam a rastrear o estado do trabalho de moderação para que o programa possa registar um estado de execução na consola.These methods download the Content Moderator output file (JSON) from the Azure Media Services asset, and help track the status of the moderation job so that the program can log a running status to the console.

static void DownloadAsset(IAsset asset, string outputDirectory)
{
    foreach (IAssetFile file in asset.AssetFiles)
    {
        file.Download(Path.Combine(outputDirectory, file.Name));
    }
}

// event handler for Job State
static void StateChanged(object sender, JobStateChangedEventArgs e)
{
    Console.WriteLine("Job state changed event:");
    Console.WriteLine("  Previous state: " + e.PreviousState);
    Console.WriteLine("  Current state: " + e.CurrentState);
    switch (e.CurrentState)
    {
        case JobState.Finished:
            Console.WriteLine();
            Console.WriteLine("Job finished.");
            break;
        case JobState.Canceling:
        case JobState.Queued:
        case JobState.Scheduled:
        case JobState.Processing:
            Console.WriteLine("Please wait...\n");
            break;
        case JobState.Canceled:
            Console.WriteLine("Job is canceled.\n");
            break;
        case JobState.Error:
            Console.WriteLine("Job failed.\n");
            break;
        default:
            break;
    }
}

Executar o programa e rever o resultadoRun the program and review the output

Após a conclusão do trabalho de moderação de conteúdo, analise a resposta json.After the Content Moderation job is completed, analyze the JSON response. É constituído por estes elementos:It consists of these elements:

  • Resumo da informação de vídeoVideo information summary
  • Tiros como "fragmentos"Shots as "fragments"
  • Quadros-chave como "eventos" com uma revisãoRecomendado " (= verdadeiro ou falso)" bandeira baseada em pontuações de Adulto e PicanteKey frames as "events" with a reviewRecommended" (= true or false)" flag based on Adult and Racy scores
  • início, duração, duração total, e carimbo de tempo estão em "tiques".start, duration, totalDuration, and timestamp are in "ticks". Divida por tempo para obter o número em segundos.Divide by timescale to get the number in seconds.

Nota

  • adultScorerepresenta a presença potencial e a pontuação de previsão de conteúdo que pode ser considerada sexualmente explícita ou adulta em determinadas situações.adultScore represents the potential presence and prediction score of content that may be considered sexually explicit or adult in certain situations.
  • racyScorerepresenta a presença potencial e a pontuação de previsão de conteúdo que pode ser considerada sexualmente sugestiva ou madura em determinadas situações.racyScore represents the potential presence and prediction score of content that may be considered sexually suggestive or mature in certain situations.
  • adultScoree racyScore estão entre 0 e 1.adultScore and racyScore are between 0 and 1. Quanto maior for a pontuação, maior é o modelo que prevê que a categoria pode ser aplicável.The higher the score, the higher the model is predicting that the category may be applicable. Esta pré-visualização baseia-se num modelo estatístico e não em resultados codificados manualmente.This preview relies on a statistical model rather than manually coded outcomes. Recomendamos testar com o seu próprio conteúdo para determinar como cada categoria se alinha com os seus requisitos.We recommend testing with your own content to determine how each category aligns to your requirements.
  • reviewRecommendedé verdadeiro ou falso dependendo dos limiares de pontuação internos.reviewRecommended is either true or false depending on the internal score thresholds. Os clientes devem avaliar se utilizam este valor ou decidem sobre os limiares personalizados com base nas suas políticas de conteúdo.Customers should assess whether to use this value or decide on custom thresholds based on their content policies.
{
"version": 2,
"timescale": 90000,
"offset": 0,
"framerate": 50,
"width": 1280,
"height": 720,
"totalDuration": 18696321,
"fragments": [
{
    "start": 0,
    "duration": 18000
},
{
    "start": 18000,
    "duration": 3600,
    "interval": 3600,
    "events": [
    [
        {
        "reviewRecommended": false,
        "adultScore": 0.00001,
        "racyScore": 0.03077,
        "index": 5,
        "timestamp": 18000,
        "shotIndex": 0
        }
    ]
    ]
},
{
    "start": 18386372,
    "duration": 119149,
    "interval": 119149,
    "events": [
    [
        {
        "reviewRecommended": true,
        "adultScore": 0.00000,
        "racyScore": 0.91902,
        "index": 5085,
        "timestamp": 18386372,
        "shotIndex": 62
        }
    ]
    ]
}
]
}

Passos seguintesNext steps

Saiba como gerar críticas de vídeo a partir da sua saída de moderação.Learn how to generate video reviews from your moderation output.

Adicione moderação da transcrição às suas análises de vídeo.Add transcript moderation to your video reviews.

Confira o tutorial detalhado sobre como construir uma solução completa de moderação de vídeo e transcrição.Check out the detailed tutorial on how to build a complete video and transcript moderation solution.

Baixe a solução Visual Studio para este e outros quickstarts de Moderador de Conteúdo para .NET.Download the Visual Studio solution for this and other Content Moderator quickstarts for .NET.