Configurar atributos de segurança

A API Vertex AI Gemini bloqueia conteúdo não seguro com base em uma lista de atributos de segurança e os limites de bloqueio configurados. Esta página descreve os principais conceitos de segurança e mostra como configurar os limites de bloqueio de cada atributo de segurança para controlar com que frequência as solicitações e respostas são bloqueadas.

Pontuação de confiança do atributo de segurança

O conteúdo processado pela API Vertex AI Gemini é avaliado com base em uma lista de atributos de segurança, que incluem "categorias prejudiciais" e tópicos que podem ser considerados sensíveis. Esses atributos de segurança são indicados na seguinte tabela:

Pontuação do atributo de segurança

Atributo de segurança	Definição
Discurso de ódio	Comentários negativos ou nocivos voltados à identidade e/ou atributos protegidos.
Assédio	Comentários maliciosos, intimidadores, abusivos ou violentos direcionados a outra pessoa.
Sexualmente explícito	Contém referências a atos sexuais ou outro conteúdo sexual.
Conteúdo perigoso	Promove ou permite o acesso a produtos, serviços e atividades prejudiciais.

Probabilidades de atributos de segurança

Cada atributo de segurança tem uma pontuação de confiança associada de 0,0 a 1,0, arredondada para uma casa decimal. A pontuação de confiança reflete a probabilidade da entrada ou resposta pertencer a uma determinada categoria.

A pontuação de confiança na tabela a seguir é retornada com um nível de confiança de segurança:

Probabilidade	Descrição
INSIGNIFICANTE	O conteúdo tem uma probabilidade mínima de não ser seguro.
LOW	O conteúdo tem uma probabilidade baixa de não ser seguro.
MÉDIO	O conteúdo tem uma probabilidade média de não ser seguro.
HIGH	O conteúdo tem alta probabilidade de não ser seguro.

Gravidade do atributo de segurança

Cada um dos quatro atributos de segurança recebe uma classificação de segurança (nível de gravidade) e uma pontuação de gravidade de 0,0 a 1,0, arredondada para uma casa decimal. As classificações e pontuações na tabela a seguir refletem a gravidade prevista do conteúdo em uma determinada categoria:

Gravidade	Descrição
INSIGNIFICANTE	A gravidade do conteúdo é prevista como insignificante com relação à política de segurança do Google.
LOW	A gravidade do conteúdo é prevista como baixa de acordo com a política de segurança do Google.
MÉDIO	A gravidade do conteúdo é considerada média com relação à política de segurança do Google.
HIGH	A gravidade do conteúdo é prevista como alta de acordo com a política de segurança do Google.

Pontuações de probabilidade em comparação com as pontuações de gravidade

Há dois tipos de pontuações de segurança:

• Pontuações de segurança com base na probabilidade de não ser segura
• Pontuações de segurança com base na gravidade de conteúdo nocivo

O atributo de segurança probability reflete a probabilidade de uma entrada ou resposta de modelo ser associada ao respectivo atributo de segurança. O atributo de segurança severity reflete a magnitude de quão prejudicial uma entrada ou resposta de modelo pode ser.

O conteúdo pode ter uma pontuação de probabilidade baixa e uma pontuação de gravidade alta ou uma pontuação de probabilidade alta e uma pontuação de gravidade baixa. Por exemplo, considere as duas frases a seguir:

1. O robô me bateu.
2. O robô me cortou.

A primeira frase pode aumentar a probabilidade de não ser segura, e a segunda, mais gravidade em termos de violência. Por isso, é importante testar cuidadosamente e considerar o nível apropriado de bloqueio necessário para oferecer suporte aos seus principais casos de uso e minimizar os danos aos usuários finais.

Configurações de segurança

