Início rápido: analisar conteúdo da imagem

Pré-requisitos

• Uma conta do Azure. Se você não tiver uma conta, é possível criar uma gratuitamente.
• Um recurso de IA do Azure.

Configuração

Siga estas etapas para usar a página Experimentar a Segurança do Conteúdo:

1. Acesse Azure AI Foundry e navegue até seu projeto/hub. Em seguida, selecione a guia Guardrails + controles na navegação esquerda e selecione a guia Experimentar .
2. Na página Experimentar , você pode experimentar vários recursos do Guardrails &controls, como conteúdo de texto e imagem, usando limites ajustáveis para filtrar conteúdo inadequado ou prejudicial.

Analisar imagens

Na página Moderar imagem, você pode experimentar rapidamente a moderação de imagem.

1. Selecione o painel Moderar conteúdo de imagem.
2. Selecione uma imagem de exemplo nos painéis da página ou carregue sua própria imagem.
3. Selecione Executar teste. O serviço retorna todas as categorias que foram detectadas, com o nível de severidade para cada: 0-Seguro, 2-Baixo, 4-Médio, 6-Alto. Ele também retorna um resultado binário Aceito/Rejeitado, com base nos filtros configurados. Use a matriz na guia Configurar filtros à direita para definir os níveis de severidade permitidos/proibidos de cada categoria. Depois, você pode reexecutar o texto para ver como o filtro funciona.

Exibir e exportar o código

Use o recurso Exibir Código nas páginas Analisar conteúdo de texto ou Analisar conteúdo de imagem para exibir e copiar o código de exemplo, que inclui a configuração para a filtragem de severidade, lista de bloqueados e funções de moderação. Depois, você pode implantar o código no seu ambiente.

Pré-requisitos

• Uma assinatura do Azure – crie uma gratuitamente
• Depois de ter uma assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter sua chave e ponto de extremidade. Insira um nome exclusivo para o recurso, selecione a assinatura e selecione um grupo de recursos, uma região com suporte (confira a Disponibilidade de região) e um tipo de preço com suporte. Em seguida, selecione Criar.
  • O recurso demora alguns minutos para implantar. Após a conclusão, selecione ir para o recurso. No painel à esquerda, em Gerenciamento de Recursos, selecione Chave de Assinatura e Ponto de Extremidade. O ponto de extremidade e uma das chaves são usados para chamar as APIs.
• cURL instalado

Analisar conteúdo da imagem

A seção a seguir percorre um exemplo de solicitação de moderação de imagem com cURL.

Preparar uma imagem de exemplo

Escolha uma imagem de exemplo para analisar e baixe-a em seu dispositivo.

Veja os requisitos de entrada para as limitações de imagem. Se o formato for animado, o serviço extrairá o primeiro quadro para fazer a análise.

Você pode inserir sua imagem por um dos dois métodos: fluxo de arquivos local ou URL de armazenamento de blobs.

• Fluxo de arquivos local (recomendado): codifique sua imagem para base64. Você pode usar um site como codebeautify para fazer a codificação. Em seguida, salve a cadeia de caracteres codificada em um local temporário.

• URL de Armazenamento de Blobs: carregue sua imagem em uma conta Armazenamento de Blobs do Azure. Siga o início rápido do armazenamento de blobs para saber como fazer isso. Em seguida, abra Gerenciador de Armazenamento do Azure e obtenha a URL para sua imagem. Salve-a em uma localização temporária.

  Em seguida, você precisa fornecer acesso ao recurso de Segurança de Conteúdo para ler do recurso de Armazenamento do Microsoft Azure. Habilite a identidade gerenciada atribuída pelo sistema para a instância de Segurança de Conteúdo de IA do Azure e atribua a função de Colaborador/Proprietário de Dados de Blobs de Armazenamento à identidade:

  Importante

  Somente o Colaborador de Dados de Blobs de Armazenamento ou o Proprietário de Dados de Blobs de Armazenamento são funções válidas para continuar.

  1. Habilite a identidade gerenciada para a instância de Segurança de Conteúdo de IA do Azure.

     

  2. Atribua a função de Colaborador/Proprietário de Dados do Blob de Armazenamento à identidade gerenciada. Todas as funções realçadas abaixo devem funcionar.

     

     

     

Analisar conteúdo da imagem

Cole o comando abaixo em um editor de texto e faça as seguintes alterações.

