Configurar atributos de segurança

Modelos de linguagem grandes (LLM) podem gerar resultados inesperados, incluindo texto ofensivo, insensível ou incorreto. Para manter a segurança e evitar o uso indevido, o Gemini usa filtros de segurança para bloquear comandos e respostas que ele considera potencialmente perigosas.

Esta página descreve cada um dos tipos de filtro e descreve os principais conceitos de segurança. Para filtros configuráveis, ele mostra como configurar os limites de bloqueio de cada atributo de segurança para controlar com que frequência os comandos e respostas são bloqueados.

Os filtros de segurança funcionam como uma barreira, evitando resultados nocivos, mas não influenciam diretamente o comportamento do modelo. Para saber mais sobre a direção de modelos, consulte Instruções do sistema.

Comandos não seguros

A API Vertex AI Gemini fornece um dos seguintes códigos enum para explicar o motivo da rejeição de um comando:

Enum Tipo de filtro Descrição
PROHIBITED_CONTENT Filtro de segurança não configurável A solicitação foi bloqueada porque foi sinalizada por conter conteúdo proibido, geralmente material de abuso sexual infantil.
BLOCKED_REASON_UNSPECIFIED N/A O motivo para bloquear o comando não foi especificado.
OUTROS N/A Esse tipo enumerado se refere a todos os outros motivos para bloquear um comando. A API Vertex AI Gemini não é compatível com todos os idiomas. Para uma lista de idiomas compatíveis, consulte Compatibilidade com idiomas do Gemini.

Para saber mais, consulte BlockedReason.

Este é um exemplo de saída da API Vertex AI Gemini quando um comando é bloqueado por conter PROHIBITED_CONTENT:

{
  "promptFeedback": {
    "blockReason": "PROHIBITED_CONTENT"
  },
  "usageMetadata": {
    "promptTokenCount": 7,
    "totalTokenCount": 7
  }
}

Respostas não seguras

Para determinar quais respostas são potencialmente inseguras, a API Vertex AI Gemini usa os filtros a seguir:

  • Filtros de segurança não configuráveis, que bloqueiam material de abuso sexual infantil (CSAM) e informações de identificação pessoal (PII).
  • Filtros de segurança configuráveis, que bloqueiam conteúdo não seguro com base em uma lista de atributos de segurança e os limites de bloqueio configurados pelo usuário. Você pode configurar limites de bloqueio para cada um desses atributos com base no que é apropriado para seu caso de uso e negócios. Para saber mais, consulte Filtros de segurança configuráveis.
  • Filtros de citação, que evitam o uso indevido e garantem a citação correta de dados protegidos por direitos autorais. Para saber mais, consulte Filtro de citação.

Um LLM gera respostas em unidades de texto chamadas tokens. Um modelo interrompe a geração tokens porque ele chega a um ponto de parada natural ou porque um dos filtros bloqueia a resposta. A API Vertex AI Gemini fornece um dos códigos enum a seguir para explicar por que a geração de token foi interrompida:

Enum Tipo de filtro Descrição
PARAR N/A Esse tipo enumerado indica que o modelo atingiu um ponto de parada natural ou a sequência de parada fornecida.
MAX_TOKENS N/A A geração de tokens foi interrompida porque o modelo atingiu o número máximo de tokens especificado na solicitação.
SAFETY Filtro de segurança configurável A geração de tokens foi interrompida porque a resposta foi sinalizada por motivos de segurança.
RECITATION Filtro de citações A geração de tokens foi interrompida porque a resposta foi sinalizada por citações não autorizadas.
SPII Filtro de segurança não configurável A geração de tokens foi interrompida porque a resposta foi sinalizada por conteúdo com informações sensíveis de identificação pessoal (SPII).
PROHIBITED_CONTENT Filtro de segurança não configurável A geração de tokens foi interrompida porque a resposta foi sinalizada por conter conteúdo proibido, geralmente material de abuso sexual infantil.
FINISH_REASON_UNSPECIFIED N/A O motivo da finalização não foi especificado.
OUTROS N/A Esse tipo enumerado refere-se a todos os outros motivos que interrompem a geração de tokens. Observe que a geração de tokens não é compatível com todos os idiomas. Para uma lista de idiomas compatíveis, consulte Compatibilidade com idiomas do Gemini.

Para saber mais, consulte FinishReason.

Se um filtro bloquear a resposta, ele anulará o campo Candidate.content da resposta. Ele não fornece feedback ao modelo.

Filtros de segurança configuráveis

