Configurer les attributs de sécurité

L'API Vertex AI Gemini bloque le contenu non sécurisé en fonction d'une liste d'attributs de sécurité et des seuils de blocage associés configurés. Cette page décrit les concepts clés de la sécurité et vous explique comment configurer les seuils de blocage de chaque attribut de sécurité afin de contrôler la fréquence à laquelle les invites et les réponses sont bloquées.

Score de confiance de l'attribut de sécurité

Le contenu traité via l'API Vertex AI Gemini est évalué en fonction d'une liste d'attributs de sécurité, qui incluent les "catégories dangereuses" et les sujets pouvant être considérés comme sensibles. Ces attributs de sécurité sont indiqués dans le tableau suivant :

Définitions des attributs de sécurité

Attribut de sécurité Définition
Incitation à la haine Commentaires négatifs ou offensants ciblant l'identité et/ou les attributs protégés.
Harcèlement Commentaires malveillants, intimidants ou abusifs ciblant une autre personne.
Contenu à caractère sexuel explicite Contient des références à des actes sexuels ou à d'autres contenus obscènes.
Contenu dangereux Encourage ou facilite l'accès à des activités, produits et services dangereux.

Probabilités d'attribut de sécurité

Chaque attribut de sécurité est associé à un score de confiance compris entre 0,0 et 1,0, arrondi à une décimale. Il reflète la probabilité que l'entrée ou la réponse appartienne à une catégorie donnée.

Le score de confiance présenté dans le tableau suivant est renvoyé avec un niveau de confiance :

Probabilité Description
Négligeable Le contenu présente une probabilité négligeable d'être non sécurisé.
FAIBLE Le contenu présente une probabilité faible d'être non sécurisé.
MOYENNE Le contenu présente une probabilité moyenne d'être non sécurisé
ÉLEVÉ Le contenu présente une probabilité élevée d'être non sécurisé

Gravité des attributs de sécurité

Chacun des quatre attributs de sécurité se voit attribuer un score de sécurité (niveau de gravité) et un score de gravité compris entre 0,0 et 1,0, arrondis à une décimale. Les notes et les scores du tableau suivant reflètent la gravité prévue du contenu appartenant à une catégorie donnée :

Gravité Description
Négligeable Le niveau de gravité du contenu est prédit comme négligeable conformément aux règles de sécurité de Google.
FAIBLE Le niveau de gravité du contenu est prédit comme faible conformément aux règles de sécurité de Google.
MOYENNE Le niveau de gravité du contenu est prédit comme moyen conformément aux règles de sécurité de Google.
ÉLEVÉ Le niveau de gravité du contenu est prédit comme élevé conformément aux règles de sécurité de Google.

Paramètres de sécurité

Les paramètres de sécurité font partie de la requête que vous envoyez au service d'API. Il peut être ajusté pour chaque requête que vous envoyez à l'API. Le tableau suivant décrit les paramètres de blocage que vous pouvez ajuster pour chaque catégorie. Par exemple, si vous définissez le paramètre de blocage sur Bloquer peu pour la catégorie de contenu dangereux, tous les éléments susceptibles d'être des contenus dangereux sont bloqués. Cependant, toute valeur plus faible est autorisée. Si ce champ n'est pas spécifié, le paramètre de blocage par défaut est Bloquer certains.

Seuil (Studio) Seuil (API) Seuil (description)
BLOCK_NONE (Limité) Toujours afficher, quelle que soit la probabilité que le contenu soit non sécurisé.
Bloquer quelques éléments BLOCK_ONLY_HIGH Bloquer lorsque la probabilité d'un contenu non sécurisé est élevée.
Bloquer une partie (par défaut) BLOCK_MEDIUM_AND_ABOVE (par défaut) Bloquer lorsque la probabilité d'un contenu non sécurisé est moyenne ou élevée.
Bloquer la plupart des éléments BLOCK_LOW_AND_ABOVE Bloquer lorsque la probabilité d'un contenu non sécurisé est moyenne ou élevée.
HARM_BLOCK_THRESHOLD_UNSPECIFIED Le seuil n'est pas spécifié. Le blocage est effectué selon le seuil par défaut.

Vous pouvez modifier ces paramètres pour chaque requête envoyée au service texte. Pour plus d'informations, consultez la documentation de référence de l'API HarmBlockThreshold.

Supprimer le blocage des réponses automatiques pour certains attributs de sécurité

