Istruzioni di avvio rapido: analizzare il contenuto di testo

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, quindi selezionare un gruppo di risorse, un'area supportata (vedere Disponibilità di aree) e un 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 di testo

La sezione seguente illustra una richiesta di esempio con cURL. Incollare il comando qui di seguito in un editor di testo e apportare le modifiche seguenti.

1. Sostituire <endpoint> con l'URL dell'endpoint associato alla risorsa.
2. Sostituire <your_subscription_key> con una delle chiavi fornite con la risorsa.
3. Facoltativamente, sostituire il campo "text" nel corpo con il testo che si desidera analizzare.

   Suggerimento

   Dimensioni e granularità del testo

   Vedere Requisiti di input per le limitazioni massime della lunghezza del testo.

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

I campi seguenti devono essere inclusi nell'URL:

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

Vedere il corpo della richiesta di esempio seguente:

{
  "text": "I hate you",
  "categories": ["Hate", "Sexual", "SelfHarm", "Violence"],
  "blocklistNames": ["array"],
  "haltOnBlocklistHit": false,
  "outputType": "FourSeverityLevels"
}

Aprire una finestra del prompt dei comandi, incollare il comando cURL modificato ed eseguirlo.

Output

I risultati della moderazione del testo verranno visualizzati come dati JSON nell'output della console. Ad esempio:

{
  "blocklistsMatch": [
    {
      "blocklistName": "string",
      "blocklistItemId": "string",
      "blocklistItemText": "string"
    }
  ],
  "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:

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.
• 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, quindi selezionare un gruppo di risorse, un'area supportata (vedere Disponibilità di aree) e un 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#.

dotnet new console -n content-safety-quickstart

dotnet build

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

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.

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.

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'

Analizzare il contenuto di testo

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 ContentSafetySampleAnalyzeText
  {
    public static void AnalyzeText()
    {
      // 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));

      string text = "Your input text";

      var request = new AnalyzeTextOptions(text);

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

      Console.WriteLine("\nAnalyze text succeeded:");
      Console.WriteLine("Hate severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == TextCategory.Hate)?.Severity ?? 0);
      Console.WriteLine("SelfHarm severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == TextCategory.SelfHarm)?.Severity ?? 0);
      Console.WriteLine("Sexual severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == TextCategory.Sexual)?.Severity ?? 0);
      Console.WriteLine("Violence severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == TextCategory.Violence)?.Severity ?? 0);

    }
    static void Main()
    {
        AnalyzeText();
    }
  }
}

Sostituire "Your input text" con il contenuto di testo che si desidera usare.

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, quindi selezionare un gruppo di risorse, un'area supportata (vedere Disponibilità di aree) e un 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.x
  • 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.

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.

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'

Analizzare il contenuto di testo

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

1. Aprire un prompt dei comandi, andare alla cartella del progetto e creare un nuovo file denominato quickstart.py.

2. Eseguire questo comando per installare la libreria di Sicurezza dei contenuti di Azure AI:

   pip install azure-ai-contentsafety
   

3. Copiare il codice seguente in quickstart.py:

   import os
   from azure.ai.contentsafety import ContentSafetyClient
   from azure.core.credentials import AzureKeyCredential
   from azure.core.exceptions import HttpResponseError
   from azure.ai.contentsafety.models import AnalyzeTextOptions, TextCategory
   
   def analyze_text():
       # analyze text
       key = os.environ["CONTENT_SAFETY_KEY"]
       endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]
   
       # Create an Azure AI Content Safety client
       client = ContentSafetyClient(endpoint, AzureKeyCredential(key))
   
       # Contruct request
       request = AnalyzeTextOptions(text="Your input text")
   
       # Analyze text
       try:
           response = client.analyze_text(request)
       except HttpResponseError as e:
           print("Analyze text 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 == TextCategory.HATE)
       self_harm_result = next(item for item in response.categories_analysis if item.category == TextCategory.SELF_HARM)
       sexual_result = next(item for item in response.categories_analysis if item.category == TextCategory.SEXUAL)
       violence_result = next(item for item in response.categories_analysis if item.category == TextCategory.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_text()
   

4. Sostituire "Your input text" con il contenuto di testo che si desidera usare.

   Suggerimento

   Dimensioni e granularità del testo

   Vedere Requisiti di input per le limitazioni massime della lunghezza del testo.

5. 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, quindi selezionare un gruppo di risorse, un'area supportata (vedere Disponibilità di aree) e un 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 ContentSafetyQuickstart.java.

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 ContentSafetyQuickstart. 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.

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.

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'

Analizzare il contenuto di testo

Aprire ContentSafetyQuickstart.java nell’editor o IDE preferito e incollare il codice seguente. Sostituire <your text sample> con il contenuto di testo che si desidera usare.

import com.azure.ai.contentsafety.ContentSafetyClient;
import com.azure.ai.contentsafety.ContentSafetyClientBuilder;
import com.azure.ai.contentsafety.models.AnalyzeTextOptions;
import com.azure.ai.contentsafety.models.AnalyzeTextResult;
import com.azure.ai.contentsafety.models.TextCategoriesAnalysis;
import com.azure.core.credential.KeyCredential;
import com.azure.core.util.Configuration;


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

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

        AnalyzeTextResult response = contentSafetyClient.analyzeText(new AnalyzeTextOptions("<your text sample>"));

        for (TextCategoriesAnalysis 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, quindi selezionare un gruppo di risorse, un'area supportata (vedere Disponibilità di aree) e un 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

Installare l'SDK client

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

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

Installare anche il modulo dotenv 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.

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.

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'

Analizzare il contenuto di testo

Creare un nuovo file nella directory index.js. Successivamente, aprirlo nell'editor o nell'IDE preferito e incollarlo nel codice seguente. Sostituire <your text sample> con il contenuto di testo che si desidera usare.

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

// 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 text string 
    const text = "<your sample text>";
    const analyzeTextOption = { text: text };
    const analyzeTextParameters = { body: analyzeTextOption };
    
    const result = await client.path("/text:analyze").post(analyzeTextParameters);
    
    if (isUnexpected(result)) {
        throw result;
    }
    
    for (let i = 0; i < result.body.categoriesAnalysis.length; i++) {
    const textCategoriesAnalysisOutput = result.body.categoriesAnalysis[i];
    console.log(
      textCategoriesAnalysisOutput.category,
      " severity: ",
      textCategoriesAnalysisOutput.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