O Gemini avalia o conteúdo com base em uma lista de atributos de segurança, que incluem categorias e temas nocivos que podem ser considerados sensíveis. Para cada atributo, a API Vertex AI Gemini atribui uma pontuação de segurança com base na probabilidade do conteúdo ser inseguro e outra pontuação de segurança com base na gravidade do conteúdo nocivo.

O filtro de segurança configurável não tem controle de versões independente do modelo. O Google não atualiza o filtro de segurança configurável para uma versão lançada anteriormente de um modelo. No entanto, é possível que atualize o filtro de segurança configurável para uma versão futura de um modelo.

Atributos de segurança

O Gemini avalia o conteúdo com base nos seguintes atributos 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.

Comparação de pontuações de probabilidade e de gravidade

O atributo de segurança probability reflete a probabilidade da resposta de um modelo estar associada ao respectivo atributo de segurança. Ele tem pontuação de confiança associada entre 0.0 e 1.0, arredondada para uma casa decimal. A pontuação de confiança é criterizada em quatro níveis de confiança de segurança: NEGLIGIBLE, LOW, MEDIUM e HIGH.

O atributo de segurança severity reflete a magnitude de quão prejudicial a resposta de um modelo pode ser. Ele tem uma pontuação de gravidade associada que vai de 0.0 para 1.0, arredondada para uma casa decimal. A pontuação de gravidade é criterizada em quatro níveis: NEGLIGIBLE, LOW, MEDIUM e HIGH.

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.

Como configurar o filtro de segurança

Use a API Vertex AI Gemini ou o console do Google Cloud para configurar o filtro de segurança.

API Gemini da Vertex AI

A API Vertex AI Gemini fornece dois "bloqueios de dano", métodos:

  • SEVERITY: esse método usa pontuações de probabilidade e gravidade.
  • PROBABILITY: esse método usa apenas a pontuação de probabilidade.

O método padrão é PROBABILITY. Para saber mais, consulte a referência da API HarmBlockMethod.

A API Vertex AI Gemini fornece os seguintes limites de "bloqueio de dano":

  • BLOCK_LOW_AND_ABOVE: bloqueia quando a pontuação de probabilidade ou de gravidade é LOW, MEDIUM ou HIGH.
  • BLOCK_MEDIUM_AND_ABOVE: bloqueia quando a pontuação de probabilidade ou de gravidade é MEDIUM ou HIGH.
  • BLOCK_ONLY_HIGH: bloqueia quando a pontuação de probabilidade ou de gravidade é HIGH.
  • HARM_BLOCK_THRESHOLD_UNSPECIFIED: bloqueia usando o limite padrão.
  • BLOCK_NONE (restrito): a configuração de segurança de BLOCK_NONE remove o bloqueio automático de respostas e permite que você configure suas próprias diretrizes de segurança com as pontuações retornadas. Este é um campo restrito que não está disponível para todos os usuários nas versões de modelo do GA. BLOCK_NONE não é compatível com entrada de áudio e vídeo quando você estiver usando o Gemini 1.5 Flash ou o Gemini 1.5 Pro.

Para acessar a configuração BLOCK_NONE, você pode:

  1. Inscreva-se na lista de permissões usando o formulário de lista de permissões de filtro de segurança do Genmini.
  2. Mude seu tipo de conta para faturamento mensal com a referência de cobrança por fatura do Google Cloud.

O limite padrão é BLOCK_MEDIUM_AND_ABOVE. Para saber mais, consulte a referência da API HarmBlockThreshold.

Por exemplo, o código Python a seguir demonstra como é possível configurar o método de bloqueio de danos para SEVERITY e o limite de bloqueio para BLOCK_LOW_AND_ABOVE para a categoria de conteúdo perigoso:

generative_models.SafetySetting(
        category=generative_models.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
        method=generative_models.HarmBlockMethod.SEVERITY,
        threshold=generative_models.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    ),

Isso vai bloquear a maior parte do conteúdo classificado como perigoso.

Para conferir exemplos completos em Python, Node.js, Java, Go, C# e REST, consulte os Exemplos de configuração do filtro de segurança.

Console do Google Cloud

O console do Google Cloud permite configurar um limite para cada atributo de segurança. O filtro de segurança usa apenas as pontuações de probabilidade. Não há a opção de usar as pontuações de gravidade.

O console do Google Cloud fornece os seguintes valores de limite:

  • Bloquear poucos: bloquear quando a pontuação de probabilidade for HIGH.
  • Bloquear alguns: bloquear quando a pontuação de probabilidade for MEDIUM ou HIGH.
  • Bloquear muitos: bloquear quando a pontuação de probabilidade for LOW, MEDIUM ou HIGH.

