Sicherheitsattribute konfigurieren

Large Language Models (LLM) können unerwartete Ausgaben generieren, einschließlich Text, der beleidigend, grob oder tatsächlich falsch ist. Zur Wahrung der Sicherheit und zur Vermeidung von Missbrauch verwendet Gemini Sicherheitsfilter, um Aufforderungen und Antworten zu blockieren, die als potenziell schädlich eingestuft werden.

Auf dieser Seite werden die einzelnen Filtertypen und wichtige Sicherheitskonzepte beschrieben. Bei konfigurierbaren Filtern erfahren Sie, wie Sie die Grenzwerte für die Blockierung von jedem Sicherheitsattribut konfigurieren, um zu steuern, wie oft Prompts und Antworten blockiert werden.

Sicherheitsfilter dienen als Hürde und verhindern schädliche Ausgaben, beeinflussen aber nicht direkt das Verhalten des Modells. Weitere Informationen zur Modellsteuerung finden Sie in der Systemanleitung.

Unsichere Prompts

Die Vertex AI Gemini API bietet einen der folgenden enum-Codes, um zu erklären, warum ein Prompt abgelehnt wurde:

Enum Filtertyp Beschreibung
PROHIBITED_CONTENT Nicht konfigurierbarer Sicherheitsfilter Der Prompt wurde blockiert, da er unzulässige Inhalte enthält, in der Regel Darstellungen des sexuellen Missbrauchs von Kindern.
BLOCKED_REASON_UNSPECIFIED – Es wurde kein Grund für das Blockieren des Prompts angegeben.
ANDERE – Diese Aufzählung bezieht sich auf alle anderen Gründe für das Blockieren eines Prompts. Beachten Sie, dass die Vertex AI Gemini API nicht alle Sprachen unterstützt. Eine Liste der unterstützten Sprachen finden Sie unter Gemini-Sprachunterstützung.

Weitere Informationen finden Sie unter BlockedReason.

Das folgende Beispiel zeigt ein Beispiel für die Ausgabe der Vertex AI Gemini API, wenn ein Prompt blockiert ist, da sie PROHIBITED_CONTENT enthalten:

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

Unsichere Antworten

Die Vertex AI Gemini API verwendet die folgenden Filter, um zu ermitteln, welche Antworten potenziell unsicher sind:

  • Nicht konfigurierbare Sicherheitsfilter, die den sexuellen Missbrauch von Kindern (CSAM) und personenidentifizierbare Informationen blockieren.
  • Konfigurierbare Sicherheitsfilter, die unsichere Inhalte anhand einer Liste von Sicherheitsattributen und ihren vom Nutzer konfigurierten Grenzwerten für die Blockierung blockieren. Sie können Blockiergrenzwerte für jedes dieser Attribute basierend auf dem konfigurieren, was für Ihren Anwendungsfall und Ihr Geschäft geeignet ist. Weitere Informationen finden Sie unter Konfigurierbare Sicherheitsfilter.
  • Zitationsfilter, die Missbrauch verhindern und dafür sorgen, dass urheberrechtlich geschützte Daten ordnungsgemäß zitiert werden. Weitere Informationen finden Sie unter Zitatefilter.

Ein LLM generiert Antworten in Texteinheiten, die als Tokens bezeichnet werden. Ein Modell sendet keine Tokens mehr, da es einen natürlichen Stopp erreicht oder einer der Filter die Antwort blockiert. Vertex AI Gemini API stellt einen der folgenden enum-Codes bereit, um zu erklären, warum die Tokengenerierung gestoppt wurde:

Enum Filtertyp Beschreibung
STOP – Dieser enum-Wert gibt an, dass das Modell einen natürlichen Stopppunkt oder die angegebene Stoppsequenz erreicht hat.
MAX_TOKENS – Die Tokengenerierung wurde gestoppt, da das Modell die maximale Anzahl von Tokens erreicht hat, die in der Anfrage angegeben wurde.
SAFETY Konfigurierbarer Sicherheitsfilter Die Tokengenerierung wurde gestoppt, da die Antwort aus Sicherheitsgründen gemeldet wurde.
RECITATION Zitatfilter Die Tokengenerierung wurde gestoppt, da die Antwort wegen nicht autorisierter Zitate gekennzeichnet wurde.
Vertrauliche personenbezogene Daten Nicht konfigurierbarer Sicherheitsfilter Die Tokengenerierung wurde gestoppt, da die Antwort für Inhalte des Typs „Sensitive Personally Identifiable Information“ (SPII) gekennzeichnet wurde.
PROHIBITED_CONTENT Nicht konfigurierbarer Sicherheitsfilter Die Tokengenerierung wurde gestoppt, weil die Antwort wegen des verbotenen Inhalts (normalerweise CSAM) gemeldet wurde.
FINISH_REASON_UNSPECIFIED – Der Grund für Fertig ist nicht angegeben.
ANDERE – Diese Aufzählung bezieht sich auf alle anderen Gründe, aus denen die Tokengenerierung beendet wird. Beachten Sie, dass die Generierung von Tokens nicht für alle Sprachen unterstützt wird. Eine Liste der unterstützten Sprachen finden Sie unter Sprachunterstützung in Gemini.

