Schnellstart: Verwenden der Clientbibliothek des Inhaltsmoderators

Erste Schritte mit der Azure-Content-Moderator-Clientbibliothek für .NET. Führen Sie die folgenden Schritte aus, um das NuGet-Paket zu installieren und den Beispielcode für grundlegende Aufgaben auszuprobieren.

Der Inhaltsmoderator ist ein KI-Dienst, mit dem Sie Inhalte behandeln können, die potenziell anstößig, riskant oder anderweitig unerwünscht sind. Verwenden Sie den KI-basierten Inhaltsmoderationsdienst, um Text, Bild und Videos zu scannen und Inhaltskennzeichnungen automatisch anzuwenden. Erstellen Sie Inhaltsfiltersoftware in Ihre App, um Vorschriften einzuhalten oder die beabsichtigte Umgebung für Ihre Benutzer aufrechtzuerhalten.

Verwenden Sie die Content Moderator-Clientbibliothek für .NET, um:

• Moderater Text
• Moderate Bilder

Reference-Dokumentation | Library Quellcode | Package (NuGet) | Beispiele

Voraussetzungen

• Azure-Abonnement – Create one for free
• Die Visual Studio-IDE oder die aktuelle Version von .NET Core.
• Sobald Sie Ihr Azure-Abonnement haben, eine Content Moderator-Ressource erstellen im Azure-Portal, um Ihren Schlüssel und Endpunkt zu erhalten. Warten Sie, bis sie bereitgestellt wird, und klicken Sie auf die Schaltfläche "Zur Ressource wechseln ".
  • Sie benötigen den Schlüssel und endpunkt aus der Ressource, die Sie erstellen, um Ihre Anwendung mit dem Inhaltsmoderator zu verbinden. Sie fügen Ihren Schlüssel und Endpunkt später in der Schnellstartanleitung in den folgenden Code ein.
  • Sie können das kostenlose Preisniveau (F0) verwenden, um den Dienst zu testen und später auf eine kostenpflichtige Stufe für die Produktion zu aktualisieren.

Einrichten

Erstellen einer neuen C#-Anwendung

dotnet new console -n content-moderator-quickstart

dotnet build

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

dotnet add package Microsoft.Azure.CognitiveServices.ContentModerator --version 2.0.0

Öffnen Sie im Projektverzeichnis die Program.cs Datei in Ihrem bevorzugten Editor oder ihrer bevorzugten IDE. Fügen Sie die folgenden using-Anweisungen ein:

using Microsoft.Azure.CognitiveServices.ContentModerator;
using Microsoft.Azure.CognitiveServices.ContentModerator.Models;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading;

Erstellen Sie in der Program-Klasse Variablen für den Schlüssel und Endpunkt Ihrer Ressource.

// Your Content Moderator subscription key is found in your Azure portal resource on the 'Keys' page.
private static readonly string SubscriptionKey = "PASTE_YOUR_CONTENT_MODERATOR_SUBSCRIPTION_KEY_HERE";
// Base endpoint URL. Found on 'Overview' page in Azure resource. For example: https://westus.api.cognitive.microsoft.com
private static readonly string Endpoint = "PASTE_YOUR_CONTENT_MODERATOR_ENDPOINT_HERE";

Fügen Sie in der Methode der Anwendung main() Aufrufe für die in dieser Schnellstartanleitung verwendeten Methoden hinzu. Sie erstellen diese später.

// Create an image review client
ContentModeratorClient clientImage = Authenticate(SubscriptionKey, Endpoint);
// Create a text review client
ContentModeratorClient clientText = Authenticate(SubscriptionKey, Endpoint);
// Create a human reviews client
ContentModeratorClient clientReviews = Authenticate(SubscriptionKey, Endpoint);

// Moderate text from text in a file
ModerateText(clientText, TextFile, TextOutputFile);

// Moderate images from list of image URLs
ModerateImages(clientImage, ImageUrlFile, ImageOutputFile);

Objektmodell

Die folgenden Klassen behandeln einige der wichtigsten Features des Inhaltsmoderators .NET Clientbibliothek.

Codebeispiele

Diese Codeausschnitte zeigen Ihnen, wie Sie die folgenden Aufgaben mit der Inhaltsmoderator-Clientbibliothek für .NET ausführen:

• Authentifizieren des Clients
• Moderater Text
• Moderate Bilder

Authentifizieren des Clients

Instanziieren Sie in einer neuen Methode Clientobjekte mit Ihrem Endpunkt und Schlüssel.

public static ContentModeratorClient Authenticate(string key, string endpoint)
{
    ContentModeratorClient client = new ContentModeratorClient(new ApiKeyServiceClientCredentials(key));
    client.Endpoint = endpoint;

    return client;
}

Moderater Text

Der folgende Code verwendet einen Inhaltsmoderator-Client, um einen Textkörper zu analysieren und die Ergebnisse in der Konsole zu drucken. Definieren Sie im Stammverzeichnis Ihrer Program-Klasse Eingabe- und Ausgabedateien:

// TEXT MODERATION
// Name of the file that contains text
private static readonly string TextFile = "TextFile.txt";
// The name of the file to contain the output from the evaluation.
private static string TextOutputFile = "TextModerationOutput.txt";

Fügen Sie dann im Stammverzeichnis Ihres Projekts eine TextFile.txt Datei hinzu. Fügen Sie dieser Datei Ihren eigenen Text hinzu, oder verwenden Sie den folgenden Beispieltext:

Is this a grabage email abcdef@abcd.com, phone: 4255550111, IP: 255.255.255.255, 1234 Main Boulevard, Panapolis WA 96555.
<offensive word> is the profanity here. Is this information PII? phone 4255550111

Definieren Sie dann die Textmoderationsmethode an einer beliebigen Stelle in Ihrer Programmklasse :

/*
 * TEXT MODERATION
 * This example moderates text from file.
 */
public static void ModerateText(ContentModeratorClient client, string inputFile, string outputFile)
{
    Console.WriteLine("--------------------------------------------------------------");
    Console.WriteLine();
    Console.WriteLine("TEXT MODERATION");
    Console.WriteLine();
    // Load the input text.
    string text = File.ReadAllText(inputFile);

    // Remove carriage returns
    text = text.Replace(Environment.NewLine, " ");
    // Convert string to a byte[], then into a stream (for parameter in ScreenText()).
    byte[] textBytes = Encoding.UTF8.GetBytes(text);
    MemoryStream stream = new MemoryStream(textBytes);

    Console.WriteLine("Screening {0}...", inputFile);
    // Format text

    // Save the moderation results to a file.
    using (StreamWriter outputWriter = new StreamWriter(outputFile, false))
    {
        using (client)
        {
            // Screen the input text: check for profanity, classify the text into three categories,
            // do autocorrect text, and check for personally identifying information (PII)
            outputWriter.WriteLine("Autocorrect typos, check for matching terms, PII, and classify.");

            // Moderate the text
            var screenResult = client.TextModeration.ScreenText("text/plain", stream, "eng", true, true, null, true);
            outputWriter.WriteLine(JsonConvert.SerializeObject(screenResult, Formatting.Indented));
        }

        outputWriter.Flush();
        outputWriter.Close();
    }

    Console.WriteLine("Results written to {0}", outputFile);
    Console.WriteLine();
}