As configurações de segurança fazem parte da solicitação que você envia ao serviço de API. Elas podem ser ajustadas para cada solicitação feita à API. A tabela a seguir descreve as configurações de bloqueio que você pode ajustar em cada categoria. Por exemplo, se você definir a configuração de bloqueio como Bloquear poucos itens na categoria "Conteúdos perigosos", tudo com alta probabilidade de ser um conteúdo perigoso será bloqueado. No entanto, qualquer item com menor probabilidade de risco é permitido. Se não for definida, a configuração de bloqueio padrão será Bloquear alguns itens.

Limite (Studio)	Limite (API)	Limite (descrição)
	BLOCK_NONE (Restrito)	Sempre mostrar, seja qual for a probabilidade do conteúdo não ser seguro.
Bloquear poucos	BLOCK_ONLY_HIGH	Bloquear quando houver alta probabilidade do conteúdo não ser seguro.
Bloquear alguns (padrão)	BLOCK_MEDIUM_AND_ABOVE (padrão)	Bloquear quando houver probabilidade média ou alta do conteúdo não ser seguro.
Bloquear muitos	BLOCK_LOW_AND_ABOVE	Bloquear quando houver probabilidade média ou alta do conteúdo não ser seguro.
	HARM_BLOCK_THRESHOLD_UNSPECIFIED	Como o limite não foi especificado, o bloqueio está usando o limite padrão.

Você pode mudar essas configurações em cada solicitação que fizer ao serviço de mensagens de texto. Confira mais detalhes na referência da API HarmBlockThreshold.

Observação: a configuração "BLOCK_NONE" é um campo restrito não disponível para todos os usuários nas versões de modelo com disponibilidade geral. Consulte o restante deste documento para mais orientações.

Como remover o bloqueio de respostas automáticas para atributos de segurança selecionados

A configuração de segurança "BLOCK_NONE" remove o bloqueio de respostas automáticas (para os atributos de segurança descritos em "Configurações de segurança") e permite que você defina suas próprias diretrizes de segurança com as pontuações retornadas. Para acessar a configuração "BLOCK_NONE", você tem duas opções:

(1) Você pode se inscrever na lista de permissões usando o formulário de lista de permissões de filtro de segurança do Gemini.

(2) É possível mudar o tipo de conta para faturamento mensal com a referência de cobrança por fatura do GCP.

Principais diferenças entre o Gemini e outras famílias de modelos

Embora os mesmos classificadores de segurança sejam aplicados ao Gemini e ao PaLM, o número de atributos de segurança retornados na API pode variar em diferentes famílias de modelos. A lógica de bloqueio (ou seja, limite de confiança) é baseada em avaliações rigorosas de cada modelo. Por isso, uma configuração de segurança aplicada a um modelo pode não corresponder perfeitamente ao comportamento de uma configuração de segurança aplicada a outro modelo. Se isso for uma preocupação, recomendamos que você configure sua própria lógica de bloqueio com pontuações de gravidade brutas e de confiança brutas, aplicando os mesmos limites de pontuação em todos os modelos.

Configurar limites

Python

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Para mais informações, consulte a documentação de referência da API Python.

import vertexai

from vertexai import generative_models

# Initialize Vertex AI
vertexai.init(project=project_id, location=location)

# Load the model
model = generative_models.GenerativeModel(model_name="gemini-1.0-pro-vision-001")

# Generation config
generation_config = generative_models.GenerationConfig(
    max_output_tokens=2048, temperature=0.4, top_p=1, top_k=32
)

# Safety config
safety_config = [
    generative_models.SafetySetting(
        category=generative_models.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
        threshold=generative_models.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    ),
    generative_models.SafetySetting(
        category=generative_models.HarmCategory.HARM_CATEGORY_HARASSMENT,
        threshold=generative_models.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    ),
]

# Generate content
responses = model.generate_content(
    [image, "Add your prompt here"],
    generation_config=generation_config,
    stream=True,
    safety_settings=safety_config,
)

text_responses = []
for response in responses:
    print(response.text)
    text_responses.append(response.text)

Node.js

Antes de testar essa amostra, siga as instruções de configuração para Node.js Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Node.js.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

