Video-inhoud analyseren op ongewenst materiaal in C#

Dit artikel bevat informatie en codevoorbeelden om u te helpen aan de slag te gaan met de Content Moderator SDK voor .NET om video-inhoud te scannen op inhoud voor volwassenen of ongepaste inhoud.

Als u geen Azure-abonnement hebt, maakt u een gratis account voordat u begint.

Vereisten

• Een versie van Visual Studio 2015 of 2017

Azure-resources instellen

De mogelijkheid voor videobeheer van Content Moderator is beschikbaar als een gratis openbare preview-mediaprocessor in Azure Media Services (AMS). Azure Media Services is een gespecialiseerde Azure-service voor het opslaan en streamen van video-inhoud.

Een Azure Media Services-account maken

Volg de instructies in Een Azure Media Services-account maken om u te abonneren op AMS en een gekoppeld Azure-opslagaccount te maken. Maak in dat opslagaccount een nieuwe Blob Storage-container.

Een Microsoft Entra-toepassing maken

Navigeer naar uw nieuwe AMS-abonnement in Azure Portal en selecteer API-toegang in het zijmenu. Selecteer Verbinding maken naar Azure Media Services met service-principal. Noteer de waarde in het veld rest API-eindpunt . U hebt deze later nodig.

Selecteer In de sectie Microsoft Entra-app de optie Nieuwe maken en geef uw nieuwe Microsoft Entra-toepassingsregistratie een naam (bijvoorbeeld 'VideoModADApp'). Selecteer Opslaan en wacht enkele minuten terwijl de toepassing is geconfigureerd. Vervolgens ziet u de nieuwe app-registratie onder de sectie Microsoft Entra-app van de pagina.

Selecteer uw app-registratie en klik op de knop Toepassing beheren eronder. Noteer de waarde in het veld Toepassings-id . U hebt deze later nodig. Selecteer Instellingen> Sleutels en voer een beschrijving in voor een nieuwe sleutel (zoals 'VideoModKey'). Selecteer Opslaan en let vervolgens op de nieuwe sleutelwaarde. Kopieer deze tekenreeks en sla deze ergens veilig op.

Zie Aan de slag met Microsoft Entra-verificatie voor een uitgebreider overzicht van het bovenstaande proces.

Zodra u dit hebt gedaan, kunt u de mediaprocessor voor videobeheer op twee verschillende manieren gebruiken.

Azure Media Services Explorer gebruiken

Azure Media Services Explorer is een gebruiksvriendelijke front-end voor AMS. Gebruik het om door uw AMS-account te bladeren, video's te uploaden en inhoud te scannen met de Content Moderator-mediaprocessor. Download en installeer het vanuit GitHub of zie het blogbericht van Azure Media Services Explorer voor meer informatie.

Het Visual Studio-project maken

1. Maak in Visual Studio een nieuw Console-appproject (.NET Framework) en noem het VideoModeration.
2. Als uw oplossing nog meer projecten bevat, selecteert u deze als het enkele opstartproject.
3. Download de vereiste NuGet-pakketten. Klik met de rechtermuisknop op uw project in Solution Explorer en selecteer NuGet-pakketten beheren. Zoek en installeer vervolgens de volgende pakketten:
   • windowsazure.mediaservices
   • windowsazure.mediaservices.extensions

Code voor videobeheer toevoegen

Vervolgens kopieert en plakt u de code uit deze handleiding in uw project om een eenvoudig scenario voor inhoudstoezicht te implementeren.

De using-instructies van het programma bijwerken

Voeg aan het begin van het bestand Program.cs de volgende using-instructies toe.

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;

Resourceverwijzingen instellen

Voeg de volgende statische velden toe aan de klasse Program in Program.cs. Deze velden bevatten de informatie die nodig is om verbinding te maken met uw AMS-abonnement. Vul ze in met de waarden die u in de bovenstaande stappen hebt gekregen. Let op: CLIENT_ID de waarde van de toepassings-id van uw Microsoft Entra-app en CLIENT_SECRET is de waarde van de 'VideoModKey' die u voor die app hebt gemaakt.