Moderate Bilder

Im folgenden Code wird ein Content Moderator-Client zusammen mit einem ImageModeration-Objekt verwendet, um Remotebilder für erwachsene und rassige Inhalte zu analysieren.

Beispielbilder abrufen

Definieren Sie Ihre Eingabe- und Ausgabedateien im Stammverzeichnis Ihrer Programmklasse :

// IMAGE MODERATION
//The name of the file that contains the image URLs to evaluate.
private static readonly string ImageUrlFile = "ImageFiles.txt";
// The name of the file to contain the output from the evaluation.
private static string ImageOutputFile = "ImageModerationOutput.json";

Erstellen Sie dann die Eingabedatei ImageFiles.txtam Stamm des Projekts. In dieser Datei fügen Sie die ZU analysierenden URLs von Bildern hinzu – eine URL in jeder Zeile. Sie können die folgenden Beispielbilder verwenden:

https://moderatorsampleimages.blob.core.windows.net/samples/sample2.jpg
https://moderatorsampleimages.blob.core.windows.net/samples/sample5.png

Definieren der Hilfsklasse

Fügen Sie die folgende Klassendefinition in der Program-Klasse hinzu. Diese Innere Klasse wird die Ergebnisse der Bildmoderation bearbeiten.

// Contains the image moderation results for an image, 
// including text and face detection results.
public class EvaluationData
{
    // The URL of the evaluated image.
    public string ImageUrl;

    // The image moderation results.
    public Evaluate ImageModeration;

    // The text detection results.
    public OCR TextDetection;

    // The face detection results;
    public FoundFaces FaceDetection;
}

Definieren der Bildmoderationsmethode

Die folgende Methode iteriert über die Bild-URLs in einer Textdatei, erstellt eine EvaluationData-Instanz und analysiert das Bild auf Inhalte für Erwachsene/anstößige Inhalte, Text und menschliche Gesichter. Anschließend wird die endgültige EvaluationData-Instanz zu einer Liste hinzugefügt und die vollständige Liste der zurückgegebenen Daten in die Konsole geschrieben.

Durchlaufen von Bildern

/*
 * IMAGE MODERATION
 * This example moderates images from URLs.
 */
public static void ModerateImages(ContentModeratorClient client, string urlFile, string outputFile)
{
    Console.WriteLine("--------------------------------------------------------------");
    Console.WriteLine();
    Console.WriteLine("IMAGE MODERATION");
    Console.WriteLine();
    // Create an object to store the image moderation results.
    List<EvaluationData> evaluationData = new List<EvaluationData>();

    using (client)
    {
        // Read image URLs from the input file and evaluate each one.
        using (StreamReader inputReader = new StreamReader(urlFile))
        {
            while (!inputReader.EndOfStream)
            {
                string line = inputReader.ReadLine().Trim();
                if (line != String.Empty)
                {
                    Console.WriteLine("Evaluating {0}...", Path.GetFileName(line));
                    var imageUrl = new BodyModel("URL", line.Trim());

Analysieren von Inhalten

Weitere Informationen zu den Bildattributen, die der Inhaltsmoderator überprüft, finden Sie im Leitfaden für Bildmoderationskonzepte .

            var imageData = new EvaluationData
            {
                ImageUrl = imageUrl.Value,

                // Evaluate for adult and racy content.
                ImageModeration =
                client.ImageModeration.EvaluateUrlInput("application/json", imageUrl, true)
            };
            Thread.Sleep(1000);

            // Detect and extract text.
            imageData.TextDetection =
                client.ImageModeration.OCRUrlInput("eng", "application/json", imageUrl, true);
            Thread.Sleep(1000);

            // Detect faces.
            imageData.FaceDetection =
                client.ImageModeration.FindFacesUrlInput("application/json", imageUrl, true);
            Thread.Sleep(1000);

            // Add results to Evaluation object
            evaluationData.Add(imageData);
        }
    }
}

Schreiben von Moderationsergebnissen in eine Datei

        // Save the moderation results to a file.
        using (StreamWriter outputWriter = new StreamWriter(outputFile, false))
        {
            outputWriter.WriteLine(JsonConvert.SerializeObject(
                evaluationData, Formatting.Indented));

            outputWriter.Flush();
            outputWriter.Close();
        }
        Console.WriteLine();
        Console.WriteLine("Image moderation results written to output file: " + outputFile);
        Console.WriteLine();
    }
}

Ausführen der Anwendung

dotnet run

Bereinigen von Ressourcen

Wenn Sie ein Azure KI Services-Abonnement bereinigen und entfernen möchten, können Sie die Ressource oder Ressourcengruppe löschen. Durch das Löschen der Ressourcengruppe werden auch alle anderen ressourcen gelöscht, die ihr zugeordnet sind.

• Azure Portal
• Azure CLI

Nächste Schritte

In dieser Schnellstartanleitung haben Sie erfahren, wie Sie den Inhaltsmoderator .NET Bibliothek verwenden, um Moderationsaufgaben auszuführen. Erfahren Sie als Nächstes mehr über die Moderation von Bildern oder anderen Medien, indem Sie einen konzeptionellen Leitfaden lesen.

Erste Schritte mit der Azure Clientbibliothek für Inhaltsmoderator für Java. Führen Sie die folgenden Schritte aus, um das Maven-Paket zu installieren und den Beispielcode für grundlegende Aufgaben auszuprobieren.

Der Inhaltsmoderator ist ein KI-Dienst, mit dem Sie Inhalte behandeln können, die potenziell anstößig, riskant oder anderweitig unerwünscht sind. Verwenden Sie den KI-basierten Inhaltsmoderationsdienst, um Text, Bild und Videos zu scannen und Inhaltskennzeichnungen automatisch anzuwenden. Erstellen Sie Inhaltsfiltersoftware in Ihre App, um Vorschriften einzuhalten oder die beabsichtigte Umgebung für Ihre Benutzer aufrechtzuerhalten.

Verwenden Sie die Content Moderator-Clientbibliothek für Java, um:

• Moderater Text
• Moderate Bilder

Referenzdokumentation | Bibliotheksquellcode |Artefakt (Maven) | Beispiele

Voraussetzungen