const {
  VertexAI,
  HarmCategory,
  HarmBlockThreshold,
} = require('@google-cloud/vertexai');

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function setSafetySettings(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.0-pro-001'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  // Instantiate the model
  const generativeModel = vertexAI.getGenerativeModel({
    model: model,
    // The following parameters are optional
    // They can also be passed to individual content generation requests
    safety_settings: [
      {
        category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
        threshold: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
      },
    ],
    generation_config: {max_output_tokens: 256},
  });

  const request = {
    contents: [{role: 'user', parts: [{text: 'Tell me something dangerous.'}]}],
  };

  console.log('Prompt:');
  console.log(request.contents[0].parts[0].text);
  console.log('Streaming Response Text:');

  // Create the response stream
  const responseStream = await generativeModel.generateContentStream(request);

  // Log the text response as it streams
  for await (const item of responseStream.stream) {
    if (item.candidates[0].finishReason === 'SAFETY') {
      console.log('This response stream terminated due to safety concerns.');
      break;
    } else {
      process.stdout.write(item.candidates[0].content.parts[0].text);
    }
  }
}

Java

Antes de testar essa amostra, siga as instruções de configuração para Java Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Java.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.Candidate;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.api.GenerationConfig;
import com.google.cloud.vertexai.api.HarmCategory;
import com.google.cloud.vertexai.api.SafetySetting;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import java.util.Arrays;
import java.util.List;

public class WithSafetySettings {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.0-pro-vision";
    String textPrompt = "your-text-here";

    String output = safetyCheck(projectId, location, modelName, textPrompt);
    System.out.println(output);
  }

  // Use safety settings to avoid harmful questions and content generation.
  public static String safetyCheck(String projectId, String location, String modelName,
      String textPrompt) throws Exception {
    // Initialize client that will be used to send requests. This client only needs
    // to be created once, and can be reused for multiple requests.
    try (VertexAI vertexAI = new VertexAI(projectId, location)) {
      StringBuilder output = new StringBuilder();

      GenerationConfig generationConfig =
          GenerationConfig.newBuilder()
              .setMaxOutputTokens(2048)
              .setTemperature(0.4F)
              .setTopK(32)
              .setTopP(1)
              .build();

      GenerativeModel model = new GenerativeModel(modelName, generationConfig, vertexAI);

      List<SafetySetting> safetySettings = Arrays.asList(
          SafetySetting.newBuilder()
              .setCategory(HarmCategory.HARM_CATEGORY_HATE_SPEECH)
              .setThreshold(SafetySetting.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE)
              .build(),
          SafetySetting.newBuilder()
              .setCategory(HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT)
              .setThreshold(SafetySetting.HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE)
              .build()
      );

      GenerateContentResponse response = model.generateContent(
          textPrompt,
          safetySettings
      );
      output.append(response).append("\n");

      // Verifies if the above content has been blocked for safety reasons.
      boolean blockedForSafetyReason = response.getCandidatesList()
          .stream()
          .anyMatch(candidate -> candidate.getFinishReason() == Candidate.FinishReason.SAFETY);
      output.append("Blocked for safety reasons?: ").append(blockedForSafetyReason);

      return output.toString();
    }
  }
}

Go

Antes de testar essa amostra, siga as instruções de configuração para Go Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Go.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import (
	"context"
	"fmt"
	"io"
	"mime"
	"path/filepath"

	"cloud.google.com/go/vertexai/genai"
)