// 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";

Belangrijk

Vergeet niet de sleutels uit uw code te verwijderen wanneer u klaar bent, en maak deze sleutels nooit openbaar. Gebruik voor productie een veilige manier om uw referenties op te slaan en te openen, zoals Azure Key Vault. Zie het beveiligingsartikel over Azure AI-services voor meer informatie.

Als u een lokaal videobestand wilt gebruiken (eenvoudigste geval), voegt u dit toe aan het project en voert u het pad in als de INPUT_FILE waarde (relatieve paden zijn relatief ten opzichte van de uitvoeringsmap).

U moet ook het bestand preset.json maken in de huidige map en dit gebruiken om een versienummer op te geven. Bijvoorbeeld:

{
    "version": "2.0"
}

De invoervideo('s) laden

Met de hoofdmethode van de klasse Program maakt u een Azure Media-context en vervolgens een Azure Storage-context (voor het geval uw video's zich in blobopslag bevinden). De resterende code scant een video vanuit een lokale map, blob of meerdere blobs in een Azure-opslagcontainer. U kunt alle opties proberen door de andere regels code als commentaar te geven.

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

Een Azure Media-context maken

Voeg de volgende methode toe aan de klasse Program. Hierbij worden uw AMS-referenties gebruikt om communicatie met AMS mogelijk te maken.

// 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);
}

De code toevoegen om een Azure Storage-context te maken

Voeg de volgende methode toe aan de klasse Program. U gebruikt de opslagcontext, gemaakt op basis van uw opslagreferenties, voor toegang tot uw blobopslag.

// 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);
}

Voeg de code toe om Azure Media Assets te maken op basis van een lokaal bestand en een blob

De Content Moderator-mediaprocessor voert taken uit op assets binnen het Azure Media Services-platform. Met deze methoden maakt u de assets op basis van een lokaal bestand of een gekoppelde 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);
}

Voeg de code toe om een verzameling video's (als blobs) in een container te scannen

// 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;
}

Voeg de methode toe om de Content Moderator-taak uit te voeren

// 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);
}

Helperfuncties toevoegen

Met deze methoden wordt het Content Moderator-uitvoerbestand (JSON) gedownload van de Azure Media Services-asset en wordt de status van de beheertaak bijgehouden, zodat het programma een actieve status kan registreren bij de 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;
    }
}

Het programma uitvoeren en de uitvoer controleren

Nadat de inhoudsbeheertaak is voltooid, analyseert u het JSON-antwoord. Het bestaat uit deze elementen:

• Samenvatting van videogegevens
• Schoten als 'fragmenten'
• Sleutelframes als 'gebeurtenissen' met een reviewRecommended (= true of false)' vlag op basis van volwassen en Racy-scores
• begin, duur, totalDuration en tijdstempel bevinden zich in 'tikken'. Deel door tijdschaal om het getal in seconden op te halen.

Notitie

• adultScore vertegenwoordigt de mogelijke aanwezigheids- en voorspellingsscore van inhoud die in bepaalde situaties als seksueel expliciet of volwassen kan worden beschouwd.
• racyScore vertegenwoordigt de mogelijke aanwezigheids- en voorspellingsscore van inhoud die in bepaalde situaties als seksueel suggestief of volwassen kan worden beschouwd.
• adultScore en racyScore liggen tussen 0 en 1. Hoe hoger de score, hoe hoger het model voorspelt dat de categorie van toepassing kan zijn. Deze preview is afhankelijk van een statistisch model in plaats van handmatig gecodeerde resultaten. We raden u aan om te testen met uw eigen inhoud om te bepalen hoe elke categorie overeenkomt met uw vereisten.
• reviewRecommended is waar of onwaar, afhankelijk van de interne scoredrempels. Klanten moeten beoordelen of ze deze waarde moeten gebruiken of moeten beslissen over aangepaste drempelwaarden op basis van hun inhoudsbeleid.

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

Volgende stappen

Download de Visual Studio-oplossing voor deze en andere Content Moderator-quickstarts voor .NET.