Sicherheitsattribute konfigurieren

Die Vertex AI Gemini API blockiert unsichere Inhalte anhand einer Liste von Sicherheitsattributen und ihren konfigurierten Grenzwerten für die Blockierung. Auf dieser Seite werden wichtige Sicherheitskonzepte beschrieben. Außerdem erfahren Sie, wie Sie die Schwellenwerte für die Blockierung von jedem Sicherheitsattribut konfigurieren, um zu steuern, wie oft Aufforderungen und Antworten blockiert werden.

Konfidenzbewertung für Sicherheitsattribute

Über die Vertex AI Gemini API verarbeitete Inhalte werden anhand einer Liste von Sicherheitsattributen bewertet, die „schädliche Kategorien“ und Themen enthalten, die als sensitiv eingestuft werden können. Diese Sicherheitsattribute sind in der folgenden Tabelle aufgeführt:

Definitionen der Sicherheitsattribute

Sicherheitsattribut Definition
Hassrede Negative oder schädliche Kommentare, die auf Identität und/oder geschützte Merkmale ausgerichtet sind
Belästigung Böswillige, einschüchternde, mobbende oder missbräuchliche Kommentare, die auf andere Personen ausgerichtet sind
sexuell explizit Enthält Verweise auf sexuelle Handlungen oder andere vulgäre Inhalte
Gefährliche Inhalte Fördert oder ermöglicht den Zugriff auf schädliche Waren, Dienste und Aktivitäten

Wahrscheinlichkeiten für Sicherheitsattribute

Jedem Sicherheitsattribut ist ein Konfidenzwert zwischen 0,0 und 1,0 zugeordnet, gerundet auf eine Dezimalstelle. Dieser Wert gibt die Wahrscheinlichkeit an, mit der eine Eingabe oder Antwort zu einer bestimmten Kategorie gehört.

Der Konfidenzwert in der folgenden Tabelle wird mit einem Sicherheitskonfidenzniveau zurückgegeben:

Wahrscheinlichkeit Beschreibung
Vernachlässigbar Inhalte haben eine vernachlässigbare Wahrscheinlichkeit, unsicher zu sein
NIEDRIG Inhalte haben eine geringe Wahrscheinlichkeit, unsicher zu sein
MITTEL Inhalte haben eine mittlere Wahrscheinlichkeit, unsicher zu sein
HOCH Inhalte haben eine hohe Wahrscheinlichkeit, unsicher zu sein

Schweregrad des Sicherheitsattributs

Jedem der vier Sicherheitsattribute wird eine Sicherheitsbewertung (Schweregrad) und ein Schweregrad zwischen 0,0 und 1,0 zugewiesen, gerundet auf eine Dezimalstelle. Die Bewertungen in der folgenden Tabelle spiegeln den vorhergesagten Schweregrad der Inhalte wider, die zu einer bestimmten Kategorie gehören:

Schweregrad Beschreibung
Vernachlässigbar Der Schweregrad der Inhalte wird in Bezug auf die Sicherheitsrichtlinien von Google als vernachlässigbar vorhergesagt.
NIEDRIG Der Schweregrad der Inhalte wird in Bezug auf die Sicherheitsrichtlinien von Google als niedrig vorhergesagt.
MITTEL Der Schweregrad des Inhalts wird in Bezug auf die Sicherheitsrichtlinien von Google als mittel vorhergesagt.
HOCH Der Schweregrad der Inhalte wird in Bezug auf die Sicherheitsrichtlinien von Google als hoch vorhergesagt.

Sicherheits­einstellungen

Sicherheitseinstellungen sind Teil der Anfrage, die Sie an den API-Dienst senden. Sie können für jede Anfrage an die API angepasst werden. In der folgenden Tabelle werden die Blockierungseinstellungen beschrieben, die Sie für jede Kategorie anpassen können. Wenn Sie beispielsweise die Blockierungseinstellung für die Kategorie Gefährliche Inhalte auf Wenige blockieren setzen, werden alle Inhalte blockiert, die mit hoher Wahrscheinlichkeit gefährliche Inhalte enthalten. Alles mit einer geringeren Wahrscheinlichkeit ist aber zulässig. Wenn nichts festgelegt ist, wird die Standardeinstellung Einige blockieren verwendet.

Grenzwert (Studio) Grenzwert (API) Grenzwert (Beschreibung)
BLOCK_NONE (Eingeschränkt) Wird unabhängig von der Wahrscheinlichkeit unsicherer Inhalte immer angezeigt.
Wenige blockieren BLOCK_ONLY_HIGH Blockieren, wenn die Wahrscheinlichkeit von unsicheren Inhalten hoch ist.
Einige blockieren (Standard) BLOCK_MEDIUM_AND_ABOVE (Standard) Blockieren, wenn die Wahrscheinlichkeit von unsicheren Inhalten mit mittlerer oder hoher Wahrscheinlichkeit ist.
Meiste blockieren BLOCK_LOW_AND_ABOVE Blockieren, wenn die Wahrscheinlichkeit von unsicheren Inhalten mit mittlerer oder hoher Wahrscheinlichkeit ist.
HARM_BLOCK_THRESHOLD_UNSPECIFIED Der Grenzwert ist nicht angegeben, nach dem Standardschwellenwert blockieren.