// generateMultimodalContent generates a response into w, based upon the prompt
// and image provided.
func generateMultimodalContent(w io.Writer, prompt, image, projectID, location, modelName string) error {
	// prompt := "describe this image."
	// location := "us-central1"
	// model := "gemini-1.0-pro-vision"
	// image := "gs://cloud-samples-data/generative-ai/image/320px-Felis_catus-cat_on_snow.jpg"
	ctx := context.Background()

	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		return fmt.Errorf("unable to create client: %v", err)
	}
	defer client.Close()

	model := client.GenerativeModel(modelName)
	model.SetTemperature(0.4)
	// configure the safety settings thresholds
	model.SafetySettings = []*genai.SafetySetting{
		{
			Category:  genai.HarmCategoryHarassment,
			Threshold: genai.HarmBlockLowAndAbove,
		},
		{
			Category:  genai.HarmCategoryDangerousContent,
			Threshold: genai.HarmBlockLowAndAbove,
		},
	}

	// Given an image file URL, prepare image file as genai.Part
	img := genai.FileData{
		MIMEType: mime.TypeByExtension(filepath.Ext(image)),
		FileURI:  image,
	}

	res, err := model.GenerateContent(ctx, img, genai.Text(prompt))
	if err != nil {
		return fmt.Errorf("unable to generate contents: %w", err)
	}

	fmt.Fprintf(w, "generated response: %s\n", res.Candidates[0].Content.Parts[0])
	return nil
}

C#

Antes de testar essa amostra, siga as instruções de configuração para C# Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para C#.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

using Google.Api.Gax.Grpc;
using Google.Cloud.AIPlatform.V1;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using static Google.Cloud.AIPlatform.V1.SafetySetting.Types;

public class WithSafetySettings
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.0-pro-vision"
    )
    {
        // Create client
        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        // Prompt
        string prompt = "Hello!";

        // Initialize request argument(s)
        var content = new Content
        {
            Role = "USER"
        };
        content.Parts.AddRange(new List<Part>()
        {
            new()
            {
                Text = prompt
            }
        });

        var safetySettings = new List<SafetySetting>()
        {
            new()
            {
                Category = HarmCategory.HateSpeech,
                Threshold = HarmBlockThreshold.BlockLowAndAbove
            },
            new()
            {
                Category = HarmCategory.DangerousContent,
                Threshold = HarmBlockThreshold.BlockMediumAndAbove
            }
        };

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            GenerationConfig = new GenerationConfig
            {
                Temperature = 0.4f,
                TopP = 1,
                TopK = 32,
                MaxOutputTokens = 2048
            },
        };
        generateContentRequest.Contents.Add(content);
        generateContentRequest.SafetySettings.AddRange(safetySettings);

        // Make the request, returning a streaming response
        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        // Read streaming responses from server until complete
        AsyncResponseStream<GenerateContentResponse> responseStream = response.GetResponseStream();
        await foreach (GenerateContentResponse responseItem in responseStream)
        {
            // Check if the content has been blocked for safety reasons.
            bool blockForSafetyReason = responseItem.Candidates[0].FinishReason == Candidate.Types.FinishReason.Safety;
            if (blockForSafetyReason)
            {
                fullText.Append("Blocked for safety reasons");
            }
            else
            {
                fullText.Append(responseItem.Candidates[0].Content.Parts[0].Text);
            }
        }

        return fullText.ToString();
    }
}

REST

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

• LOCATION: a região para processar a solicitação. As opções disponíveis incluem:

  Clique para expandir as regiões disponíveis

  • us-central1
  • us-west4
  • northamerica-northeast1
  • us-east4
  • us-west1
  • asia-northeast3
  • asia-southeast1
  • asia-northeast1
• PROJECT_ID: o ID do projeto.
• MODEL_ID: o ID do modelo multimodal que você quer usar. As opções são:
  • gemini-1.0-pro
  • gemini-1.0-pro-vision
• ROLE: o papel em uma conversa associada ao conteúdo. É necessário especificar um papel mesmo em casos de uso de turno único. Os valores aceitáveis são os seguintes:
  • USER: especifica o conteúdo que é enviado por você.
  • MODEL: especifica a resposta do modelo.
