Istruzioni di avvio rapido: Analizzare il contenuto delle immagini

Articolo
05/08/2024

Iniziare a usare Content Studio, API REST o gli SDK client per eseguire la moderazione delle immagini di base. Il servizio Azure AI Content Cassaforte ty offre algoritmi di intelligenza artificiale per contrassegnare contenuti inapproponibili. Seguire questa procedura per provare.

Nota

I dati di esempio e il codice possono avere contenuti offensivi. La discrezione dell'utente è consigliata.

Prerequisiti

Una sottoscrizione di Azure: creare un account gratuitamente
Dopo aver creato la sottoscrizione di Azure, Creare una risorsa di Sicurezza dei contenuti nel portale di Azure per ottenere la chiave e l'endpoint. Immettere un nome univoco per la risorsa, selezionare la sottoscrizione e selezionare un gruppo di risorse, un'area supportata (Stati Uniti orientali o Europa occidentale) e il piano tariffario supportato. Selezionare Crea.
- La distribuzione della risorsa richiede alcuni minuti. Al termine, selezionare Vai alla risorsa. Nel riquadro a sinistra, in Gestione risorse selezionare Chiave di sottoscrizione ed endpoint. L'endpoint e una delle chiavi vengono usati per chiamare le API.
cURL installato

Analizzare il contenuto delle immagini

La sezione seguente illustra una richiesta di moderazione delle immagini di esempio con cURL.

Preparare un'immagine di esempio

Scegliere un'immagine di esempio da analizzare e scaricarla nel dispositivo.

Sono supportati formati di immagine JPEG, PNG, GIF, BMP, TIFF o WEBP. La dimensione massima per gli invii di immagini è di 4 MB e le dimensioni dell'immagine devono essere comprese tra 50 x 50 pixel e 2.048 x 2.048 pixel. Se il formato è animato, verrà estratto il primo fotogramma per eseguire il rilevamento.

È possibile immettere l'immagine in uno dei due metodi seguenti: filestream locale o URL di archiviazione BLOB.

Filestream locale (scelta consigliata): codificare l'immagine in base64. È possibile usare un sito Web come codecodetify per eseguire la codifica. Salvare quindi la stringa codificata in una posizione temporanea.
URL di archiviazione BLOB: caricare l'immagine in un account di archiviazione BLOB di Azure. Per informazioni su come eseguire questa operazione, seguire le istruzioni di avvio sull'archiviazione BLOB. Aprire quindi Azure Storage Explorer e ottenere l'URL dell'immagine. Salvarlo anche in un percorso temporaneo.

Successivamente, è necessario concedere alla risorsa Sicurezza dei contenuti l'accesso per la lettura dalla risorsa di Archiviazione di Azure. Abilitare l'identità gestita assegnata dal sistema per l'istanza di Azure AI Content Cassaforte ty e assegnare il ruolo di collaboratore/proprietario/lettore di Archiviazione dati BLOB all'identità:
1. Abilitare l'identità gestita per l'istanza di Content Cassaforte ty di Intelligenza artificiale di Azure.
2. Assegnare il ruolo Collaboratore/Proprietario/Lettore dei dati dei BLOB di archiviazione all'identità gestita. Tutti i ruoli evidenziati di seguito dovrebbero funzionare.

Analizzare il contenuto delle immagini

Incollare il comando qui di seguito in un editor di testo e apportare le modifiche seguenti.