Le paramètre de sécurité "BLOCK_NONE" supprime le blocage automatique des réponses (pour les attributs de sécurité décrits sous "Paramètres de sécurité") et vous permet de configurer vos propres consignes de sécurité avec les scores qui vous sont renvoyés. Pour accéder au paramètre "BLOCK_NONE", vous disposez de deux options :

(1) Vous pouvez demander l'inscription à la liste d'autorisation via le formulaire de liste d'autorisation de filtrage de sécurité Gemini.

(2) Vous pouvez basculer vers un type de compte avec paiement sur facture mensuelle à l'aide de la documentation de référence sur la facturation avec paiement sur facture mensuelle GCP.

Principales différences entre Gemini et les autres familles de modèles

Bien que les mêmes classificateurs de sécurité soient appliqués à Gemini et PaLM, le nombre d'attributs de sécurité renvoyés dans l'API peut varier selon les familles de modèles. La logique de blocage (seuil de confiance) est basée sur une évaluation rigoureuse de chaque modèle. Par conséquent, un paramètre de sécurité appliqué à un modèle peut ne pas correspondre parfaitement au comportement d'un paramètre de sécurité appliqué à un autre modèle. Si cela pose problème, nous vous recommandons de configurer votre propre logique de blocage avec des scores de gravité et des scores de confiance bruts, en appliquant les mêmes seuils de score à tous les modèles.

Configurer les seuils

Python

Pour savoir comment installer ou mettre à jour le SDK pour Python, consultez la page Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API Python. 

from vertexai import generative_models

def generate_text(project_id: str, location: str, image: str) -> str:
    # Initialize Vertex AI
    vertexai.init(project=project_id, location=location)

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

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

    # Safety config
    safety_config = {
        generative_models.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: generative_models.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
        generative_models.HarmCategory.HARM_CATEGORY_HARASSMENT: generative_models.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    }

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

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

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Node.js.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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'
) {
  // 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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Java.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Go.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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#

Avant d'essayer cet exemple, suivez les instructions de configuration pour C# décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI C#.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

  • LOCATION : région dans laquelle traiter la requête. Les options disponibles sont les suivantes :

    Cliquer pour développer les régions disponibles

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • PROJECT_ID : l'ID de votre projet.
  • MODEL_ID : ID du modèle multimodal que vous souhaitez utiliser. Vous disposez des options suivantes :
    • gemini-1.0-pro
    • gemini-1.0-pro-vision
  • ROLE : rôle dans une conversation associée au contenu. La spécification d'un rôle est requise, même dans les cas d'utilisation à un seul tour. Les valeurs acceptées incluent les suivantes :
    • USER : spécifie le contenu envoyé par vous.
    • MODEL : spécifie la réponse du modèle.
  • TEXT : instructions textuelles à inclure dans l'invite.
  • SAFETY_CATEGORY : catégorie de sécurité pour laquelle configurer un seuil. Les valeurs acceptées incluent les suivantes :

    Cliquer pour développer les catégories de sécurité

    • HARM_CATEGORY_SEXUALLY_EXPLICIT
    • HARM_CATEGORY_HATE_SPEECH
    • HARM_CATEGORY_HARASSMENT
    • HARM_CATEGORY_DANGEROUS_CONTENT
  • THRESHOLD : seuil de blocage des réponses susceptibles d'appartenir à la catégorie de sécurité spécifiée en fonction de la probabilité. Les valeurs acceptées incluent les suivantes :

    Cliquer pour développer les seuils de blocage

    • BLOCK_NONE
    • BLOCK_ONLY_HIGH
    • BLOCK_MEDIUM_AND_ABOVE (par défaut)
    • BLOCK_LOW_AND_ABOVE
     BLOCK_LOW_AND_ABOVE bloque le plus, tandis que BLOCK_ONLY_HIGH bloque le moins.

Méthode HTTP et URL :

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

Corps JSON de la requête : 

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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

Vous devriez recevoir une réponse JSON semblable à la suivante.

Exemple de commande 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. Dans la section "Vertex AI" de la console Google Cloud, accédez à la page Vertex AI Studio.

    Accéder à Vertex AI Studio

  2. Sous Créer une requête, cliquez sur l'un des boutons pour ouvrir la page de conception d'invite.

  3. Cliquez sur Paramètres de sécurité.

    La boîte de dialogue Paramètres de sécurité s'affiche.

  4. Pour chaque attribut de sécurité, configurez la valeur de seuil souhaitée.

  5. Cliquez sur Enregistrer.

Étapes suivantes