1. Substituir <endpoint> pela URL do ponto de extremidade do recurso.
2. Substitua <your_subscription_key> pela sua chave.
3. Preencha o campo "image" no corpo com o campo "content" ou o campo "blobUrl". Por exemplo: {"image": {"content": "<base_64_string>"} ou {"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>"
  }
}

Os campos abaixo precisam ser incluídos na URL:

Os parâmetros no corpo da solicitação são definidos nesta tabela:

abra uma janela do prompt de comando e execute o comando cURL.

Saída

Você verá os resultados de moderação de imagem exibidos como dados JSON no console. Por exemplo:

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

Os campos JSON na saída são definidos aqui:

Documentação de referência | Código-fonte da biblioteca | Pacote (NuGet) | Exemplos

Pré-requisitos

• Uma assinatura do Azure – crie uma gratuitamente
• O IDE do Visual Studio com a carga de trabalho de desenvolvimento da área de trabalho do .NET habilitada. Ou, se você não planeja usar o IDE do Visual Studio, precisará da versão atual do .NET Core.
• Runtime do .NET instalado.
• Depois de ter uma assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter sua chave e ponto de extremidade. Insira um nome exclusivo para o recurso, selecione a assinatura e selecione um grupo de recursos, uma região com suporte (confira a Disponibilidade de região) e um tipo de preço com suporte. Em seguida, selecione Criar.
  • O recurso demora alguns minutos para implantar. Após a conclusão, selecione ir para o recurso. No painel à esquerda, em Gerenciamento de Recursos, selecione Chave de Assinatura e Ponto de Extremidade. O ponto de extremidade e uma das chaves são usados para chamar as APIs.

Configurar aplicativo

Criar um aplicativo em C#.

dotnet new console -n content-safety-quickstart

dotnet build

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

dotnet add package Azure.AI.ContentSafety

Criar variáveis de ambiente

Neste exemplo, você gravará as credenciais em variáveis de ambiente no computador local que está executando o aplicativo.

Para definir a variável de ambiente da chave e do ponto de extremidade, abra uma janela do console e siga as instruções para o sistema operacional e o ambiente de desenvolvimento.

• Para definir a variável de ambiente CONTENT_SAFETY_KEY, substitua YOUR_CONTENT_SAFETY_KEY por uma das chaves do recurso.
• Para definir a variável de ambiente CONTENT_SAFETY_ENDPOINT, substitua YOUR_CONTENT_SAFETY_ENDPOINT pelo ponto de extremidade do recurso.

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'

Analisar conteúdo da imagem

No diretório do projeto, abra o arquivo Program.cs que foi criado anteriormente. Cole o código a seguir.

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

Crie uma pasta sample_data no diretório do projeto e adicione um arquivo image.png nele.

dotnet build
dotnet run

Documentação de referência | Código-fonte da biblioteca | Pacote (PyPI) | Amostras |

Pré-requisitos

• Uma assinatura do Azure – crie uma gratuitamente
• Depois de ter uma assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter sua chave e ponto de extremidade. Insira um nome exclusivo para o recurso, selecione a assinatura e selecione um grupo de recursos, uma região com suporte (confira a Disponibilidade de região) e um tipo de preço com suporte. Em seguida, selecione Criar.
  • O recurso demora alguns minutos para implantar. Após a conclusão, selecione ir para o recurso. No painel à esquerda, em Gerenciamento de Recursos, selecione Chave de Assinatura e Ponto de Extremidade. O ponto de extremidade e uma das chaves são usados para chamar as APIs.
• Python 3.8 ou posterior
  • A instalação do Python deve incluir o pip. Você pode executar pip --version na linha de comando para verificar se o pip está instalado. Instale a versão mais recente do Python para obter o pip.

Criar variáveis de ambiente

Neste exemplo, você gravará as credenciais em variáveis de ambiente no computador local que está executando o aplicativo.

Para definir a variável de ambiente da chave e do ponto de extremidade, abra uma janela do console e siga as instruções para o sistema operacional e o ambiente de desenvolvimento.

• Para definir a variável de ambiente CONTENT_SAFETY_KEY, substitua YOUR_CONTENT_SAFETY_KEY por uma das chaves do recurso.
• Para definir a variável de ambiente CONTENT_SAFETY_ENDPOINT, substitua YOUR_CONTENT_SAFETY_ENDPOINT pelo ponto de extremidade do recurso.

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'