Sostituire <endpoint> con l'URL dell'endpoint della risorsa.
Sostituire <your_subscription_key> con la chiave.
Popolare il campo "image" nel corpo con un campo "content" o uno "blobUrl". Ad esempio, {"image": {"content": "<base_64_string>"} o {"image": {"blobUrl": "<your_storage_url>"}.

curl --location --request POST '<endpoint>/contentsafety/image:analyze?api-version=2023-10-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"
}'

Nota

Se si usa un URL di archiviazione BLOB, il corpo della richiesta sarà simile al seguente:

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

Aprire una finestra del prompt dei comandi ed eseguire il comando cURL.

I campi seguenti devono essere inclusi nell'URL:

Nome	Obbligatorio?	Descrizione	Tipo
Versione dell'API	Richiesto	La versione dell'API da controllare. La versione corrente è: `api-version=2023-10-01`. Esempio: `<endpoint>/contentsafety/image:analyze?api-version=2023-10-01`	String

I parametri nel corpo della richiesta sono definiti in questa tabella:

Nome	Obbligatorio?	Descrizione	Tipo
content	Richiesto	URL del contenuto o del BLOB dell'immagine. I can be either base64-encoded bytes or a blob URL. Se vengono specificati entrambi, la richiesta viene rifiutata. La dimensione massima consentita dell'immagine è di 2048 pixel x 2048 pixel e la dimensione massima del file è di 4 MB. La dimensione minima dell'immagine è di 50 pixel x 50 pixel.	String
categorie	Facoltativo	Si presuppone che sia un array di nomi di categoria. Per un elenco dei nomi di categoria disponibili, vedere la Guida alle categorie di danni. Se non vengono specificate categorie, vengono utilizzate tutte e quattro le categorie. Vengono usate più categorie per ottenere punteggi in una singola richiesta.	String
outputType	Facoltativo	L'API di moderazione delle immagini supporta `"FourSeverityLevels"`solo . Gravità dell'output in quattro livelli. Il valore può essere `0,2,4,6`	String

Output

I risultati della moderazione dell'immagine verranno visualizzati come dati JSON nella console. Ad esempio:

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

I campi JSON nell'output sono definiti di seguito:

Nome	Descrizione	Tipo
categoriesAnalysis	Ogni classe di output stimata dall'API. La classificazione può essere con etichetta multipla. Ad esempio, quando un'immagine viene caricata nel modello di moderazione delle immagini, può essere classificata sia come contenuto sessuale che come violenza. Categorie di danni	String
Gravità	Livello di gravità del flag in ogni categoria di danni. Categorie di danni	Intero

Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (NuGet) | Esempi

Prerequisiti

Una sottoscrizione di Azure: creare un account gratuitamente
IDE di Visual Studio con sviluppo desktop .NET del carico di lavoro abilitato. In alternativa, se non si prevede di usare l'IDE di Visual Studio, è necessaria la versione corrente di .NET Core.
Runtime .NET installato.
Dopo aver creato la sottoscrizione di Azure, Creare una risorsa di Sicurezza dei contenuti nel portale di Azure per ottenere la chiave e l'endpoint. Immettere un nome univoco per la risorsa, selezionare la sottoscrizione e selezionare un gruppo di risorse, un'area supportata (Stati Uniti orientali o Europa occidentale) e il piano tariffario supportato. Selezionare Crea.
- La distribuzione della risorsa richiede alcuni minuti. Al termine, selezionare Vai alla risorsa. Nel riquadro a sinistra, in Gestione risorse selezionare Chiave di sottoscrizione ed endpoint. L'endpoint e una delle chiavi vengono usati per chiamare le API.

Configurare l'applicazione

Creare una nuova applicazione C#.

IDE di Visual Studio
CLI

Aprire Visual Studio e in Introduzione selezionare Crea un nuovo progetto. Impostare i filtri del modello su C#/Tutte le piattaforme/Console. Selezionare App console (applicazione da riga di comando che è possibile eseguire in .NET in Windows, Linux e macOS), quindi selezionare Avanti. Aggiornare il nome del progetto in ContentSafetyQuickstart e selezionare Avanti. Selezionare .NET 6.0 o versione successiva e scegliere Crea per creare il progetto.

Installare l'SDK client

Dopo aver creato un nuovo progetto, installare il SDK client facendo clic con il pulsante destro del mouse sulla soluzione del progetto in Esplora soluzioni e scegliendo Gestisci pacchetti NuGet. Nella finestra di dialogo Gestione pacchetti visualizzata selezionare Sfoglia e cercare Azure.AI.ContentSafety. Selezionare Installa.

In una finestra di una console, ad esempio cmd, PowerShell o Bash, usare il comando dotnet new per creare una nuova app console con il nome content-safety-quickstart. Questo comando crea un semplice progetto C# "Hello World" con un singolo file di origine: Program.cs.

dotnet new console -n content-safety-quickstart

Spostarsi nella cartella dell'app appena creata. È possibile compilare l'applicazione con il comando seguente:

dotnet build

L'output di compilazione non deve contenere alcun avviso o errore.

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

Installare l'SDK client

Nella directory dell'applicazione installare la libreria SDK client di Visione artificiale per .NET con il comando seguente:

dotnet add package Azure.AI.ContentSafety

Creare variabili di ambiente

In questo esempio, sarà possibile scrivere le credenziali nelle variabili di ambiente nel computer locale che esegue l'applicazione.

Suggerimento

Non includere la chiave direttamente nel codice e non renderla mai pubblica. Per altre opzioni di autenticazione come Azure Key Vault, vedere l'articolo sicurezza dei servizi di intelligenza artificiale di Azure.

Per impostare la variabile di ambiente per la chiave e l'endpoint, aprire una finestra della console e seguire le istruzioni del sistema operativo e dell'ambiente di sviluppo.

Per impostare la CONTENT_SAFETY_KEYvariabile di ambiente, sostituire YOUR_CONTENT_SAFETY_KEY con una delle chiavi della risorsa.
Per impostare la CONTENT_SAFETY_ENDPOINTvariabile di ambiente, sostituire YOUR_CONTENT_SAFETY_ENDPOINT con l'endpoint della risorsa.

Windows
Linux

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

Dopo aver aggiunto le variabili di ambiente, potrebbe essere necessario riavviare tutti i programmi in esecuzione che leggeranno le variabili di ambiente, inclusa la finestra della console.

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Dopo avere aggiunto le variabili di ambiente, eseguire source ~/.bashrc dalla finestra della console per rendere effettive le modifiche.

Analizzare il contenuto delle immagini

Dalla directory del progetto aprire il file program.cs creato in precedenza. Incollare il codice seguente.

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

Creare una cartella sample_data nella directory del progetto e aggiungerne una image.png .

IDE di Visual Studio
CLI

Compilare ed eseguire l'applicazione selezionando Avvia debug nel menu Debug nella parte superiore della finestra IDE (o premere F5).

Compilare ed eseguire l'applicazione dalla directory dell'applicazione con i seguenti comandi:

dotnet build
dotnet run

Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (PyPI) | Esempi |

Prerequisiti

Una sottoscrizione di Azure: creare un account gratuitamente
Dopo aver creato la sottoscrizione di Azure, Creare una risorsa di Sicurezza dei contenuti nel portale di Azure per ottenere la chiave e l'endpoint. Immettere un nome univoco per la risorsa, selezionare la sottoscrizione e selezionare un gruppo di risorse, un'area supportata (Stati Uniti orientali o Europa occidentale) e il piano tariffario supportato. Selezionare Crea.
- La distribuzione della risorsa richiede alcuni minuti. Al termine, selezionare Vai alla risorsa. Nel riquadro a sinistra, in Gestione risorse selezionare Chiave di sottoscrizione ed endpoint. L'endpoint e una delle chiavi vengono usati per chiamare le API.
Python 3.8 o versione successiva
- L'installazione di Python deve includere pip. È possibile verificare se pip è installato eseguendo pip --version nella riga di comando. Ottenere pip installando la versione più recente di Python.

Creare variabili di ambiente

In questo esempio, sarà possibile scrivere le credenziali nelle variabili di ambiente nel computer locale che esegue l'applicazione.

Suggerimento

Per impostare la variabile di ambiente per la chiave e l'endpoint, aprire una finestra della console e seguire le istruzioni del sistema operativo e dell'ambiente di sviluppo.

Per impostare la CONTENT_SAFETY_KEYvariabile di ambiente, sostituire YOUR_CONTENT_SAFETY_KEY con una delle chiavi della risorsa.
Per impostare la CONTENT_SAFETY_ENDPOINTvariabile di ambiente, sostituire YOUR_CONTENT_SAFETY_ENDPOINT con l'endpoint della risorsa.

Windows
Linux

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

Dopo aver aggiunto le variabili di ambiente, potrebbe essere necessario riavviare tutti i programmi in esecuzione che leggeranno le variabili di ambiente, inclusa la finestra della console.

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Dopo avere aggiunto le variabili di ambiente, eseguire source ~/.bashrc dalla finestra della console per rendere effettive le modifiche.

Analizzare il contenuto delle immagini

La sezione seguente illustra una richiesta di esempio con Python SDK.

Aprire un prompt dei comandi, andare alla cartella del progetto e creare un nuovo file denominato quickstart.py.
Eseguire questo comando per installare la libreria client di Azure AI Content Cassaforte ty:
```
python -m pip install azure-ai-contentsafety
```

Copiare il codice seguente 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()

Sostituire "sample_data" e "image.jpg" con il percorso e il nome file dell'istanza locale da usare.
Successivamente, eseguire l'applicazione con il comando python nel file di avvio rapido.
```
python quickstart.py
```

Documentazione di riferimento | Codice sorgente della libreria | Artefatto (Maven) | Esempi

Prerequisiti

Una sottoscrizione di Azure: creare un account gratuitamente
La versione più recente di Java Development Kit (JDK)
Lo strumento di compilazione Gradle o un'altra utilità di gestione dipendenze.
Dopo aver creato la sottoscrizione di Azure, Creare una risorsa di Sicurezza dei contenuti nel portale di Azure per ottenere la chiave e l'endpoint. Immettere un nome univoco per la risorsa, selezionare la sottoscrizione e selezionare un gruppo di risorse, un'area supportata (Stati Uniti orientali o Europa occidentale) e il piano tariffario supportato. Selezionare Crea.
- La distribuzione della risorsa richiede alcuni minuti. Al termine, selezionare Vai alla risorsa. Nel riquadro a sinistra, in Gestione risorse selezionare Chiave di sottoscrizione ed endpoint. L'endpoint e una delle chiavi vengono usati per chiamare le API.

Configurare l'applicazione

Creare un nuovo progetto Gradle.

In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app.

mkdir myapp && cd myapp

Eseguire il comando gradle init dalla directory di lavoro. Questo comando creerà i file di compilazione essenziali per Gradle, tra cui build.gradle.kts, che viene usato in fase di esecuzione per creare e configurare l'applicazione.

gradle init --type basic

Quando viene chiesto di scegliere un linguaggio DSL, selezionare Kotlin.

Dalla directory di lavoro eseguire il comando seguente per creare una cartella di origine del progetto:

mkdir -p src/main/java

Passare alla nuova cartella e creare un file denominato Content Cassaforte tyQuickstart.java.

Creare anche una src/resources cartella nella radice del progetto e aggiungervi un'immagine di esempio.

Installare l'SDK client

Questo argomento di avvio rapido usa l'utilità di gestione dipendenze Gradle. La libreria client e le informazioni per altre utilità di gestione dipendenze sono disponibili in Maven Central Repository.

Individuare il file build.gradle.kts e aprirlo con un IDE o un editor di testo a scelta. Quindi copiare la configurazione di compilazione seguente. Questa configurazione definisce il progetto come applicazione Java il cui punto di ingresso è la classe Content Cassaforte tyQuickstart. Importa la libreria di Visione artificiale di Azure.

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

Creare variabili di ambiente

In questo esempio, sarà possibile scrivere le credenziali nelle variabili di ambiente nel computer locale che esegue l'applicazione.

Suggerimento

Per impostare la variabile di ambiente per la chiave e l'endpoint, aprire una finestra della console e seguire le istruzioni del sistema operativo e dell'ambiente di sviluppo.

Per impostare la CONTENT_SAFETY_KEYvariabile di ambiente, sostituire YOUR_CONTENT_SAFETY_KEY con una delle chiavi della risorsa.
Per impostare la CONTENT_SAFETY_ENDPOINTvariabile di ambiente, sostituire YOUR_CONTENT_SAFETY_ENDPOINT con l'endpoint della risorsa.

Windows
Linux

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

Dopo aver aggiunto le variabili di ambiente, potrebbe essere necessario riavviare tutti i programmi in esecuzione che leggeranno le variabili di ambiente, inclusa la finestra della console.

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Dopo avere aggiunto le variabili di ambiente, eseguire source ~/.bashrc dalla finestra della console per rendere effettive le modifiche.

Analizzare il contenuto delle immagini

Aprire Content Cassaforte tyQuickstart.java nell'editor o nell'IDE preferito e incollare il codice seguente. Sostituire la source variabile con il percorso dell'immagine di esempio.

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

Tornare alla cartella radice del progetto e compilare l'app con:

gradle build

Eseguirlo quindi con il comando gradle run:

gradle run

Output

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

Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (npm) | Esempi |

Prerequisiti

Una sottoscrizione di Azure: creare un account gratuitamente
Versione corrente di Node.js
Dopo aver creato la sottoscrizione di Azure, Creare una risorsa di Sicurezza dei contenuti nel portale di Azure per ottenere la chiave e l'endpoint. Immettere un nome univoco per la risorsa, selezionare la sottoscrizione e selezionare un gruppo di risorse, un'area supportata (Stati Uniti orientali o Europa occidentale) e il piano tariffario supportato. Selezionare Crea.
- La distribuzione della risorsa richiede alcuni minuti. Al termine, selezionare Vai alla risorsa. Nel riquadro a sinistra, in Gestione risorse selezionare Chiave di sottoscrizione ed endpoint. L'endpoint e una delle chiavi vengono usati per chiamare le API.

Configurare l'applicazione

Creare una nuova applicazione Node.js. In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app.

mkdir myapp && cd myapp

Eseguire il comando npm init per creare un'applicazione Node con un file package.json.

npm init

Creare anche una /resources cartella nella radice del progetto e aggiungervi un'immagine di esempio.

Installare l'SDK client

Installare il pacchetto npm @azure-rest/ai-content-safety:

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

Installare anche il dotenv modulo per usare le variabili di ambiente:

npm install dotenv

Il file package.json dell'app viene aggiornato con le dipendenze.

Creare variabili di ambiente

In questo esempio, sarà possibile scrivere le credenziali nelle variabili di ambiente nel computer locale che esegue l'applicazione.

Suggerimento

Per impostare la variabile di ambiente per la chiave e l'endpoint, aprire una finestra della console e seguire le istruzioni del sistema operativo e dell'ambiente di sviluppo.

Per impostare la CONTENT_SAFETY_KEYvariabile di ambiente, sostituire YOUR_CONTENT_SAFETY_KEY con una delle chiavi della risorsa.
Per impostare la CONTENT_SAFETY_ENDPOINTvariabile di ambiente, sostituire YOUR_CONTENT_SAFETY_ENDPOINT con l'endpoint della risorsa.

Windows
Linux

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

Dopo aver aggiunto le variabili di ambiente, potrebbe essere necessario riavviare tutti i programmi in esecuzione che leggeranno le variabili di ambiente, inclusa la finestra della console.

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Dopo avere aggiunto le variabili di ambiente, eseguire source ~/.bashrc dalla finestra della console per rendere effettive le modifiche.

Analizzare il contenuto delle immagini

Creare un nuovo file nella directory index.js. Aprirlo nell'editor o nell'IDE preferito e incollarlo nel codice seguente. Sostituire la image_path variabile con il percorso dell'immagine di esempio.

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

Eseguire l'applicazione con il comando node nel file quickstart.

node index.js

Output

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

Pulire le risorse

Se si vuole pulire e rimuovere una sottoscrizione a Servizi di Azure AI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

Passaggi successivi

Configurare i filtri per ogni categoria e test sui set di dati usando Studio di Sicurezza dei contenuti, esportare il codice e distribuire.

Istruzioni di avvio rapido di Studio di Sicurezza dei contenuti

Istruzioni di avvio rapido: Analizzare il contenuto delle immagini

Prerequisiti

Analizzare il contenuto delle immagini

Preparare un'immagine di esempio

Analizzare il contenuto delle immagini

Output

Prerequisiti

Configurare l'applicazione

Installare l'SDK client

Creare variabili di ambiente

Analizzare il contenuto delle immagini

Prerequisiti

Creare variabili di ambiente

Analizzare il contenuto delle immagini

Prerequisiti

Configurare l'applicazione

Installare l'SDK client

Creare variabili di ambiente

Analizzare il contenuto delle immagini

Output

Prerequisiti

Configurare l'applicazione

Installare l'SDK client

Creare variabili di ambiente

Analizzare il contenuto delle immagini

Output

Pulire le risorse

Passaggi successivi

Risorse aggiuntive