• Ein Azure-Abonnement – Create one for free
• Die aktuelle Version des Java Development Kit (JDK)
• Das Gradle-Buildtool oder ein anderer Abhängigkeits-Manager.
• Sobald Sie Ihr Azure-Abonnement haben, eine Content Moderator-Ressource erstellen im Azure-Portal, um Ihren Schlüssel und Endpunkt zu erhalten. Warten Sie, bis sie bereitgestellt wird, und klicken Sie auf die Schaltfläche "Zur Ressource wechseln ".
  • Sie benötigen den Schlüssel und endpunkt aus der Ressource, die Sie erstellen, um Ihre Anwendung mit dem Inhaltsmoderator zu verbinden. Sie fügen Ihren Schlüssel und Endpunkt später in der Schnellstartanleitung in den folgenden Code ein.
  • Sie können das kostenlose Preisniveau (F0) verwenden, um den Dienst zu testen und später auf eine kostenpflichtige Stufe für die Produktion zu aktualisieren.

Einrichten

Erstellen eines neuen Gradle-Projekts

Erstellen Sie in einem Konsolenfenster (z. B. cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und navigieren Sie zu ihr.

mkdir myapp && cd myapp

Führen Sie den gradle init Befehl aus Ihrem Arbeitsverzeichnis aus. Mit diesem Befehl werden wichtige Builddateien für Gradle erstellt, einschließlich build.gradle.kts, die zur Laufzeit zum Erstellen und Konfigurieren Ihrer Anwendung verwendet werden.

gradle init --type basic

Wenn Sie aufgefordert werden, ein DSL auszuwählen, wählen Sie Kotlin aus.

Installieren der Clientbibliothek

Suchen Sie build.gradle.kts , und öffnen Sie sie mit Ihrer bevorzugten IDE oder Ihrem Text-Editor. Kopieren Sie die folgende Buildkonfiguration. Diese Konfiguration definiert das Projekt als Java Anwendung, deren Einstiegspunkt die Klasse ContentModeratorQuickstart ist. Sie importiert die Clientbibliothek des Inhaltsmoderators und das GSON-Sdk für die JSON-Serialisierung.

plugins {
    java
    application
}

application{ 
    mainClassName = "ContentModeratorQuickstart"
}

repositories{
    mavenCentral()
}

dependencies{
    compile(group = "com.microsoft.azure.cognitiveservices", name = "azure-cognitiveservices-contentmoderator", version = "1.0.2-beta")
    compile(group = "com.google.code.gson", name = "gson", version = "2.8.5")
}

Erstellen einer Java Datei

Führen Sie in Ihrem Arbeitsverzeichnis den folgenden Befehl aus, um einen Projektquellordner zu erstellen:

mkdir -p src/main/java

Navigieren Sie zum neuen Ordner, und erstellen Sie eine Datei namens ContentModeratorQuickstart.java. Öffnen Sie ihn in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE und fügen Sie die folgenden import Anweisungen hinzu:

import com.google.gson.*;

import com.microsoft.azure.cognitiveservices.vision.contentmoderator.*;
import com.microsoft.azure.cognitiveservices.vision.contentmoderator.models.*;

import java.io.*;
import java.util.*;
import java.util.concurrent.*;

Erstellen Sie in der ContentModeratorQuickstart-Klasse der Anwendung Variablen für den Schlüssel und Endpunkt Ihrer Ressource.

private static final String subscriptionKey = "<your-subscription-key>";
private static final String endpoint = "<your-api-endpoint>";

Fügen Sie in der Hauptmethode der Anwendung Aufrufe für die in dieser Schnellstartanleitung verwendeten Methoden hinzu. Sie definieren diese Methoden später.

// Create a List in which to store the image moderation results.
List<EvaluationData> evaluationData = new ArrayList<EvaluationData>();

// Moderate URL images
moderateImages(client, evaluationData);
// Moderate text from file
moderateText(client);
// Create a human review
humanReviews(client);

Objektmodell

Die folgenden Klassen behandeln einige der Hauptfunktionen der Inhaltsmoderator Java-Clientbibliothek.

Codebeispiele

Diese Codeausschnitte zeigen Ihnen, wie Sie die folgenden Aufgaben mit der Inhaltsmoderator-Clientbibliothek für Java ausführen:

• Authentifizieren des Clients
• Moderater Text
• Moderate Bilder

Authentifizieren des Clients

Erstellen Sie in der Methode der Anwendung ein main mithilfe des Abonnementendpunktwerts und des Abonnementschlüssels.

// Set CONTENT_MODERATOR_SUBSCRIPTION_KEY in your environment settings, with
// your key as its value.
// Set COMPUTER_MODERATOR_ENDPOINT in your environment variables with your Azure
// endpoint.
ContentModeratorClient client = ContentModeratorManager.authenticate(AzureRegionBaseUrl.fromString(endpoint),
        "CONTENT_MODERATOR_SUBSCRIPTION_KEY");

Moderater Text

Einrichten von Beispieltext

Definieren Sie oben in Ihrer ContentModeratorQuickstart-Klasse einen Verweis auf eine lokale Textdatei. Fügen Sie ihrem Projektverzeichnis eine .txt Datei hinzu, und geben Sie den Text ein, den Sie analysieren möchten.

// TEXT MODERATION variable
private static File textFile = new File("src\\main\\resources\\TextModeration.txt");

Analysieren von Text

Erstellen Sie eine neue Methode, die die .txt Datei liest, und ruft die screenText-Methode in jeder Zeile auf.

public static void moderateText(ContentModeratorClient client) {
    System.out.println("---------------------------------------");
    System.out.println("MODERATE TEXT");
    System.out.println();

    try (BufferedReader inputStream = new BufferedReader(new FileReader(textFile))) {
        String line;
        Screen textResults = null;
        // For formatting the printed results
        Gson gson = new GsonBuilder().setPrettyPrinting().create();

        while ((line = inputStream.readLine()) != null) {
            if (line.length() > 0) {
                textResults = client.textModerations().screenText("text/plain", line.getBytes(), null);
                // Uncomment below line to print in console
                // System.out.println(gson.toJson(textResults).toString());
            }
        }

Ergebnisse der Textmoderation drucken

Fügen Sie den folgenden Code hinzu, um die Moderationsergebnisse in einer .json Datei in Ihrem Projektverzeichnis zu drucken.

System.out.println("Text moderation status: " + textResults.status().description());
System.out.println();

// Create output results file to TextModerationOutput.json
BufferedWriter writer = new BufferedWriter(
        new FileWriter(new File("src\\main\\resources\\TextModerationOutput.json")));
writer.write(gson.toJson(textResults).toString());
System.out.println("Check TextModerationOutput.json to see printed results.");
System.out.println();
writer.close();

Schließen Sie die Anweisung try und catch, um die Methode abzuschließen.

    } catch (Exception e) {
        System.out.println(e.getMessage());
        e.printStackTrace();
    }
}

Moderate Bilder

Beispielbild einrichten

Erstellen Sie in einer neuen Methode ein BodyModelModel-Objekt mit einer bestimmten URL-Zeichenfolge, die auf ein Bild verweist.

public static void moderateImages(ContentModeratorClient client, List<EvaluationData> resultsList) {
    System.out.println();
    System.out.println("---------------------------------------");
    System.out.println("MODERATE IMAGES");
    System.out.println();

    try {
        String urlString = "https://moderatorsampleimages.blob.core.windows.net/samples/sample2.jpg";
        // Evaluate each line of text
        BodyModelModel url = new BodyModelModel();
        url.withDataRepresentation("URL");
        url.withValue(urlString);
        // Save to EvaluationData class for later
        EvaluationData imageData = new EvaluationData();
        imageData.ImageUrl = url.value();

Definieren der Hilfsklasse

Fügen Sie dann in Ihrer ContentModeratorQuickstart.java-Datei die folgende Klassendefinition in der ContentModeratorQuickstart-Klasse hinzu. Diese innere Klasse wird im Bildmoderationsprozess verwendet.

// Contains the image moderation results for an image, including text and face
// detection from the image.
public static class EvaluationData {
    // The URL of the evaluated image.
    public String ImageUrl;
    // The image moderation results.
    public Evaluate ImageModeration;
    // The text detection results.
    public OCR TextDetection;
    // The face detection results;
    public FoundFaces FaceDetection;
}

Analysieren von Inhalten

Diese Codezeile überprüft das Bild unter der angegebenen URL auf erwachsenen oder rassigen Inhalt. Informationen zu diesen Begriffen finden Sie im konzeptionellen Leitfaden zur Bildmoderation.

// Evaluate for adult and racy content.
imageData.ImageModeration = client.imageModerations().evaluateUrlInput("application/json", url,
        new EvaluateUrlInputOptionalParameter().withCacheImage(true));
Thread.sleep(1000);

Nach Text suchen

Diese Codezeile überprüft das Bild auf sichtbaren Text.

// Detect and extract text from image.
imageData.TextDetection = client.imageModerations().oCRUrlInput("eng", "application/json", url,
        new OCRUrlInputOptionalParameter().withCacheImage(true));
Thread.sleep(1000);

Nach Gesichtern suchen

Diese Codezeile überprüft das Bild auf menschliche Gesichter.

// Detect faces.
imageData.FaceDetection = client.imageModerations().findFacesUrlInput("application/json", url,
        new FindFacesUrlInputOptionalParameter().withCacheImage(true));
Thread.sleep(1000);

Speichern Sie schließlich die zurückgegebenen Informationen in der EvaluationData Liste.

resultsList.add(imageData);

Drucken von Ergebnissen

Fügen Sie nach der while Schleife den folgenden Code hinzu, der die Ergebnisse in der Konsole und in einer Ausgabedatei ausgibt, src/main/resources/ModerationOutput.json.

// Save the moderation results to a file.
// ModerationOutput.json contains the output from the evaluation.
// Relative paths are relative to the execution directory (where pom.xml is
// located).
BufferedWriter writer = new BufferedWriter(
        new FileWriter(new File("src\\main\\resources\\ImageModerationOutput.json")));
// For formatting the printed results
Gson gson = new GsonBuilder().setPrettyPrinting().create();

writer.write(gson.toJson(resultsList).toString());
System.out.println("Check ImageModerationOutput.json to see printed results.");
writer.close();

Schließen Sie die try Anweisung, und fügen Sie eine catch Anweisung hinzu, um die Methode abzuschließen.

} catch (Exception e) {
    System.out.println(e.getMessage());
    e.printStackTrace();
}

Ausführen der Anwendung

Sie können die App mit:

gradle build

Führen Sie die Anwendung mit dem gradle run Befehl aus:

gradle run

Navigieren Sie dann zur Datei "src/main/resources/ModerationOutput.json ", und zeigen Sie die Ergebnisse Der Inhaltsmoderation an.

Bereinigen von Ressourcen

Wenn Sie ein Azure KI Services-Abonnement bereinigen und entfernen möchten, können Sie die Ressource oder Ressourcengruppe löschen. Durch das Löschen der Ressourcengruppe werden auch alle anderen ressourcen gelöscht, die ihr zugeordnet sind.

• Azure Portal
• Azure CLI

Nächste Schritte

In dieser Schnellstartanleitung haben Sie erfahren, wie Sie den Inhaltsmoderator Java Bibliothek verwenden, um Moderationsaufgaben auszuführen. Erfahren Sie als Nächstes mehr über die Moderation von Bildern oder anderen Medien, indem Sie einen konzeptionellen Leitfaden lesen.

Erste Schritte mit der Azure Inhaltsmoderator-Clientbibliothek für Python. Führen Sie die folgenden Schritte aus, um das PiPy-Paket zu installieren und den Beispielcode für grundlegende Aufgaben auszuprobieren.

Der Inhaltsmoderator ist ein KI-Dienst, mit dem Sie Inhalte behandeln können, die potenziell anstößig, riskant oder anderweitig unerwünscht sind. Verwenden Sie den KI-basierten Inhaltsmoderationsdienst, um Text, Bild und Videos zu scannen und Inhaltskennzeichnungen automatisch anzuwenden. Erstellen Sie Inhaltsfiltersoftware in Ihre App, um Vorschriften einzuhalten oder die beabsichtigte Umgebung für Ihre Benutzer aufrechtzuerhalten.

Verwenden Sie die Clientbibliothek des Inhaltsmoderators für Python:

• Moderater Text
• Verwenden einer benutzerdefinierten Begriffsliste
• Moderate Bilder
• Verwenden einer benutzerdefinierten Bildliste

Reference-Dokumentation | Library Quellcode | Package (PiPy) | Beispiele

Voraussetzungen

• Azure-Abonnement – Create one for free
• Python 3.x
  • Ihre Python-Installation sollte pip enthalten. Sie können überprüfen, ob pip installiert ist, indem Sie pip --version auf der Befehlszeile ausführen. Erhalten Sie pip durch die Installation der neuesten Version von Python.
• Sobald Sie Ihr Azure-Abonnement haben, Erstellen Sie eine Content Moderator-Ressource im Azure-Portal, zur Ermittlung Ihres Schlüssels und Endpunkts. Warten Sie, bis sie bereitgestellt wird, und klicken Sie auf die Schaltfläche "Zur Ressource wechseln ".
  • Sie benötigen den Schlüssel und endpunkt aus der Ressource, die Sie erstellen, um Ihre Anwendung mit dem Inhaltsmoderator zu verbinden. Sie fügen Ihren Schlüssel und Endpunkt später in der Schnellstartanleitung in den folgenden Code ein.
  • Sie können das kostenlose Preisniveau (F0) verwenden, um den Dienst zu testen und später auf eine kostenpflichtige Stufe für die Produktion zu aktualisieren.

Einrichten

Installieren der Clientbibliothek

Nach der Installation von Python können Sie die Clientbibliothek des Inhaltsmoderators mit dem folgenden Befehl installieren:

pip install --upgrade azure-cognitiveservices-vision-contentmoderator

Erstellen einer neuen Python Anwendung

Erstellen Sie ein neues Python Skript, und öffnen Sie es in Ihrem bevorzugten Editor oder ihrer IDE. Fügen Sie dann die folgenden import Anweisungen am Anfang der Datei hinzu.

import os.path
from pprint import pprint
import time
from io import BytesIO
from random import random
import uuid

from azure.cognitiveservices.vision.contentmoderator import ContentModeratorClient
import azure.cognitiveservices.vision.contentmoderator.models
from msrest.authentication import CognitiveServicesCredentials

Erstellen Sie als Nächstes Variablen für den Endpunktstandort und den Schlüssel Ihrer Ressource.

CONTENT_MODERATOR_ENDPOINT = "PASTE_YOUR_CONTENT_MODERATOR_ENDPOINT_HERE"
subscription_key = "PASTE_YOUR_CONTENT_MODERATOR_SUBSCRIPTION_KEY_HERE"

Objektmodell

Die folgenden Klassen behandeln einige der wichtigsten Features der Content Moderator Python-Clientbibliothek.

Codebeispiele

Diese Codeausschnitte zeigen Ihnen, wie Sie die folgenden Aufgaben mit der Inhaltsmoderator-Clientbibliothek für Python ausführen:

• Authentifizieren des Clients
• Moderater Text
• Verwenden einer benutzerdefinierten Begriffsliste
• Moderate Bilder
• Verwenden einer benutzerdefinierten Bildliste

Authentifizieren des Clients

Instanziieren Sie einen Client mit Ihrem Endpunkt und Ihrem Schlüssel. Erstellen Sie ein CognitiveServicesCredentials](/python/api/msrest/msrest.authentication.cognitiveservicescredentials-Objekt mit Ihrem Schlüssel, und verwenden Sie es mit Ihrem Endpunkt, um ein ContentModeratorClient-Objekt zu erstellen.

client = ContentModeratorClient(
    endpoint=CONTENT_MODERATOR_ENDPOINT,
    credentials=CognitiveServicesCredentials(subscription_key)
)

Moderater Text

Der folgende Code verwendet einen Inhaltsmoderator-Client, um einen Textkörper zu analysieren und die Ergebnisse in der Konsole zu drucken. Erstellen Sie zunächst einen text_files/ Ordner im Stammverzeichnis Ihres Projekts, und fügen Sie eine content_moderator_text_moderation.txt Datei hinzu. Fügen Sie dieser Datei Ihren eigenen Text hinzu, oder verwenden Sie den folgenden Beispieltext:

Is this a grabage email abcdef@abcd.com, phone: 4255550111, IP: 255.255.255.255, 1234 Main Boulevard, Panapolis WA 96555.
<offensive word> is the profanity here. Is this information PII? phone 2065550111

Fügen Sie einen Verweis auf den neuen Ordner hinzu.

TEXT_FOLDER = os.path.join(os.path.dirname(
    os.path.realpath(__file__)), "text_files")

Fügen Sie dann ihrem Python Skript den folgenden Code hinzu.

# Screen the input text: check for profanity,
# do autocorrect text, and check for personally identifying
# information (PII)
with open(os.path.join(TEXT_FOLDER, 'content_moderator_text_moderation.txt'), "rb") as text_fd:
    screen = client.text_moderation.screen_text(
        text_content_type="text/plain",
        text_content=text_fd,
        language="eng",
        autocorrect=True,
        pii=True
    )
    assert isinstance(screen, Screen)
    pprint(screen.as_dict())

Verwenden einer benutzerdefinierten Begriffsliste

Der folgende Code zeigt, wie Sie eine Liste von benutzerdefinierten Ausdrücken für die Textmoderation verwalten. Sie können die ListManagementTermListsOperations-Klasse verwenden, um eine Begriffsliste zu erstellen, die einzelnen Ausdrücke zu verwalten und andere Textkörper damit abzugleichen.

Beispieltext abrufen

Um dieses Beispiel zu verwenden, müssen Sie einen text_files/ Ordner im Stammverzeichnis Ihres Projekts erstellen und eine content_moderator_term_list.txt Datei hinzufügen. Diese Datei sollte organischen Text enthalten, der anhand der Liste der Begriffe überprüft wird. Sie können den folgenden Beispieltext verwenden:

This text contains the terms "term1" and "term2".

Fügen Sie einen Verweis auf den Ordner hinzu, wenn Sie noch keinen definiert haben.

TEXT_FOLDER = os.path.join(os.path.dirname(
    os.path.realpath(__file__)), "text_files")

Erstellen einer Liste

Fügen Sie Ihrem Python Skript den folgenden Code hinzu, um eine benutzerdefinierte Begriffsliste zu erstellen und den ID-Wert zu speichern.

#
# Create list
#
print("\nCreating list")
custom_list = client.list_management_term_lists.create(
    content_type="application/json",
    body={
        "name": "Term list name",
        "description": "Term list description",
    }
)
print("List created:")
assert isinstance(custom_list, TermList)
pprint(custom_list.as_dict())
list_id = custom_list.id

Definieren von Listendetails

Sie können die ID einer Liste verwenden, um den Namen und die Beschreibung zu bearbeiten.

#
# Update list details
#
print("\nUpdating details for list {}".format(list_id))
updated_list = client.list_management_term_lists.update(
    list_id=list_id,
    content_type="application/json",
    body={
        "name": "New name",
        "description": "New description"
    }
)
assert isinstance(updated_list, TermList)
pprint(updated_list.as_dict())

Einen Begriff zur Liste hinzufügen

Der folgende Code fügt die Begriffe "term1" und "term2" der Liste hinzu.

#
# Add terms
#
print("\nAdding terms to list {}".format(list_id))
client.list_management_term.add_term(
    list_id=list_id,
    term="term1",
    language="eng"
)
client.list_management_term.add_term(
    list_id=list_id,
    term="term2",
    language="eng"
)

Abrufen aller Begriffe in der Liste

Sie können die Listen-ID verwenden, um alle Begriffe in der Liste zurückzugeben.

#
# Get all terms ids
#
print("\nGetting all term IDs for list {}".format(list_id))
terms = client.list_management_term.get_all_terms(
    list_id=list_id, language="eng")
assert isinstance(terms, Terms)
terms_data = terms.data
assert isinstance(terms_data, TermsData)
pprint(terms_data.as_dict())

Aktualisieren des Listenindexes

Wenn Sie Ausdrücke aus der Liste hinzufügen oder entfernen, müssen Sie den Index aktualisieren, bevor Sie die aktualisierte Liste verwenden können.

#
# Refresh the index
#
print("\nRefreshing the search index for list {}".format(list_id))
refresh_index = client.list_management_term_lists.refresh_index_method(
    list_id=list_id, language="eng")
assert isinstance(refresh_index, RefreshIndex)
pprint(refresh_index.as_dict())

print("\nWaiting {} minutes to allow the server time to propagate the index changes.".format(
    LATENCY_DELAY))
time.sleep(LATENCY_DELAY * 60)

Bildschirmtext mit der Liste abgleichen

Die Hauptfunktionalität der Liste der benutzerdefinierten Ausdrücke besteht darin, einen Textkörper mit der Liste zu vergleichen und zu ermitteln, ob übereinstimmende Ausdrücke vorhanden sind.

#
# Screen text
#
with open(os.path.join(TEXT_FOLDER, 'content_moderator_term_list.txt'), "rb") as text_fd:
    screen = client.text_moderation.screen_text(
        text_content_type="text/plain",
        text_content=text_fd,
        language="eng",
        autocorrect=False,
        pii=False,
        list_id=list_id
    )
    assert isinstance(screen, Screen)
    pprint(screen.as_dict())

Entfernen eines Begriffs aus einer Liste

Mit dem folgenden Code wird der Ausdruck "term1" aus der Liste entfernt.

#
# Remove terms
#
term_to_remove = "term1"
print("\nRemove term {} from list {}".format(term_to_remove, list_id))
client.list_management_term.delete_term(
    list_id=list_id,
    term=term_to_remove,
    language="eng"
)

Entfernen aller Ausdrücke aus einer Liste

Verwenden Sie den folgenden Code, um alle Begriffe aus einer Liste zu entfernen.

#
# Delete all terms
#
print("\nDelete all terms in the image list {}".format(list_id))
client.list_management_term.delete_all_terms(
    list_id=list_id, language="eng")

Löschen einer Liste

Verwenden Sie den folgenden Code, um eine benutzerdefinierte Begriffsliste zu löschen.

#
# Delete list
#
print("\nDelete the term list {}".format(list_id))
client.list_management_term_lists.delete(list_id=list_id)

Moderate Bilder

Der folgende Code verwendet einen Inhaltsmoderator-Client zusammen mit einem ImageModerationOperations-Objekt, um Bilder auf Erwachseneninhalte und anstößige Inhalte zu analysieren.

Beispielbilder abrufen

Definieren Sie einen Verweis auf einige zu analysierende Bilder.

IMAGE_LIST = [
    "https://moderatorsampleimages.blob.core.windows.net/samples/sample2.jpg",
    "https://moderatorsampleimages.blob.core.windows.net/samples/sample5.png"
]

Fügen Sie dann den folgenden Code hinzu, um über Ihre Bilder zu iterieren. Der Rest des Codes in diesem Abschnitt wird in diese Schleife eingefügt.

for image_url in IMAGE_LIST:
    print("\nEvaluate image {}".format(image_url))

Überprüfen auf erwachsene/anstößige Inhalte

Der folgende Code überprüft das Bild unter der angegebenen URL auf erwachsene oder rassige Inhalte und druckt Ergebnisse in der Konsole. Im Leitfaden für Bildmoderationskonzepte finden Sie Informationen dazu, was diese Begriffe bedeuten.

print("\nEvaluate for adult and racy content.")
evaluation = client.image_moderation.evaluate_url_input(
    content_type="application/json",
    cache_image=True,
    data_representation="URL",
    value=image_url
)
assert isinstance(evaluation, Evaluate)
pprint(evaluation.as_dict())

Auf sichtbaren Text prüfen

Der folgende Code überprüft das Bild auf sichtbaren Textinhalt und druckt Ergebnisse in der Konsole.

print("\nDetect and extract text.")
evaluation = client.image_moderation.ocr_url_input(
    language="eng",
    content_type="application/json",
    data_representation="URL",
    value=image_url,
    cache_image=True,
)
assert isinstance(evaluation, OCR)
pprint(evaluation.as_dict())

Nach Gesichtern suchen

Der folgende Code überprüft das Bild auf menschliche Gesichter und druckt Ergebnisse in der Konsole.

print("\nDetect faces.")
evaluation = client.image_moderation.find_faces_url_input(
    content_type="application/json",
    cache_image=True,
    data_representation="URL",
    value=image_url
)
assert isinstance(evaluation, FoundFaces)
pprint(evaluation.as_dict())

Verwenden einer benutzerdefinierten Bildliste

Der folgende Code zeigt, wie Sie eine benutzerdefinierte Liste von Bildern für die Bildmoderation verwalten. Dieses Feature ist nützlich, wenn Ihre Plattform häufig Instanzen derselben Gruppe von Bildern empfängt, die Sie herausstellen möchten. Durch die Aufrechterhaltung einer Liste dieser spezifischen Bilder können Sie die Leistung verbessern. Mit der ListManagementImageListsOperations-Klasse können Sie eine Bildliste erstellen, die einzelnen Bilder in der Liste verwalten und andere Bilder damit vergleichen.

Erstellen Sie die folgenden Textvariablen, um die Bild-URLs zu speichern, die Sie in diesem Szenario verwenden.

IMAGE_LIST = {
    "Sports": [
        "https://moderatorsampleimages.blob.core.windows.net/samples/sample4.png",
        "https://moderatorsampleimages.blob.core.windows.net/samples/sample6.png",
        "https://moderatorsampleimages.blob.core.windows.net/samples/sample9.png"
    ],
    "Swimsuit": [
        "https://moderatorsampleimages.blob.core.windows.net/samples/sample1.jpg",
        "https://moderatorsampleimages.blob.core.windows.net/samples/sample3.png",
        "https://moderatorsampleimages.blob.core.windows.net/samples/sample4.png",
        "https://moderatorsampleimages.blob.core.windows.net/samples/sample16.png"
    ]
}

IMAGES_TO_MATCH = [
    "https://moderatorsampleimages.blob.core.windows.net/samples/sample1.jpg",
    "https://moderatorsampleimages.blob.core.windows.net/samples/sample4.png",
    "https://moderatorsampleimages.blob.core.windows.net/samples/sample5.png",
    "https://moderatorsampleimages.blob.core.windows.net/samples/sample16.png"
]

Erstellen einer Bildliste

Fügen Sie den folgenden Code hinzu, um eine Bildliste zu erstellen und einen Verweis auf die ID zu speichern.

#
# Create list
#
print("Creating list MyList\n")
custom_list = client.list_management_image_lists.create(
    content_type="application/json",
    body={
        "name": "MyList",
        "description": "A sample list",
        "metadata": {
            "key_one": "Acceptable",
            "key_two": "Potentially racy"
        }
    }
)
print("List created:")
assert isinstance(custom_list, ImageList)
pprint(custom_list.as_dict())
list_id = custom_list.id

Hinzufügen von Bildern zu einer Liste

Mit dem folgenden Code werden alle Bilder der Liste hinzugefügt.

print("\nAdding images to list {}".format(list_id))
index = {}  # Keep an index url to id for later removal
for label, urls in IMAGE_LIST.items():
    for url in urls:
        image = add_images(list_id, url, label)
        if image:
            index[url] = image.content_id

Definieren Sie die add_images Hilfsfunktion an anderer Stelle in Ihrem Skript.

#
# Add images
#
def add_images(list_id, image_url, label):
    """Generic add_images from url and label."""
    print("\nAdding image {} to list {} with label {}.".format(
        image_url, list_id, label))
    try:
        added_image = client.list_management_image.add_image_url_input(
            list_id=list_id,
            content_type="application/json",
            data_representation="URL",
            value=image_url,
            label=label
        )
    except APIErrorException as err:
        # sample4 will fail
        print("Unable to add image to list: {}".format(err))
    else:
        assert isinstance(added_image, Image)
        pprint(added_image.as_dict())
        return added_image

Bilder in einer Liste abrufen

Der folgende Code druckt die Namen aller Bilder in Ihrer Liste.

#
# Get all images ids
#
print("\nGetting all image IDs for list {}".format(list_id))
image_ids = client.list_management_image.get_all_image_ids(list_id=list_id)
assert isinstance(image_ids, ImageIds)
pprint(image_ids.as_dict())

Aktualisieren von Listendetails

Sie können die Listen-ID verwenden, um den Namen und die Beschreibung der Liste zu aktualisieren.

#
# Update list details
#
print("\nUpdating details for list {}".format(list_id))
updated_list = client.list_management_image_lists.update(
    list_id=list_id,
    content_type="application/json",
    body={
        "name": "Swimsuits and sports"
    }
)
assert isinstance(updated_list, ImageList)
pprint(updated_list.as_dict())

Listendetails abrufen

Verwenden Sie den folgenden Code, um die aktuellen Details Ihrer Liste zu drucken.

#
# Get list details
#
print("\nGetting details for list {}".format(list_id))
list_details = client.list_management_image_lists.get_details(
    list_id=list_id)
assert isinstance(list_details, ImageList)
pprint(list_details.as_dict())

Aktualisieren des Listenindexes

Nachdem Sie Bilder hinzugefügt oder entfernt haben, müssen Sie den Listenindex aktualisieren, bevor Sie ihn zum Anzeigen anderer Bilder verwenden können.

#
# Refresh the index
#
print("\nRefreshing the search index for list {}".format(list_id))
refresh_index = client.list_management_image_lists.refresh_index_method(
    list_id=list_id)
assert isinstance(refresh_index, RefreshIndex)
pprint(refresh_index.as_dict())

print("\nWaiting {} minutes to allow the server time to propagate the index changes.".format(
    LATENCY_DELAY))
time.sleep(LATENCY_DELAY * 60)

Abgleichen von Bildern mit der Liste

Die Hauptfunktion von Bildlisten besteht darin, neue Bilder zu vergleichen und festzustellen, ob Übereinstimmungen vorhanden sind.

#
# Match images against the image list.
#
for image_url in IMAGES_TO_MATCH:
    print("\nMatching image {} against list {}".format(image_url, list_id))
    match_result = client.image_moderation.match_url_input(
        content_type="application/json",
        list_id=list_id,
        data_representation="URL",
        value=image_url,
    )
    assert isinstance(match_result, MatchResponse)
    print("Is match? {}".format(match_result.is_match))
    print("Complete match details:")
    pprint(match_result.as_dict())

Entfernen eines Bilds aus der Liste

Mit dem folgenden Code wird ein Element aus der Liste entfernt. In diesem Fall handelt es sich um ein Bild, das nicht mit der Listenkategorie übereinstimmt.

#
# Remove images
#
correction = "https://moderatorsampleimages.blob.core.windows.net/samples/sample16.png"
print("\nRemove image {} from list {}".format(correction, list_id))
client.list_management_image.delete_image(
    list_id=list_id,
    image_id=index[correction]
)

Entfernen aller Bilder aus einer Liste

Verwenden Sie den folgenden Code, um eine Bildliste zu löschen.

#
# Delete all images
#
print("\nDelete all images in the image list {}".format(list_id))
client.list_management_image.delete_all_images(list_id=list_id)

Löschen der Bildliste

Verwenden Sie den folgenden Code, um eine bestimmte Bildliste zu löschen.

#
# Delete list
#
print("\nDelete the image list {}".format(list_id))
client.list_management_image_lists.delete(list_id=list_id)

Ausführen der Anwendung

Führen Sie die Anwendung mit dem python Befehl in der Schnellstartdatei aus.

python quickstart-file.py

Bereinigen von Ressourcen

Wenn Sie ein Azure KI Services-Abonnement bereinigen und entfernen möchten, können Sie die Ressource oder Ressourcengruppe löschen. Durch das Löschen der Ressourcengruppe werden auch alle anderen ressourcen gelöscht, die ihr zugeordnet sind.

• Azure Portal
• Azure CLI

Nächste Schritte

In dieser Schnellstartanleitung haben Sie erfahren, wie Sie den Inhaltsmoderator Python Bibliothek verwenden, um Moderationsaufgaben auszuführen. Erfahren Sie als Nächstes mehr über die Moderation von Bildern oder anderen Medien, indem Sie einen konzeptionellen Leitfaden lesen.

Erfahren Sie mehr über die REST-API Azure Content Moderator.

Der Inhaltsmoderator ist ein KI-Dienst, mit dem Sie Inhalte behandeln können, die potenziell anstößig, riskant oder anderweitig unerwünscht sind. Verwenden Sie den KI-basierten Inhaltsmoderationsdienst, um Text, Bild und Videos zu scannen und Inhaltskennzeichnungen automatisch anzuwenden. Erstellen Sie Inhaltsfiltersoftware in Ihre App, um Vorschriften einzuhalten oder die beabsichtigte Umgebung für Ihre Benutzer aufrechtzuerhalten.

Verwenden Sie die REST-API des Inhaltsmoderators für Folgendes:

• Moderater Text
• Moderate Bilder

Voraussetzungen

• Azure-Abonnement – Create one for free
• Sobald Sie Ihr Azure-Abonnement haben, eine Content Moderator-Ressource erstellen im Azure-Portal, um Ihren Schlüssel und Endpunkt zu erhalten. Warten Sie, bis sie bereitgestellt wird, und klicken Sie auf die Schaltfläche "Zur Ressource wechseln ".
  • Sie benötigen den Schlüssel und endpunkt aus der Ressource, die Sie erstellen, um Ihre Anwendung mit dem Inhaltsmoderator zu verbinden. Sie fügen Ihren Schlüssel und Endpunkt später in der Schnellstartanleitung in den folgenden Code ein.
  • Sie können das kostenlose Preisniveau (F0) verwenden, um den Dienst zu testen und später auf eine kostenpflichtige Stufe für die Produktion zu aktualisieren.
• PowerShell, Version 6.0+, oder eine ähnliche Befehlszeilenanwendung.

Moderater Text

Sie verwenden einen Befehl wie den folgenden, um die Inhaltsmoderator-API aufzurufen, um einen Textkörper zu analysieren und die Ergebnisse in der Konsole zu drucken.

curl -v -X POST "https://westus.api.cognitive.microsoft.com/contentmoderator/moderate/v1.0/ProcessText/Screen?autocorrect=True&PII=True&classify=True&language={string}"
-H "Content-Type: text/plain"
-H "Ocp-Apim-Subscription-Key: {subscription key}"
--data-ascii "Is this a crap email abcdef@abcd.com, phone: 6657789887, IP: 255.255.255.255, 1 Microsoft Way, Redmond, WA 98052"

Kopieren Sie den Befehl in einen Text-Editor, und nehmen Sie die folgenden Änderungen vor:

1. Weisen Sie Ocp-Apim-Subscription-Key Ihrem gültigen Abonnementschlüssel für die Gesichtserkennung zu.

   Wichtig

   Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und veröffentlichen Sie ihn nie öffentlich. Verwenden Sie für die Produktion eine sichere Möglichkeit zum Speichern und Zugreifen auf Ihre Anmeldeinformationen wie Azure Key Vault. Weitere Informationen finden Sie im Artikel Azure KI Services security.

2. Ändern Sie den ersten Teil der Abfrage-URL so, dass er mit dem Endpunkt übereinstimmt, der Ihrem Abonnementschlüssel entspricht.

   Hinweis

   Neue Ressourcen, die nach dem 1. Juli 2019 erstellt wurden, verwenden benutzerdefinierte Unterdomänennamen. Weitere Informationen und eine vollständige Liste der regionalen Endpunkte finden Sie unter benutzerdefinierte Unterdomänennamen für Foundry Tools.

3. Ändern Sie optional den Textkörper der Anforderung in eine beliebige Textzeichenfolge, die Sie analysieren möchten.

Nachdem Sie Ihre Änderungen vorgenommen haben, öffnen Sie eine Eingabeaufforderung, und geben Sie den neuen Befehl ein.

Untersuchen der Ergebnisse

Die Ergebnisse der Textmoderation sollten als JSON-Daten im Konsolenfenster angezeigt werden. Zum Beispiel:

{
  "OriginalText": "Is this a <offensive word> email abcdef@abcd.com, phone: 6657789887, IP: 255.255.255.255,\n1 Microsoft Way, Redmond, WA 98052\n",
  "NormalizedText": "Is this a <offensive word> email abide@ abed. com, phone: 6657789887, IP: 255. 255. 255. 255, \n1 Microsoft Way, Redmond, WA 98052",
  "AutoCorrectedText": "Is this a <offensive word> email abide@ abed. com, phone: 6657789887, IP: 255. 255. 255. 255, \n1 Microsoft Way, Redmond, WA 98052",
  "Misrepresentation": null,
  "PII": {
    "Email": [
      {
        "Detected": "abcdef@abcd.com",
        "SubType": "Regular",
        "Text": "abcdef@abcd.com",
        "Index": 21
      }
    ],
    "IPA": [
      {
        "SubType": "IPV4",
        "Text": "255.255.255.255",
        "Index": 61
      }
    ],
    "Phone": [
      {
        "CountryCode": "US",
        "Text": "6657789887",
        "Index": 45
      }
    ],
    "Address": [
      {
        "Text": "1 Microsoft Way, Redmond, WA 98052",
        "Index": 78
      }
    ]
  },
 "Classification": {
    "Category1": 
    {
      "Score": 0.5
    },
    "Category2": 
    {
      "Score": 0.6
    },
    "Category3": 
    {
      "Score": 0.5
    },
    "ReviewRecommended": true
  },
  "Language": "eng",
  "Terms": [
    {
      "Index": 10,
      "OriginalIndex": 10,
      "ListId": 0,
      "Term": "<offensive word>"
    }
  ],
  "Status": {
    "Code": 3000,
    "Description": "OK",
    "Exception": null
  },
  "TrackingId": "1717c837-cfb5-4fc0-9adc-24859bfd7fac"
}

Weitere Informationen zu den Textattributen, die der Inhaltsmoderator überprüft, finden Sie im Leitfaden zur Textmoderation .

Moderate Bilder

Sie verwenden einen Befehl wie den folgenden, um die Inhaltsmoderator-API aufzurufen, um ein Remoteimage zu moderieren und die Ergebnisse in der Konsole zu drucken.

curl -v -X POST "https://westus.api.cognitive.microsoft.com/contentmoderator/moderate/v1.0/ProcessImage/Evaluate?CacheImage={boolean}" 
-H "Content-Type: application/json"
-H "Ocp-Apim-Subscription-Key: {subscription key}" 
--data-ascii "{\"DataRepresentation\":\"URL\", \"Value\":\"https://moderatorsampleimages.blob.core.windows.net/samples/sample.jpg\"}"

Kopieren Sie den Befehl in einen Text-Editor, und nehmen Sie die folgenden Änderungen vor:

1. Weisen Sie Ocp-Apim-Subscription-Key Ihrem gültigen Abonnementschlüssel für die Gesichtserkennung zu.
2. Ändern Sie den ersten Teil der Abfrage-URL so, dass er mit dem Endpunkt übereinstimmt, der Ihrem Abonnementschlüssel entspricht.
3. Ändern Sie optional die URL "Value" im Anforderungstext in das gewünschte Remotebild für die Moderation.

Nachdem Sie Ihre Änderungen vorgenommen haben, öffnen Sie eine Eingabeaufforderung, und geben Sie den neuen Befehl ein.

Untersuchen der Ergebnisse

Die Ergebnisse der Bildmoderation sollten als JSON-Daten im Konsolenfenster angezeigt werden.

{
  "AdultClassificationScore": x.xxx,
  "IsImageAdultClassified": <Bool>,
  "RacyClassificationScore": x.xxx,
  "IsImageRacyClassified": <Bool>,
  "AdvancedInfo": [],
  "Result": false,
  "Status": {
    "Code": 3000,
    "Description": "OK",
    "Exception": null
  },
  "TrackingId": "<Request Tracking Id>"
}

Weitere Informationen zu den Bildattributen, die der Inhaltsmoderator überprüft, finden Sie im Leitfaden für Bildmoderationskonzepte .

Bereinigen von Ressourcen

Wenn Sie ein Azure KI Services-Abonnement bereinigen und entfernen möchten, können Sie die Ressource oder Ressourcengruppe löschen. Durch das Löschen der Ressourcengruppe werden auch alle anderen ressourcen gelöscht, die ihr zugeordnet sind.

• Azure Portal
• Azure CLI

Nächste Schritte

In dieser Schnellstartanleitung haben Sie erfahren, wie Sie die REST-API für Inhaltsmoderator verwenden, um Moderationsaufgaben auszuführen. Erfahren Sie als Nächstes mehr über die Moderation von Bildern oder anderen Medien, indem Sie einen konzeptionellen Leitfaden lesen.

• Konzepte der Bildmoderation
• Konzepte der Textmoderation