Weitere Informationen finden Sie unter FinishReason.

Wenn ein Filter die Antwort blockiert, wird das Candidate.content-Feld der Antwort ungültig. Es gibt kein Feedback für das Modell.

Konfigurierbare Sicherheitsfilter

Gemini bewertet Inhalte anhand einer Liste von Sicherheitsattributen, die schädliche Kategorien und Themen enthalten, die als sensitiv eingestuft werden können. Für jedes Attribut weist die Vertex AI Gemini API eine Sicherheitspunktzahl anhand der Wahrscheinlichkeit der Inhalte zu, die unsicher sind, und eine weitere Sicherheitspunktzahl auf Grundlage des Schweregrads des schädlichen Inhalts aus.

Der konfigurierbare Sicherheitsfilter hat keine von Modellversionen unabhängige Versionsverwaltung. Google aktualisiert den konfigurierbaren Sicherheitsfilter für eine zuvor veröffentlichte Version eines Modells nicht. Es kann jedoch den konfigurierbaren Sicherheitsfilter für eine zukünftige Version eines Modells aktualisieren.

Sicherheitsattribute

Gemini bewertet Inhalte anhand der folgenden 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

Vergleich von Wahrscheinlichkeitswerten und Schweregradwerten

Das Sicherheitsattribut Wahrscheinlichkeit gibt die Wahrscheinlichkeit an, mit der eine Modellantwort mit dem entsprechenden Sicherheitsattribut verknüpft ist. Sie hat einen zugehörigen Konfidenzwert zwischen 0.0 und 1.0, gerundet auf eine Dezimalstelle. Der Konfidenzwert wird in vier Sicherheitskonfidenzstufen diskretisiert: NEGLIGIBLE, LOW, MEDIUM und HIGH.

Das Sicherheitsattribut Schweregrad gibt an, wie schädlich eine Modellantwort sein kann. Sie hat einen zugehörigen Schweregrad von 0.0 bis 1.0, gerundet auf eine Dezimalstelle. Der Schweregrad ist in vier Ebenen diskretisiert: NEGLIGIBLE, LOW, MEDIUM und HIGH.

Inhalte können einen niedrigen Wahrscheinlichkeitswert und einen hohen Schweregrad haben oder einen hohen Wahrscheinlichkeitswert und einen niedrigen Schweregrad. Betrachten Sie zum Beispiel die folgenden beiden Sätze:

  1. Der Roboter hat mich geboxt.
  2. Der Roboter hat mich in Stücke geschnitten.

Der erste Satz kann zu einer höheren Wahrscheinlichkeit führen, dass er unsicher ist, der zweite Satz hat möglicherweise einen Schweregrad bezüglich Gewalt. Aufgrund dessen ist es wichtig, Tests sorgfältig durchzuführen und das angemessene Maß an Blockierungen zu prüfen, das zur Unterstützung deiner wichtigsten Anwendungsfälle und zur Minimierung des Schadens für Nutzende erforderlich ist.

So konfigurieren Sie den Sicherheitsfilter

Sie können die Vertex AI Gemini API oder die Google Cloud Console verwenden, um den Sicherheitsfilter zu konfigurieren.

Vertex AI Gemini API

Die Vertex AI Gemini API bietet zwei Methoden zur „schädlichen Blockierung“:

  • SCHWEREGRAD: Diese Methode verwendet Punktzahlen sowohl für die Wahrscheinlichkeit als auch den Schweregrad.
  • WAHRSCHEINLICHKEIT: Diese Methode verwendet nur den Wahrscheinlichkeitswert.

Die Standardmethode ist PROBABILITY. Weitere Informationen finden Sie in der Referenz zur HarmBlockMethod API.

Die Vertex AI Gemini API bietet die folgenden Schwellenwerte für die „schädlichen Blockierung“:

  • BLOCK_LOW_AND_ABOVE: Blockieren Sie, wenn der Wahrscheinlichkeitswert oder der Schweregrad LOW, MEDIUM oder HIGH ist.
  • BLOCK_MEDIUM_AND_ABOVE: Blockieren Sie, wenn der Wahrscheinlichkeitswert oder der Schweregrad MEDIUM oder HIGH ist.
  • BLOCK_ONLY_HIGH: Blockieren Sie, wenn der Wahrscheinlichkeitswert oder der Schweregrad HIGH ist.
  • HARM_BLOCK_THRESHOLD_UNSPECIFIED: Blockieren Sie mit dem Standardschwellenwert.
  • BLOCK_NONE (Eingeschränkt): Die Sicherheitseinstellung BLOCK_NONE entfernt die automatische Antwortblockierung und ermöglicht Ihnen, Ihre eigenen Sicherheitsrichtlinien mit den zurückgegebenen Punktzahlen zu konfigurieren. Dies ist ein eingeschränktes Feld, das nicht für alle Nutzer in GA-Modellversionen verfügbar ist. BLOCK_NONE wird für die Audio- und Videoeingabe nicht unterstützt, wenn Sie Gemini 1.5 Flash oder Gemini 1.5 Pro verwenden.