• TEXT: as instruções de texto a serem incluídas no comando.
• SAFETY_CATEGORY: a categoria de segurança para a qual configurar um limite. Os valores aceitáveis são os seguintes:

  Clique para expandir as categorias de segurança

  • HARM_CATEGORY_SEXUALLY_EXPLICIT
  • HARM_CATEGORY_HATE_SPEECH
  • HARM_CATEGORY_HARASSMENT
  • HARM_CATEGORY_DANGEROUS_CONTENT
• THRESHOLD: o limite de bloqueio de respostas que podem pertencer à categoria de segurança especificada com base na probabilidade. Os valores aceitáveis são os seguintes:

  Clique para expandir os limites de bloqueio

  • BLOCK_NONE
  • BLOCK_ONLY_HIGH
  • BLOCK_MEDIUM_AND_ABOVE (padrão)
  • BLOCK_LOW_AND_ABOVE
  BLOCK_LOW_AND_ABOVE bloqueia mais, e BLOCK_ONLY_HIGH bloqueia a menor.

Método HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:streamGenerateContent

Corpo JSON da solicitação:

{
  "contents": {
    "role": "ROLE",
    "parts": { "text": "TEXT" }
  },
  "safety_settings": {
    "category": "SAFETY_CATEGORY",
    "threshold": "THRESHOLD"
  },
}

Para enviar a solicitação, escolha uma destas opções:

curl

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:streamGenerateContent"

PowerShell

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:streamGenerateContent" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a seguinte.

Resposta

[{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "text": " The picture shows a table with a white tablecloth. On the table are two cups of coffee, a bowl of blueberries, and five scones with blueberries. There"
          }
        ]
      },
      "safetyRatings": [
        {
          "category": "HARM_CATEGORY_HARASSMENT",
          "probability": "NEGLIGIBLE"
        },
        {
          "category": "HARM_CATEGORY_HATE_SPEECH",
          "probability": "NEGLIGIBLE"
        },
        {
          "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
          "probability": "NEGLIGIBLE"
        },
        {
          "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
          "probability": "NEGLIGIBLE"
        }
      ]
    }
  ]
}
,
{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "text": " are also some pink flowers on the table. The background is a dark blue color. The picture is taken from a top-down perspective."
          }
        ]
      },
      "finishReason": "STOP",
      "safetyRatings": [
        {
          "category": "HARM_CATEGORY_HARASSMENT",
          "probability": "NEGLIGIBLE"
        },
        {
          "category": "HARM_CATEGORY_HATE_SPEECH",
          "probability": "NEGLIGIBLE"
        },
        {
          "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
          "probability": "NEGLIGIBLE"
        },
        {
          "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
          "probability": "NEGLIGIBLE"
        }
      ]
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 262,
    "candidatesTokenCount": 59,
    "totalTokenCount": 321
  }
}

Exemplo de comando curl

LOCATION="us-central1"
MODEL_ID="gemini-1.0-pro"
PROJECT_ID="test-project"

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:streamGenerateContent -d \
$'{
  "contents": {
    "role": "user",
    "parts": { "text": "Hello!" }
  },
  "safety_settings": [
    {
      "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
      "threshold": "BLOCK_NONE"
    },
    {
      "category": "HARM_CATEGORY_HATE_SPEECH",
      "threshold": "BLOCK_LOW_AND_ABOVE"
    },
    {
      "category": "HARM_CATEGORY_HARASSMENT",
      "threshold": "BLOCK_MEDIUM_AND_ABOVE"
    },
    {
      "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
      "threshold": "BLOCK_ONLY_HIGH"
    }
  ]
}'

Console

1. Na seção "Vertex AI" do console do Google Cloud, acesse a página do Vertex AI Studio.

   Acessar o Vertex AI Studio

2. Em Criar um novo comando, clique em qualquer um dos botões para abrir a página de criação de comandos.

3. Clique em Configurações de segurança.

   A caixa de diálogo Configurações de segurança é aberta.

4. Para cada atributo de segurança, configure o valor limite desejado.

5. Clique em Save.

A seguir

• Saiba mais sobre a IA responsável.
• Saiba mais sobre governança de dados.