Por exemplo, se você definir a configuração de bloqueio como Bloquear poucos na categoria "Conteúdos perigosos", tudo com alta probabilidade de ser um conteúdo nocivo será bloqueado. Qualquer item com menor probabilidade de risco é permitido. O limite padrão é Block some.

Para definir os limites, consulte as seguintes etapas:

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

Exemplo de saída quando uma resposta é bloqueada pelo filtro de segurança configurável

Este é um exemplo de saída da API Vertex AI Gemini quando uma resposta é bloqueada pelo filtro de segurança configurável por conter conteúdo perigoso:

{
  "candidates": [{
    "finishReason": "SAFETY",
    "safetyRatings": [{
      "category": "HARM_CATEGORY_HATE_SPEECH",
      "probability": "NEGLIGIBLE",
      "probabilityScore": 0.11027937,
      "severity": "HARM_SEVERITY_LOW",
      "severityScore": 0.28487435
    }, {
      "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
      "probability": "HIGH",
      "blocked": true,
      "probabilityScore": 0.95422274,
      "severity": "HARM_SEVERITY_MEDIUM",
      "severityScore": 0.43398145
    }, {
      "category": "HARM_CATEGORY_HARASSMENT",
      "probability": "NEGLIGIBLE",
      "probabilityScore": 0.11085559,
      "severity": "HARM_SEVERITY_NEGLIGIBLE",
      "severityScore": 0.19027223
    }, {
      "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
      "probability": "NEGLIGIBLE",
      "probabilityScore": 0.22901751,
      "severity": "HARM_SEVERITY_NEGLIGIBLE",
      "severityScore": 0.09089675
    }]
  }],
  "usageMetadata": {
    "promptTokenCount": 38,
    "totalTokenCount": 38
  }
}

Exemplos de configuração do filtro de segurança

Os exemplos a seguir demonstram como configurar o filtro de segurança usando a API Vertex AI Gemini:

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

# TODO(developer): Update and un-comment below line
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

model = generative_models.GenerativeModel(model_name="gemini-1.5-flash-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,
    ),
]

image_file = Part.from_uri(
    "gs://cloud-samples-data/generative-ai/image/scones.jpg", "image/jpeg"
)

# Generate content
responses = model.generate_content(
    [image_file, "What is in this image?"],
    generation_config=generation_config,
    safety_settings=safety_config,
    stream=True,
)

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.5-flash-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,
      temperature: 0.4,
      top_p: 1,
      top_k: 16,
    },
  });

  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);
    }
  }
  console.log('This response stream terminated due to safety concerns.');
}

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.5-flash-001";
    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();

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

      GenerativeModel model = new GenerativeModel(modelName, vertexAI)
          .withGenerationConfig(generationConfig)
          .withSafetySettings(safetySettings);

      GenerateContentResponse response = model.generateContent(textPrompt);
      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.5-flash-001"
	// 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: %w", 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.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.5-flash-001"
    )
    {
        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();


        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = "Hello!" }
                    }
                }
            },
            SafetySettings =
            {
                new SafetySetting
                {
                    Category = HarmCategory.HateSpeech,
                    Threshold = HarmBlockThreshold.BlockLowAndAbove
                },
                new SafetySetting
                {
                    Category = HarmCategory.DangerousContent,
                    Threshold = HarmBlockThreshold.BlockMediumAndAbove
                }
            }
        };

        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        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

Depois de configurou seu ambiente use REST para testar uma solicitação de texto. O exemplo a seguir envia uma solicitação ao publisher endpoint do modelo.

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:

    Clicar para abrir uma lista parcial das 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

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

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.

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"
    }
  ]
}'

Filtro de citações

Os recursos de código generativo da Vertex AI têm como objetivo produzir conteúdo original. Por padrão, o Gemini limita a probabilidade de que o conteúdo atual seja replicado extensamente. Se um recurso do Gemini fizer uma citação extensa de uma página da Web, o Gemini cita essa página.

Às vezes, o mesmo conteúdo pode ser encontrado em várias páginas da Web. O Gemini tenta apontar para uma fonte conhecida. No caso de citações de repositórios de código, a citação também pode referenciar uma licença de código aberto aplicável. É sua responsabilidade obedecer aos requisitos de licença.

Para saber mais sobre os metadados do filtro de citações, consulte a referência da API Citation.

A seguir