Schnellstart: Analysieren von Bildinhalten

Voraussetzungen

• Ein Azure Konto. Wenn Sie noch keine haben, können Sie eine kostenlos erstellen.
• Eine Azure AI-Ressource.

Konfiguration

Führen Sie die folgenden Schritte aus, um die Seite Ausprobieren der Inhaltssicherheit zu verwenden:

1. Wechseln Sie zu Azure AI Foundry und navigieren Sie zu Ihrem Projekt/Hub. Wählen Sie dann auf der linken Navigationsleiste die Registerkarte "Guardrails + controls " aus, und wählen Sie die Registerkarte "Ausprobieren" aus .
2. Auf der Seite "Ausprobieren " können Sie mit verschiedenen Guardrails & Controls-Features wie Text- und Bildinhalten experimentieren, indem Sie anpassbare Schwellenwerte verwenden, um nach unangemessenen oder schädlichen Inhalten zu filtern.

Screenshot der „Ausprobieren“-Seite für Guardrails & Kontrollen.

Analysieren von Bildern

Die Seite Bild moderieren bietet Ihnen die Funktionalität, die Bildmoderation schnell auszuprobieren.

1. Wählen Sie den Bereich Bildinhalt moderieren aus.
2. Wählen Sie über die Bereiche auf der Seite ein Beispielbild aus, oder laden Sie ein eigenes Bild hoch.
3. Wählen Sie "Test ausführen" aus. Der Dienst gibt alle erkannten Kategorien zusammen mit ihrem Schweregrad zurück: 0 (sicher), 2 (niedrig), 4 (mittel) und 6 (hoch). Außerdem wird basierend auf den von Ihnen konfigurierten Filtern ein binäres Ergebnis (Akzeptiert /Abgelehnt) zurückgegeben. Verwenden Sie die Matrix auf der Registerkarte Filter konfigurieren auf der rechten Seite, um die zulässigen bzw. nicht zulässigen Schweregrade für die einzelnen Kategorien festzulegen. Anschließend können Sie die Textanalyse erneut ausführen, um zu sehen, wie der Filter funktioniert.

Anzeigen und Exportieren von Code

Das Feature Code anzeigen steht entweder auf der Seite Textinhalt analysieren oder auf der Seite Bildinhalt analysieren zur Verfügung und kann verwendet werden, um den Beispielcode anzuzeigen und zu kopieren. Dieser umfasst die Konfiguration für die Schweregradfilterung sowie Sperrlisten und Moderationsfunktionen. Anschließend können Sie den Code auf Ihrer Seite deployen.

Voraussetzungen

• Ein Azure-Abonnement – Create one for free
• Sobald Sie Ihr Azure-Abonnement haben, erstellen Sie eine Content Safety-Ressource im Azure-Portal, um Ihren Schlüssel und Endpunkt zu erhalten. Geben Sie einen eindeutigen Namen für Ihre Ressource ein, wählen Sie Ihr Abonnement aus, und wählen Sie dann eine Ressourcengruppe, eine unterstützte Region (weitere Informationen unter Regionale Verfügbarkeit) und einen unterstützten Tarif aus. Wählen Sie dann Erstellen aus.
  • Die Bereitstellung der Ressource dauert einige Minuten. Wählen Sie im Anschluss Zu Ressource wechseln aus. Wählen Sie im linken Bereich unter Ressourcenverwaltung die Option Abonnementschlüssel und Endpunkt aus. Der Endpunkt und einer der Schlüssel werden verwendet, um APIs aufzurufen.
• cURL installiert

Analysieren von Bildinhalten

Der folgende Abschnitt führt Sie durch eine Beispielanforderung für die Bildmoderation mit cURL.

Vorbereiten eines Beispielbilds

Wählen Sie ein zu analysierendes Beispielbild aus, und laden Sie es auf Ihr Gerät herunter.

Siehe Eingabeanforderungen für die Bildbeschränkungen. Wenn Ihr Format animiert ist, extrahiert der Dienst den ersten Frame, um die Analyse vorzunehmen.

Sie können Ihr Bild mit einer von zwei Methoden eingeben: lokaler Filestream oder Blob Storage-URL.