Zum Zugreifen auf die Einstellung BLOCK_NONE haben Sie folgende Möglichkeiten:

  1. Bewerben Sie sich über das Formular zur Zulassungsliste für Sicherheitsfilter von Gemini für die Zulassungsliste oder
  2. Stellen Sie Ihren Kontotyp mit der Google Cloud-Referenz zur Rechnungsstellung auf monatliche Rechnungsstellung um.

Der Standardgrenzwert ist BLOCK_MEDIUM_AND_ABOVE. Weitere Informationen finden Sie in der API-Referenz zu HarmBlockThreshold.

Der folgende Python-Code zeigt beispielsweise, wie Sie die Methode der Schadenssperre auf SEVERITY und den Schwellenwert für die die Schadenssperre auf BLOCK_LOW_AND_ABOVE für die Kategorie gefährlicher Inhalte setzen können:

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

Dadurch werden die meisten Inhalte blockiert, die als gefährliche Inhalte eingestuft werden.

End-to-End-Beispiele in Python, Node.js, Java, Go, C# und REST finden Sie unter Beispiele für die Konfiguration von Sicherheitsfiltern.

Google Cloud Console

In der Google Cloud Console können Sie für jedes Sicherheitsattribut einen Schwellenwert konfigurieren. Der Sicherheitsfilter verwendet nur die Wahrscheinlichkeitswerte. Es gibt keine Option, die Schweregradwerte zu verwenden.

Die Google Cloud Console bietet die folgenden Grenzwerte:

  • Wenige blockieren: Blockieren Sie, wenn der Wahrscheinlichkeitswert HIGH ist.
  • Einige blockieren: Blockieren Sie, wenn der Wahrscheinlichkeitswert MEDIUM oder HIGH ist.
  • Meiste blockieren: Blockieren Sie, wenn der Wahrscheinlichkeitswert LOW, MEDIUM oder HIGH ist.

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 niedrigeren Wahrscheinlichkeit ist zulässig. Der Standardgrenzwert ist Block some.

So legen Sie die Schwellenwerte fest:

  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 Designseite für Prompts 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.

Beispielausgabe, wenn eine Antwort durch den konfigurierbaren Sicherheitsfilter blockiert wird

Das folgende Beispiel zeigt die Ausgabe der Vertex AI Gemini API, wenn eine Antwort durch den konfigurierbaren Sicherheitsfilter mit gefährlichen Inhalten blockiert wird:

{
  "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
  }
}

Beispiele für die Konfiguration von Sicherheitsfiltern

Die folgenden Beispiele zeigen, wie Sie den Sicherheitsfilter mit der Vertex AI Gemini API konfigurieren können:

Python

Informationen zur Installation des Vertex AI SDK for Python finden Sie unter Vertex AI SDK for Python installieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Python API. 

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

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

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

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

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

Nachdem Sie Ihre Umgebung eingerichtet haben, können Sie mit REST einen Text-Prompt testen. Im folgenden Beispiel wird eine Anfrage an den Publisher gesendet Modellendpunkt zu erstellen.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

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

    Klicken Sie, um eine unvollständige Liste der verfügbaren Regionen einzublenden

    • 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 mit dem Inhalt verknüpften Unterhaltung. 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"
    }
  ]
}'

Zitatfilter

Die generativen Code-Features von Vertex AI sind zum Erstellen von Originalinhalten vorgesehen. Gemini begrenzt die Wahrscheinlichkeit, dass vorhandene Inhalte umfassend repliziert werden. Wenn eine Gemini-Funktion aus einer Webseite ein umfangreiches zitiert, wird von Gemini diese Seite zitiert.

Manchmal sind dieselben Inhalte auf mehreren Webseiten zu finden. Gemini versucht, Sie auf eine beliebte Quelle zu verweisen. Bei Zitaten von Code-Repositories kann auch auf eine gültige Open-Source-Lizenz verwiesen werden. Es liegt in Ihrer eigenen Verantwortung, die Lizenzanforderungen einzuhalten.

Weitere Informationen zu den Metadaten des Zitatfilters finden Sie in der Referenz zur Citation API.

Nächste Schritte