Analisar conteúdo da imagem

A seção a seguir percorre uma solicitação de exemplo com o SDK do Python.

1. Abra um prompt de comando, navegue até a pasta do projeto e crie um novo arquivo chamado quickstart.py.

2. Execute este comando para instalar a biblioteca cliente da Segurança de Conteúdo de IA do Azure:

   python -m pip install azure-ai-contentsafety
   

3. Copie o seguinte código em 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. Substitua "sample_data" e "image.jpg" pelo caminho e nome do arquivo do local que você deseja usar.

5. Execute o aplicativo com o comando python no arquivo de início rápido.

   python quickstart.py
   

Documentação de referência | Código-fonte da biblioteca | Artefato (Maven) | Exemplos

Pré-requisitos

• Uma assinatura do Azure – crie uma gratuitamente
• A versão atual do JDK (Java Development Kit)
• A ferramenta de compilação Gradle ou outro gerenciador de dependências.
• Depois de ter uma assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter sua chave e ponto de extremidade. Insira um nome exclusivo para o recurso, selecione a assinatura e selecione um grupo de recursos, uma região com suporte (confira a Disponibilidade de região) e um tipo de preço com suporte. Em seguida, selecione Criar.
  • O recurso demora alguns minutos para implantar. Após a conclusão, selecione ir para o recurso. No painel à esquerda, em Gerenciamento de Recursos, selecione Chave de Assinatura e Ponto de Extremidade. O ponto de extremidade e uma das chaves são usados para chamar as APIs.

Configurar aplicativo

Criar um novo projeto Gradle.

Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

mkdir myapp && cd myapp

Execute o comando gradle init em seu diretório de trabalho. Esse comando criará arquivos de build essenciais para o Gradle, incluindo o build.gradle.kts, que é usado no runtime para criar e configurar seu aplicativo.

gradle init --type basic

Quando solicitado a escolher uma DSL, escolha Kotlin.

Em seu diretório de trabalho, execute o comando a seguir para criar uma pasta de origem do projeto:

mkdir -p src/main/java

Navegue até a nova pasta e crie um arquivo chamado ContentSafetyQuickstart.java.

Crie também uma pasta src/resources na raiz do seu projeto e adicione a ela uma amostra de imagem.

Instalar o cliente SDK

Este início rápido usa o gerenciador de dependência do Gradle. Você pode encontrar a biblioteca de clientes e informações para outros gerenciadores de dependência no Repositório Central do Maven.

Localize o build.gradle.kts e abra-o com seu IDE ou editor de texto preferencial. Depois copie nessa configuração de build a seguir. Essa configuração define o projeto como um aplicativo Java, cujo ponto de entrada é a classe ContentSafetyQuickstart. Isso importa a biblioteca da Visão de IA do Azure.

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

Criar variáveis de ambiente

Neste exemplo, você gravará as credenciais em variáveis de ambiente no computador local que está executando o aplicativo.

Para definir a variável de ambiente da chave e do ponto de extremidade, abra uma janela do console e siga as instruções para o sistema operacional e o ambiente de desenvolvimento.

• Para definir a variável de ambiente CONTENT_SAFETY_KEY, substitua YOUR_CONTENT_SAFETY_KEY por uma das chaves do recurso.
• Para definir a variável de ambiente CONTENT_SAFETY_ENDPOINT, substitua YOUR_CONTENT_SAFETY_ENDPOINT pelo ponto de extremidade do recurso.

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'

Analisar conteúdo da imagem

Abra ContentSafetyQuickstart.java no editor ou IDE de sua preferência e cole o código a seguir. Substitua a variável source pelo caminho para a sua amostra de imagem.

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

Navegue de volta para a pasta raiz do projeto e compile o aplicativo com:

gradle build

Em seguida, execute-o com o comando gradle run:

gradle run

Saída

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

Documentação de referência | Código-fonte da biblioteca | Pacote (npm) | Exemplos |

Pré-requisitos

• Uma assinatura do Azure – crie uma gratuitamente
• A versão atual do Node.js
• Depois de ter uma assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter sua chave e ponto de extremidade. Insira um nome exclusivo para o recurso, selecione a assinatura e selecione um grupo de recursos, uma região com suporte (confira a Disponibilidade de região) e um tipo de preço com suporte. Em seguida, selecione Criar.
  • O recurso demora alguns minutos para implantar. Após a conclusão, selecione ir para o recurso. No painel à esquerda, em Gerenciamento de Recursos, selecione Chave de Assinatura e Ponto de Extremidade. O ponto de extremidade e uma das chaves são usados para chamar as APIs.