• Lokaler Filestream (empfohlen): Codieren Sie Ihr Image mit Base64. Zur Codierung eignet sich eine Website wie codebeautify. Speichern Sie dann die codierte Zeichenfolge an einem temporären Speicherort.

• Blob-Speicher-URL: Laden Sie Ihr Bild in ein Azure Blob Storage Konto hoch. Befolgen Sie den Schnellstart für Blob Storage, um zu erfahren, was zu tun ist. Öffnen Sie dann Azure Storage Explorer, und rufen Sie die URL zu Ihrem Bild ab. Speichern Sie sie an einem temporären Speicherort.

  Als Nächstes müssen Sie Ihrer Content Safety-Ressource Zugriff gewähren, um Daten aus der Azure Storage-Ressource lesen zu können. Aktivieren Sie die vom System zugewiesene verwaltete Identität für die Azure AI Content Safety Instanz, und weisen Sie der Identität die Rolle Storage Blob Data Contributor/Owner zu:

  Wichtig

  Nur Speicherblobdaten-Beitragender oder Speicherblobdaten-Besitzer sind gültige Rollen, um weiterzumachen.

  1. Aktivieren Sie die verwaltete Identität für die Azure AI Content Safety Instanz.

     

  2. Weisen Sie der verwalteten Identität die Rolle Mitwirkender an/Besitzer von Storage-Blobdaten zu. Alle nachstehend hervorgehobenen Rollen sollten funktionieren.

     

     

     

Analysieren von Bildinhalten

Fügen Sie den nachstehenden Befehl in einen Text-Editor ein, und nehmen Sie folgende Änderungen vor.