Sie können diese Einstellungen für jede Anfrage an den Textdienst ändern. Weitere Informationen finden Sie in der API-Referenz zu HarmBlockThreshold.

So entfernen Sie die automatische Antwortblockierung für ausgewählte Sicherheitsattribute

Die Sicherheitseinstellung „BLOCK_NONE“ entfernt die automatische Antwortblockierung (für die Sicherheitsattribute, die unter „Sicherheitseinstellungen“ beschrieben werden) und ermöglichen Ihnen, Ihre eigenen Sicherheitsrichtlinien mit den zurückgegebenen Werten zu konfigurieren. Für den Zugriff auf die Einstellung „BLOCK_NONE“ haben Sie zwei Möglichkeiten:

(1) Sie können die Zulassungsliste über das Formular zur Zulassungsliste für Gemini-Sicherheitsfilter beantragen.

(2) Sie können Ihren Kontotyp über die Referenz für die Rechnungsstellung für die GCP auf monatliche Rechnungsstellung umstellen.

Hauptunterschiede zwischen Gemini und anderen Modellfamilien

Während dieselben Sicherheitsklassifikatoren auf Gemini und PaLM angewendet werden, kann die Anzahl der in der API zurückgegebenen Sicherheitsattribute je nach Modellfamilie variieren. Die Blockierungslogik, also der Konfidenzschwellenwert, basiert auf einer strengen Bewertung jedes Modells. Daher entspricht eine Sicherheitseinstellung, die auf ein Modell angewendet wird, möglicherweise nicht perfekt dem Verhalten einer Sicherheitseinstellung, die auf ein anderes Modell angewendet wird. Wenn dies ein Problem darstellt, empfehlen wir Ihnen, eine eigene Blockierlogik mit Rohschweregradwerten und Rohkonfidenzwerten zu konfigurieren und dabei dieselben Bewertungsgrenzwerte auf alle Modelle anzuwenden.

Grenzwerte konfigurieren

Python

Informationen zum Installieren oder Aktualisieren von Python finden Sie unter Vertex AI SDK für Python installieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Python API. 

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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Node.js-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Node.js API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Java-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Java API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Go-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Go API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

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#

Bevor Sie dieses Beispiel anwenden, folgen Sie den C#-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI C# API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


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

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION: Die Region, in der die Anfrage verarbeitet werden soll. Folgende Optionen sind verfügbar:

    Klicken, um verfügbare Regionen zu maximieren

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • PROJECT_ID: Ihre Projekt-ID.
  • MODEL_ID: Die Modell-ID des multimodalen Modells, das Sie verwenden möchten. Folgende Optionen sind verfügbar:
    • gemini-1.0-pro
    • gemini-1.0-pro-vision
  • ROLE: Die Rolle in einer Unterhaltung, die mit dem Inhalt verknüpft ist. Die Angabe einer Rolle ist auch bei Anwendungsfällen mit nur einem Schritt erforderlich. Unter anderem sind folgende Werte zulässig:
    • USER: Gibt Inhalte an, die von Ihnen gesendet werden
    • MODEL: Gibt die Antwort des Modells an.
  • TEXT: Die Textanleitung, die in den Prompt eingefügt werden soll.
  • SAFETY_CATEGORY: Die Sicherheitskategorie, für die ein Schwellenwert konfiguriert wird. Unter anderem sind folgende Werte zulässig:

    Zum Maximieren von Sicherheitskategorien klicken

    • HARM_CATEGORY_SEXUALLY_EXPLICIT
    • HARM_CATEGORY_HATE_SPEECH
    • HARM_CATEGORY_HARASSMENT
    • HARM_CATEGORY_DANGEROUS_CONTENT
  • THRESHOLD: Der Schwellenwert für das Blockieren von Antworten, die basierend auf der Wahrscheinlichkeit zur angegebenen Sicherheitskategorie gehören könnten. Unter anderem sind folgende Werte zulässig:

    Zum Maximieren der Grenzwerte für die Blockierung klicken

    • BLOCK_NONE
    • BLOCK_ONLY_HIGH
    • BLOCK_MEDIUM_AND_ABOVE (Standard)
    • BLOCK_LOW_AND_ABOVE
     BLOCK_LOW_AND_ABOVE blockiert am meisten, während BLOCK_ONLY_HIGH am wenigsten blockiert.

HTTP-Methode und URL:

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

JSON-Text der Anfrage:

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

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

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

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

$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

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

Beispiel: cURL-Befehls

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. Rufen Sie im Bereich „Vertex AI“ der Google Cloud Console die Seite Vertex AI Studio auf.

    Zu Vertex AI Studio

  2. Klicken Sie unter Neuen Prompt erstellen auf eine der Schaltflächen, um die Seite zum Prompt-Design zu öffnen.

  3. Klicken Sie auf Sicherheitseinstellungen.

    Das Dialogfeld Sicherheitseinstellungen wird geöffnet.

  4. Konfigurieren Sie für jedes Sicherheitsattribut den gewünschten Grenzwert.

  5. Klicken Sie auf Speichern.

Nächste Schritte