Configurar aplicativo

Crie um aplicativo Node.js. Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

mkdir myapp && cd myapp

Execute o comando npm init para criar um aplicativo do Node com um arquivo package.json.

npm init

Crie também uma pasta /resources na raiz do seu projeto e adicione a ela uma amostra de imagem.

Instalar o cliente SDK

Instale o pacote npm:@azure-rest/ai-content-safety

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

Além disso, instale o módulo dotenv para usar variáveis de ambiente:

npm install dotenv

O arquivo package.json do seu aplicativo será atualizado com as dependências.

Criar variáveis de ambiente

Neste exemplo, você gravará as credenciais em variáveis de ambiente no computador local que está executando o aplicativo.

Para definir a variável de ambiente da chave e do ponto de extremidade, abra uma janela do console e siga as instruções para o sistema operacional e o ambiente de desenvolvimento.

• Para definir a variável de ambiente CONTENT_SAFETY_KEY, substitua YOUR_CONTENT_SAFETY_KEY por uma das chaves do recurso.
• Para definir a variável de ambiente CONTENT_SAFETY_ENDPOINT, substitua YOUR_CONTENT_SAFETY_ENDPOINT pelo ponto de extremidade do recurso.

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'

Analisar conteúdo da imagem

Crie um novo arquivo no seu diretório, index.js. Abra-o no editor ou IDE de sua preferência e cole o código a seguir. Substitua a variável image_path pelo caminho para a sua amostra de imagem.

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

Execute o aplicativo com o comando node no seu arquivo de início rápido.

node index.js

Saída

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

Documentação de referência | Código-fonte da biblioteca | Pacote (npm) | Exemplos |

Pré-requisitos

• Uma assinatura do Azure – crie uma gratuitamente
• Node.js LTS
• TypeScript
• Código do Visual Studio
• Depois de ter uma assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter sua chave e ponto de extremidade. Insira um nome exclusivo para o recurso, selecione a assinatura e selecione um grupo de recursos, uma região com suporte (confira a Disponibilidade de região) e um tipo de preço com suporte. Em seguida, selecione Criar.
  • O recurso demora alguns minutos para implantar. Após a conclusão, selecione ir para o recurso. No painel à esquerda, em Gerenciamento de Recursos, selecione Chave de Assinatura e Ponto de Extremidade. O ponto de extremidade e uma das chaves são usados para chamar as APIs.

Configurar o ambiente de desenvolvimento local

1. Crie um novo diretório para seu projeto e navegue até ele:

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

2. Crie um novo pacote para módulos ESM no diretório do projeto:

   npm init -y
   npm pkg set type=module
   

3. Instale os pacotes necessários:

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

4. Instale dependências de desenvolvimento:

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

5. Crie um tsconfig.json arquivo no diretório do projeto:

   {
     "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. Atualize package.json para incluir um script para a criação de arquivos TypeScript:

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

7. Crie uma resources pasta e adicione uma imagem de exemplo a ela.

8. Crie um src diretório para o código TypeScript.

Criar variáveis de ambiente

Neste exemplo, você gravará as credenciais em variáveis de ambiente no computador local que está executando o aplicativo.

Para definir a variável de ambiente da chave e do ponto de extremidade, abra uma janela do console e siga as instruções para o sistema operacional e o ambiente de desenvolvimento.

• Para definir a variável de ambiente CONTENT_SAFETY_KEY, substitua YOUR_CONTENT_SAFETY_KEY por uma das chaves do recurso.
• Para definir a variável de ambiente CONTENT_SAFETY_ENDPOINT, substitua YOUR_CONTENT_SAFETY_ENDPOINT pelo ponto de extremidade do recurso.

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'

Analisar conteúdo da imagem

Crie um novo arquivo em seu src diretório index.ts e cole o código a seguir. Substitua a cadeia de caracteres usada para criar a imagePath variável pelo caminho para sua imagem de exemplo.

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

Criar e executar o exemplo

1. Compile o código TypeScript:

   npm run build
   

2. Execute o JavaScript compilado:

   node dist/index.js
   

Saída

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