1. Ersetzen Sie `<endpoint>` durch die URL Ihres Ressourcenendpunkts.
2. Ersetzen Sie <your_subscription_key> durch Ihren Schlüssel.
3. Füllen Sie das Feld "image" im Textkörper entweder mit dem Feld des Typs "content" oder "blobUrl" auf. Beispiel: {"image": {"content": "<base_64_string>"} oder {"image": {"blobUrl": "<your_storage_url>"}.

curl --location --request POST '<endpoint>/contentsafety/image:analyze?api-version=2024-09-01' \
--header 'Ocp-Apim-Subscription-Key: <your_subscription_key>' \
--header 'Content-Type: application/json' \
--data-raw '{
  "image": {
    "content": "<base_64_string>"
  },
  "categories": ["Hate", "SelfHarm", "Sexual", "Violence"],
  "outputType": "FourSeverityLevels"
}'

{
  "image": {
    "blobUrl": "<your_storage_url>"
  }
}

Folgende Felder müssen in der URL enthalten sein:

Die Parameter im Anforderungstext sind in der folgenden Tabelle definiert:

Öffnen Sie ein Eingabeaufforderungsfenster, und führen Sie den cURL-Befehl aus.

Output

Die Ergebnisse der Bildmoderation sollten als JSON-Daten in der Konsole angezeigt werden. Beispiel:

{
  "categoriesAnalysis": [
    {
      "category": "Hate",
      "severity": 2
    },
    {
      "category": "SelfHarm",
      "severity": 0
    },
    {
      "category": "Sexual",
      "severity": 0
    },
    {
      "category": "Violence",
      "severity": 0
    }
  ]
}

Die JSON-Felder in der Ausgabe werden hier definiert:

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

Voraussetzungen

• Ein Azure-Abonnement – Create one for free
• Die Visual Studio IDE mit aktivierter Workload für die .NET-Desktopentwicklung. Oder wenn Sie nicht Visual Studio IDE verwenden möchten, benötigen Sie die aktuelle Version von .NET Core.
• .NET Runtime installiert.
• Sobald Sie Ihr Azure-Abonnement haben, erstellen Sie eine Content Safety-Ressource im Azure-Portal, um Ihren Schlüssel und Endpunkt zu erhalten. Geben Sie einen eindeutigen Namen für Ihre Ressource ein, wählen Sie Ihr Abonnement aus, und wählen Sie dann eine Ressourcengruppe, eine unterstützte Region (weitere Informationen unter Regionale Verfügbarkeit) und einen unterstützten Tarif aus. Wählen Sie dann Erstellen aus.
  • Die Bereitstellung der Ressource dauert einige Minuten. Wählen Sie im Anschluss Zu Ressource wechseln aus. Wählen Sie im linken Bereich unter Ressourcenverwaltung die Option Abonnementschlüssel und Endpunkt aus. Der Endpunkt und einer der Schlüssel werden verwendet, um APIs aufzurufen.

Anwendung einrichten

Erstellen einer neuen C#-Anwendung

dotnet new console -n content-safety-quickstart

dotnet build

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

dotnet add package Azure.AI.ContentSafety

Erstellen von Umgebungsvariablen

In diesem Beispiel schreiben Sie Ihre Anmeldeinformationen in Umgebungsvariablen auf dem lokalen Computer, auf dem die Anwendung ausgeführt wird.

Um die Umgebungsvariable für Ihren Schlüssel und den Endpunkt festzulegen, öffnen Sie ein Konsolenfenster und folgen Sie den Anweisungen für Ihr Betriebssystem und Ihre Entwicklungsumgebung.

• Zum Festlegen der Umgebungsvariablen CONTENT_SAFETY_KEY ersetzen Sie YOUR_CONTENT_SAFETY_KEY durch einen der Schlüssel für Ihre Ressource.
• Zum Festlegen der Umgebungsvariablen CONTENT_SAFETY_ENDPOINT ersetzen Sie YOUR_CONTENT_SAFETY_ENDPOINT durch den Endpunkt für Ihre Ressource.

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Analysieren von Bildinhalten

Öffnen Sie im Projektverzeichnis die Datei Program.cs, die zuvor erstellt wurde. Fügen Sie den folgenden Code ein.

using System;
using Azure.AI.ContentSafety;

namespace Azure.AI.ContentSafety.Dotnet.Sample
{
  class ContentSafetySampleAnalyzeImage
  {
    public static void AnalyzeImage()
    {
      // retrieve the endpoint and key from the environment variables created earlier
      string endpoint = Environment.GetEnvironmentVariable("CONTENT_SAFETY_ENDPOINT");
      string key = Environment.GetEnvironmentVariable("CONTENT_SAFETY_KEY");

      ContentSafetyClient client = new ContentSafetyClient(new Uri(endpoint), new AzureKeyCredential(key));

      // Example: analyze image

      string imagePath = @"sample_data\image.png";
      ContentSafetyImageData image = new ContentSafetyImageData(BinaryData.FromBytes(File.ReadAllBytes(imagePath)));

      var request = new AnalyzeImageOptions(image);

      Response<AnalyzeImageResult> response;
      try
      {
          response = client.AnalyzeImage(request);
      }
      catch (RequestFailedException ex)
      {
          Console.WriteLine("Analyze image failed.\nStatus code: {0}, Error code: {1}, Error message: {2}", ex.Status, ex.ErrorCode, ex.Message);
          throw;
      }

      Console.WriteLine("Hate severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == ImageCategory.Hate)?.Severity ?? 0);
      Console.WriteLine("SelfHarm severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == ImageCategory.SelfHarm)?.Severity ?? 0);
      Console.WriteLine("Sexual severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == ImageCategory.Sexual)?.Severity ?? 0);
      Console.WriteLine("Violence severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == ImageCategory.Violence)?.Severity ?? 0);
    }
    static void Main()
    {
      AnalyzeImage();
    }
  }
}

Erstellen Sie einen sample_data-Ordner in Ihrem Projektverzeichnis, und fügen Sie ihm eine image.png-Datei hinzu.

dotnet build
dotnet run

Referenzdokumentation | Bibliotheksquellcode | Package (PyPI) | Beispiele |

Voraussetzungen

• Ein Azure-Abonnement – Create one for free
• Sobald Sie Ihr Azure-Abonnement haben, erstellen Sie eine Content Safety-Ressource im Azure-Portal, um Ihren Schlüssel und Endpunkt zu erhalten. Geben Sie einen eindeutigen Namen für Ihre Ressource ein, wählen Sie Ihr Abonnement aus, und wählen Sie dann eine Ressourcengruppe, eine unterstützte Region (weitere Informationen unter Regionale Verfügbarkeit) und einen unterstützten Tarif aus. Wählen Sie dann Erstellen aus.
  • Die Bereitstellung der Ressource dauert einige Minuten. Wählen Sie im Anschluss Zu Ressource wechseln aus. Wählen Sie im linken Bereich unter Ressourcenverwaltung die Option Abonnementschlüssel und Endpunkt aus. Der Endpunkt und einer der Schlüssel werden verwendet, um APIs aufzurufen.
• Python 3,8 oder höher
  • Ihre Python-Installation sollte pip enthalten. Sie können überprüfen, ob pip installiert ist, indem Sie pip --version in der Befehlszeile ausführen. Erhalten Sie pip, indem Sie die neueste Version von Python installieren.

Erstellen von Umgebungsvariablen

In diesem Beispiel schreiben Sie Ihre Anmeldeinformationen in Umgebungsvariablen auf dem lokalen Computer, auf dem die Anwendung ausgeführt wird.

Um die Umgebungsvariable für Ihren Schlüssel und den Endpunkt festzulegen, öffnen Sie ein Konsolenfenster und folgen Sie den Anweisungen für Ihr Betriebssystem und Ihre Entwicklungsumgebung.

• Zum Festlegen der Umgebungsvariablen CONTENT_SAFETY_KEY ersetzen Sie YOUR_CONTENT_SAFETY_KEY durch einen der Schlüssel für Ihre Ressource.
• Zum Festlegen der Umgebungsvariablen CONTENT_SAFETY_ENDPOINT ersetzen Sie YOUR_CONTENT_SAFETY_ENDPOINT durch den Endpunkt für Ihre Ressource.

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Analysieren von Bildinhalten

Im folgenden Abschnitt wird eine Beispielanforderung mit dem Python SDK erläutert.

1. Öffnen Sie eine Eingabeaufforderung, navigieren Sie zu Ihrem Projektordner, und erstellen Sie eine neue Datei mit dem Namen quickstart.py.

2. Führen Sie diesen Befehl aus, um die Azure AI Content Safety Clientbibliothek zu installieren:

   python -m pip install azure-ai-contentsafety
   

3. Kopieren Sie den folgenden Code in quickstart.py:

   import os
   
   from azure.ai.contentsafety import ContentSafetyClient
   from azure.ai.contentsafety.models import AnalyzeImageOptions, ImageData, ImageCategory
   from azure.core.credentials import AzureKeyCredential
   from azure.core.exceptions import HttpResponseError
   
   def analyze_image():
       endpoint = os.environ.get('CONTENT_SAFETY_ENDPOINT')
       key = os.environ.get('CONTENT_SAFETY_KEY')
       image_path = os.path.join("sample_data", "image.jpg")
   
       # Create an Azure AI Content Safety client
       client = ContentSafetyClient(endpoint, AzureKeyCredential(key))
   
   
       # Build request
       with open(image_path, "rb") as file:
           request = AnalyzeImageOptions(image=ImageData(content=file.read()))
   
       # Analyze image
       try:
           response = client.analyze_image(request)
       except HttpResponseError as e:
           print("Analyze image failed.")
           if e.error:
               print(f"Error code: {e.error.code}")
               print(f"Error message: {e.error.message}")
               raise
           print(e)
           raise
   
       hate_result = next(item for item in response.categories_analysis if item.category == ImageCategory.HATE)
       self_harm_result = next(item for item in response.categories_analysis if item.category == ImageCategory.SELF_HARM)
       sexual_result = next(item for item in response.categories_analysis if item.category == ImageCategory.SEXUAL)
       violence_result = next(item for item in response.categories_analysis if item.category == ImageCategory.VIOLENCE)
   
       if hate_result:
           print(f"Hate severity: {hate_result.severity}")
       if self_harm_result:
           print(f"SelfHarm severity: {self_harm_result.severity}")
       if sexual_result:
           print(f"Sexual severity: {sexual_result.severity}")
       if violence_result:
           print(f"Violence severity: {violence_result.severity}")
   
   if __name__ == "__main__":
       analyze_image()
   

4. Ersetzen Sie "sample_data" und "image.jpg" durch den Pfad und Dateinamen der lokalen Datei, die Sie verwenden möchten.

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

   python quickstart.py
   

Reference-Dokumentation | Library Quellcode | Artifact (Maven) | Beispiele

Voraussetzungen

• Ein Azure-Abonnement – Create one for free
• Die aktuelle Version des Java Development Kit (JDK)
• Gradle-Build-Tool oder ein anderer Abhängigkeitsmanager
• Sobald Sie Ihr Azure-Abonnement haben, erstellen Sie eine Content Safety-Ressource im Azure-Portal, um Ihren Schlüssel und Endpunkt zu erhalten. Geben Sie einen eindeutigen Namen für Ihre Ressource ein, wählen Sie Ihr Abonnement aus, und wählen Sie dann eine Ressourcengruppe, eine unterstützte Region (weitere Informationen unter Regionale Verfügbarkeit) und einen unterstützten Tarif aus. Wählen Sie dann Erstellen aus.
  • Die Bereitstellung der Ressource dauert einige Minuten. Wählen Sie im Anschluss Zu Ressource wechseln aus. Wählen Sie im linken Bereich unter Ressourcenverwaltung die Option Abonnementschlüssel und Endpunkt aus. Der Endpunkt und einer der Schlüssel werden verwendet, um APIs aufzurufen.

Anwendung einrichten

Erstellen eines neuen Gradle-Projekts

Erstellen Sie in einem Konsolenfenster (etwa cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und rufen Sie es auf.

mkdir myapp && cd myapp

Führen Sie den Befehl gradle init in 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 zur Auswahl einer DSL aufgefordert werden, wählen Sie Kotlin aus.

Führen Sie in Ihrem Arbeitsverzeichnis den folgenden Befehl aus, um einen Quellordner für das Projekt zu erstellen.

mkdir -p src/main/java

Navigieren Sie zu dem neuen Ordner, und erstellen Sie eine Datei namens ContentSafetyQuickstart.java.

Erstellen Sie außerdem im Stammverzeichnis Ihres Projekts einen Ordner namens src/resources, und fügen Sie ihm ein Beispielbild hinzu.

Installieren Sie das Client-SDK

In dieser Schnellstartanleitung wird der Gradle-Abhängigkeits-Manager verwendet. Die Clientbibliothek und Informationen zu anderen Abhängigkeits-Managern finden Sie im zentralen Maven-Repository.

Navigieren Sie zur Datei build.gradle.kts, und öffnen Sie sie in Ihrer bevorzugten IDE bzw. Ihrem bevorzugten Text-Editor. Kopieren Sie anschließend die folgende Buildkonfiguration. Diese Konfiguration definiert das Projekt als Java Anwendung, deren Einstiegspunkt die Klasse ContentSafetyQuickstart ist. Sie importiert die Azure AI Vision-Bibliothek.

plugins {
    java
    application
}
application { 
    mainClass.set("ContentSafetyQuickstart")
}
repositories {
    mavenCentral()
}
dependencies {
    implementation(group = "com.azure", name = "azure-ai-contentsafety", version = "1.0.0")
}

Erstellen von Umgebungsvariablen

In diesem Beispiel schreiben Sie Ihre Anmeldeinformationen in Umgebungsvariablen auf dem lokalen Computer, auf dem die Anwendung ausgeführt wird.

Um die Umgebungsvariable für Ihren Schlüssel und den Endpunkt festzulegen, öffnen Sie ein Konsolenfenster und folgen Sie den Anweisungen für Ihr Betriebssystem und Ihre Entwicklungsumgebung.

• Zum Festlegen der Umgebungsvariablen CONTENT_SAFETY_KEY ersetzen Sie YOUR_CONTENT_SAFETY_KEY durch einen der Schlüssel für Ihre Ressource.
• Zum Festlegen der Umgebungsvariablen CONTENT_SAFETY_ENDPOINT ersetzen Sie YOUR_CONTENT_SAFETY_ENDPOINT durch den Endpunkt für Ihre Ressource.

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Analysieren von Bildinhalten

Öffnen Sie ContentSafetyQuickstart.java in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE, und fügen Sie den folgenden Code ein. Ersetzen Sie die Variable source durch den Pfad zu Ihrem Beispielbild.

import com.azure.ai.contentsafety.ContentSafetyClient;
import com.azure.ai.contentsafety.ContentSafetyClientBuilder;
import com.azure.ai.contentsafety.models.AnalyzeImageOptions;
import com.azure.ai.contentsafety.models.AnalyzeImageResult;
import com.azure.ai.contentsafety.models.ContentSafetyImageData;
import com.azure.ai.contentsafety.models.ImageCategoriesAnalysis;
import com.azure.core.credential.KeyCredential;
import com.azure.core.util.BinaryData;
import com.azure.core.util.Configuration;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;


public class ContentSafetyQuickstart {
    public static void main(String[] args) throws IOException {

        // get endpoint and key from environment variables
        String endpoint = System.getenv("CONTENT_SAFETY_ENDPOINT");
        String key = System.getenv("CONTENT_SAFETY_KEY");

        ContentSafetyClient contentSafetyClient = new ContentSafetyClientBuilder()
            .credential(new KeyCredential(key))
            .endpoint(endpoint).buildClient();

        ContentSafetyImageData image = new ContentSafetyImageData();
        String cwd = System.getProperty("user.dir");
        String source = "/src/samples/resources/image.png";

        image.setContent(BinaryData.fromBytes(Files.readAllBytes(Paths.get(cwd, source))));

        AnalyzeImageResult response =
                contentSafetyClient.analyzeImage(new AnalyzeImageOptions(image));

        for (ImageCategoriesAnalysis result : response.getCategoriesAnalysis()) {
            System.out.println(result.getCategory() + " severity: " + result.getSeverity());
        }
    }
}

Navigieren Sie zurück zum Projektstammordner, und erstellen Sie die App mit:

gradle build

Führen Sie ihn dann mit dem gradle run-Befehl aus:

gradle run

Output

Hate severity: 0
SelfHarm severity: 0
Sexual severity: 0
Violence severity: 0

Reference-Dokumentation | Bibliotheksquellcode | Package (npm) | Beispiele |

Voraussetzungen

• Ein Azure-Abonnement – Create one for free
• Die aktuelle Version von Node.js
• Sobald Sie Ihr Azure-Abonnement haben, erstellen Sie eine Content Safety-Ressource im Azure-Portal, um Ihren Schlüssel und Endpunkt zu erhalten. Geben Sie einen eindeutigen Namen für Ihre Ressource ein, wählen Sie Ihr Abonnement aus, und wählen Sie dann eine Ressourcengruppe, eine unterstützte Region (weitere Informationen unter Regionale Verfügbarkeit) und einen unterstützten Tarif aus. Wählen Sie dann Erstellen aus.
  • Die Bereitstellung der Ressource dauert einige Minuten. Wählen Sie im Anschluss Zu Ressource wechseln aus. Wählen Sie im linken Bereich unter Ressourcenverwaltung die Option Abonnementschlüssel und Endpunkt aus. Der Endpunkt und einer der Schlüssel werden verwendet, um APIs aufzurufen.

Anwendung einrichten

Erstellen Sie eine neue Node.js-Anwendung. Erstellen Sie in einem Konsolenfenster (etwa cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und rufen Sie es auf.

mkdir myapp && cd myapp

Führen Sie den Befehl npm init aus, um eine Knotenanwendung mit der Datei package.json zu erstellen.

npm init

Erstellen Sie außerdem im Stammverzeichnis Ihres Projekts einen Ordner namens /resources, und fügen Sie ihm ein Beispielbild hinzu.

Installieren Sie das Client-SDK

Installieren Sie das npm-Paket @azure-rest/ai-content-safety:

npm install @azure-rest/ai-content-safety

Installieren Sie außerdem das Modul dotenv, um Umgebungsvariablen zu verwenden:

npm install dotenv

Die Datei package.json Ihrer App wird mit den Abhängigkeiten aktualisiert.

Erstellen von Umgebungsvariablen

In diesem Beispiel schreiben Sie Ihre Anmeldeinformationen in Umgebungsvariablen auf dem lokalen Computer, auf dem die Anwendung ausgeführt wird.

Um die Umgebungsvariable für Ihren Schlüssel und den Endpunkt festzulegen, öffnen Sie ein Konsolenfenster und folgen Sie den Anweisungen für Ihr Betriebssystem und Ihre Entwicklungsumgebung.

• Zum Festlegen der Umgebungsvariablen CONTENT_SAFETY_KEY ersetzen Sie YOUR_CONTENT_SAFETY_KEY durch einen der Schlüssel für Ihre Ressource.
• Zum Festlegen der Umgebungsvariablen CONTENT_SAFETY_ENDPOINT ersetzen Sie YOUR_CONTENT_SAFETY_ENDPOINT durch den Endpunkt für Ihre Ressource.

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Analysieren von Bildinhalten

Erstellen Sie eine neue Datei in Ihrem Verzeichnis: index.js. Öffnen Sie die Datei in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE, und fügen Sie den folgenden Code ein. Ersetzen Sie die Variable image_path durch den Pfad zu Ihrem Beispielbild.

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");
const fs = require("fs");
const path = require("path");

// Load the .env file if it exists
require("dotenv").config();

async function main() {
    // get endpoint and key from environment variables
    const endpoint = process.env["CONTENT_SAFETY_ENDPOINT"];
    const key = process.env["CONTENT_SAFETY_KEY"];
    
    const credential = new AzureKeyCredential(key);
    const client = ContentSafetyClient(endpoint, credential);
    
    // replace with your own sample image file path 
    const image_path = path.resolve(__dirname, "./resources/image.jpg");
    
    const imageBuffer = fs.readFileSync(image_path);
    const base64Image = imageBuffer.toString("base64");
    const analyzeImageOption = { image: { content: base64Image } };
    const analyzeImageParameters = { body: analyzeImageOption };
    
    const result = await client.path("/image:analyze").post(analyzeImageParameters);
    
    if (isUnexpected(result)) {
        throw result;
    }
    for (let i = 0; i < result.body.categoriesAnalysis.length; i++) {
    const imageCategoriesAnalysisOutput = result.body.categoriesAnalysis[i];
    console.log(
      imageCategoriesAnalysisOutput.category,
      " severity: ",
      imageCategoriesAnalysisOutput.severity
    );
  }
}

main().catch((err) => {
    console.error("The sample encountered an error:", err);
});

Führen Sie die Anwendung mit dem Befehl node in Ihrer Schnellstartdatei aus.

node index.js

Output

Hate severity:  0
SelfHarm severity:  0
Sexual severity:  0
Violence severity:  0

Reference-Dokumentation | Bibliotheksquellcode | Package (npm) | Beispiele |

Voraussetzungen

• Ein Azure-Abonnement – Create one for free
• Node.js LTS
• TypeScript
• Visual Studio Code
• Sobald Sie Ihr Azure-Abonnement haben, erstellen Sie eine Content Safety-Ressource im Azure-Portal, um Ihren Schlüssel und Endpunkt zu erhalten. Geben Sie einen eindeutigen Namen für Ihre Ressource ein, wählen Sie Ihr Abonnement aus, und wählen Sie dann eine Ressourcengruppe, eine unterstützte Region (weitere Informationen unter Regionale Verfügbarkeit) und einen unterstützten Tarif aus. Wählen Sie dann Erstellen aus.
  • Die Bereitstellung der Ressource dauert einige Minuten. Wählen Sie im Anschluss Zu Ressource wechseln aus. Wählen Sie im linken Bereich unter Ressourcenverwaltung die Option Abonnementschlüssel und Endpunkt aus. Der Endpunkt und einer der Schlüssel werden verwendet, um APIs aufzurufen.

Einrichten der lokalen Entwicklungsumgebung

1. Erstellen Sie ein neues Verzeichnis für Ihr Projekt, und navigieren Sie zu diesem Verzeichnis:

   mkdir content-safety-image-analysis
   cd content-safety-image-analysis
   code .
   

2. Erstellen Sie ein neues Paket für ESM-Module in Ihrem Projektverzeichnis:

   npm init -y
   npm pkg set type=module
   

3. Installieren Sie die erforderlichen Pakete:

   npm install @azure-rest/ai-content-safety
   

4. Installieren von Entwicklungsabhängigkeiten:

   npm install typescript @types/node --save-dev
   

5. Erstellen Sie eine tsconfig.json Datei in Ihrem Projektverzeichnis:

   {
     "compilerOptions": {
       "target": "es2022",
       "module": "esnext",
       "moduleResolution": "bundler",
       "rootDir": "./src",
       "outDir": "./dist/",
       "esModuleInterop": true,
       "forceConsistentCasingInFileNames": true,
       "strict": true,
       "skipLibCheck": true,
       "declaration": true,
       "sourceMap": true,
       "resolveJsonModule": true,
       "moduleDetection": "force",
       "allowSyntheticDefaultImports": true,
       "verbatimModuleSyntax": false
     },
     "include": [
       "src/**/*.ts"
     ],
     "exclude": [
       "node_modules/**/*",
       "**/*.spec.ts"
     ]
   }
   

6. Aktualisieren package.json , um ein Skript zum Erstellen von TypeScript-Dateien einzuschließen:

   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js"
   }
   

7. Erstellen Sie einen resources Ordner, und fügen Sie ihr ein Beispielbild hinzu.

8. Erstellen Sie ein src Verzeichnis für Ihren TypeScript-Code.

Erstellen von Umgebungsvariablen

In diesem Beispiel schreiben Sie Ihre Anmeldeinformationen in Umgebungsvariablen auf dem lokalen Computer, auf dem die Anwendung ausgeführt wird.

Um die Umgebungsvariable für Ihren Schlüssel und den Endpunkt festzulegen, öffnen Sie ein Konsolenfenster und folgen Sie den Anweisungen für Ihr Betriebssystem und Ihre Entwicklungsumgebung.

• Zum Festlegen der Umgebungsvariablen CONTENT_SAFETY_KEY ersetzen Sie YOUR_CONTENT_SAFETY_KEY durch einen der Schlüssel für Ihre Ressource.
• Zum Festlegen der Umgebungsvariablen CONTENT_SAFETY_ENDPOINT ersetzen Sie YOUR_CONTENT_SAFETY_ENDPOINT durch den Endpunkt für Ihre Ressource.

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Analysieren von Bildinhalten

Erstellen Sie eine neue Datei in Ihrem src Verzeichnis, index.ts und fügen Sie den folgenden Code ein. Ersetzen Sie die Zeichenfolge, die zum Erstellen der imagePath Variablen verwendet wird, durch den Pfad zum Beispielbild.

import ContentSafetyClient, {
    isUnexpected,
    AnalyzeImageParameters,
    AnalyzeImage200Response,
    AnalyzeImageDefaultResponse,
    AnalyzeImageOptions,
    ImageCategoriesAnalysisOutput
} from "@azure-rest/ai-content-safety";
import { AzureKeyCredential } from "@azure/core-auth";
import * as fs from "fs";
import * as path from "path";
import { fileURLToPath } from "url";

// Create __dirname equivalent for ESM modules
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// Get endpoint and key from environment variables
const endpoint = process.env.CONTENT_SAFETY_ENDPOINT;
const key = process.env.CONTENT_SAFETY_KEY;

if (!endpoint || !key) {
    throw new Error("Missing required environment variables CONTENT_SAFETY_ENDPOINT or CONTENT_SAFETY_KEY");
}

try {

    const credential = new AzureKeyCredential(key);
    const client = ContentSafetyClient(endpoint, credential);

    const imagePath = path.join(__dirname, '../resources/image.jpg');

    const imageBuffer = fs.readFileSync(imagePath);
    const base64Image = imageBuffer.toString("base64");
    const analyzeImageOption: AnalyzeImageOptions = { image: { content: base64Image } };
    const analyzeImageParameters: AnalyzeImageParameters = { body: analyzeImageOption };

    const result: AnalyzeImage200Response | AnalyzeImageDefaultResponse = await client.path("/image:analyze").post(analyzeImageParameters);

    if (isUnexpected(result)) {
        throw result;
    }

    const categoriesAnalysis = result.body.categoriesAnalysis as ImageCategoriesAnalysisOutput[];

    for (const analysis of categoriesAnalysis) {
        console.log(`${analysis.category} severity: ${analysis.severity}`);
    }
} catch (error) {
    console.error("Error analyzing image:", error);
}

Erstellen und Ausführen des Beispiels

1. Kompilieren sie den TypeScript-Code:

   npm run build
   

2. Führen Sie das kompilierte JavaScript aus:

   node dist/index.js
   

Output

Hate severity:  0
SelfHarm severity:  0
Sexual severity:  0
Violence severity:  0