安全和内容过滤器

如需查看使用 Vertex AI Gemini API 开始使用 Responsible AI 的示例，请在以下某个环境中运行“使用 Vertex AI Gemini API 实现 Responsible AI：安全评级和阈值”Jupyter 笔记本：

在 Colab 中打开 | 在 Colab Enterprise 中打开 | 在 Vertex AI Workbench 用户管理的笔记本中打开 | 在 GitHub 上查看

Google 的生成式 AI 模型（例如 Gemini 1.5 Flash 和 Gemini 1.5 Pro）旨在优先考虑安全性。不过，它们仍可能会生成有害的回答，尤其是在明确提示的情况下。为了进一步提高安全性并尽量减少滥用情况，您可以配置内容过滤器来屏蔽可能有害的回答。

本页介绍了每种安全和内容过滤器类型，并概述了关键安全概念。对于可配置的内容过滤器，它会向您介绍如何配置每个危害类别的屏蔽阈值，以控制提示和回答的屏蔽频率。

安全和内容过滤器可作为屏障，防止有害输出，但不会直接影响模型的行为。如需详细了解模型可操控性，请参阅系统安全说明。

不安全的提示

Vertex AI Gemini API 提供以下 enum 代码之一，以说明提示遭拒的原因：

Enum	过滤条件类型	说明
PROHIBITED_CONTENT	不可配置的安全过滤条件	系统屏蔽了此提示，因为其中包含禁止的内容（通常是 CSAM），因此被标记。
BLOCKED_REASON_UNSPECIFIED	不适用	未指定屏蔽该提示的原因。
OTHER	不适用	此枚举指的是阻止提示的所有其他原因。请注意，Vertex AI Gemini API 不支持所有语言。如需查看受支持的语言列表，请参阅 Gemini 语言支持。

如需了解详情，请参阅 BlockedReason。

以下是 Vertex AI Gemini API 输出示例，其中提示因包含 PROHIBITED_CONTENT 而被屏蔽：

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

不安全的回答

以下过滤器可以检测并屏蔽可能不安全的回答：

• 不可配置的安全过滤器，用于屏蔽儿童性虐待内容 (CSAM) 和个人可识别信息 (PII)。
• 可配置的内容过滤器，可根据危害类别列表及其用户配置的屏蔽阈值来屏蔽不安全的内容。您可以根据自己的用例和业务情况，为每种危害配置屏蔽阈值。如需了解详情，请参阅可配置的内容过滤器。
• 引文过滤器，用于提供来源材料的引文。如需了解详情，请参阅引用过滤器。

LLM 以文本单元（称为词元）的形式生成回答。模型会在达到自然停止点或某个过滤器屏蔽响应时停止生成词元。Vertex AI Gemini API 提供以下 enum 代码之一来解释词元生成停止的原因：

Enum	过滤条件类型	说明
STOP	不适用	此枚举表示模型已到达自然停止点或提供的停止序列。
MAX_TOKENS	不适用	由于模型达到了请求中指定的词元数量上限，因此词元生成操作已停止。
SAFETY	可配置的内容过滤器	由于回答因有害内容而被标记，因此 token 生成操作已停止。
RECITATION	引用过滤器	由于可能存在重复内容，因此 token 生成操作已停止。
SPII	不可配置的安全过滤条件	由于回答因敏感的个人身份信息 (SPII) 内容而被标记，因此词元生成操作已停止。
PROHIBITED_CONTENT	不可配置的安全过滤条件	由于回答因包含禁止的内容（通常是 CSAM）而被标记，因此词元生成操作已停止。
FINISH_REASON_UNSPECIFIED	不适用	未指定完成原因。
OTHER	不适用	此枚举指的是停止生成词元的所有其他原因。请注意，并非所有语言都支持词元生成。如需查看受支持的语言列表，请参阅 Gemini 语言支持。

如需了解详情，请参阅 FinishReason。

如果过滤条件阻止回答，则会使回答的 Candidate.content 字段失效。它不会向模型提供任何反馈。

可配置的内容过滤器

内容过滤器会根据一系列危害来评估内容。对于每个危害类别，内容过滤器会根据内容有害的可能性分配一个得分，并根据有害内容的严重程度分配另一个得分。

可配置的内容过滤器没有独立于模型版本的版本控制。Google 不会更新之前发布的模型版本的可配置内容过滤器。不过，它可能会更新模型的未来版本的可配置内容过滤器。

危害类别

内容过滤器会根据以下危害类别评估内容：

危害类别	定义
仇恨言论	针对身份和/或受保护属性的负面或有害评论。
骚扰	针对其他人的威胁、恐吓、欺凌或辱骂性评论。
露骨色情内容	包含对性行为或其他淫秽内容的引用。
危险内容	宣传或允许访问有害商品、服务和活动。

概率得分和严重程度得分的比较

概率安全得分反映了模型回答与相应危害相关联的可能性。其关联置信度分数介于 0.0 到 1.0 之间，四舍五入到小数点后一位。置信度分数会细分为四个置信度级别：NEGLIGIBLE、LOW、MEDIUM 和 HIGH。

严重程度得分反映了模型回答可能的危害程度。它具有关联的严重程度得分，范围介于 0.0 到 1.0 之间，四舍五入到小数点后一位。严重程度得分被细分为四个等级：NEGLIGIBLE、LOW、MEDIUM 和 HIGH。

内容可能具有较低的概率分数和较高的严重性分数，或者可能具有高概率分数和低严重程度分数。

如何配置内容过滤器

您可以使用 Vertex AI Gemini API 或 Google Cloud 控制台来配置内容过滤器。

Vertex AI Gemini API

Vertex AI Gemini API 提供了两种“伤害屏蔽”方法：

• SEVERITY：此方法同时使用可能性得分和严重程度得分。
• PROBABILITY：此方法仅使用概率得分。

默认方法为 SEVERITY。对于 gemini-1.5-flash 和 gemini-1.5-pro 之前的模型，默认方法为 PROBABILITY。如需了解详情，请参阅 HarmBlockMethod API 参考文档。

Vertex AI Gemini API 提供以下“伤害屏蔽”阈值：

• BLOCK_LOW_AND_ABOVE：当概率得分或严重程度得分为 LOW、MEDIUM 或 HIGH 时屏蔽。
• BLOCK_MEDIUM_AND_ABOVE：当概率得分或严重程度得分为 MEDIUM 或 HIGH 时屏蔽。对于 gemini-1.5-flash-001 和 gemini-1.5-pro-001，BLOCK_MEDIUM_AND_ABOVE 是默认值。
• BLOCK_ONLY_HIGH：当概率得分或严重级别得分为 HIGH 时屏蔽。
• HARM_BLOCK_THRESHOLD_UNSPECIFIED：使用默认阈值进行屏蔽。
• OFF：不会屏蔽自动回答，也不会返回元数据。对于 gemini-1.5-flash-002 和 gemini-1.5-pro-002，OFF 是默认值。
• BLOCK_NONE：BLOCK_NONE 设置会移除自动回答屏蔽。您可以改为使用返回的得分配置自己的内容准则。这是一个受限字段，仅可供 GA 模型版本的所有用户使用。

注意： 对于 Gemini 1.5 Flash 和 Gemini 1.5 Pro 之前的模型，对 BLOCK_NONE 或 OFF 设置的访问权限受到限制。如需获取访问权限，请与支持团队联系。

例如，以下 Python 代码演示了如何针对危险内容类别将伤害屏蔽阈值设为 BLOCK_ONLY_HIGH：

generative_models.SafetySetting(
  category=generative_models.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
  threshold=generative_models.HarmBlockThreshold.BLOCK_ONLY_HIGH,
),

这样做会屏蔽大部分被归类为危险内容的内容。如需了解详情，请参阅 HarmBlockThreshold API 参考文档。

如需查看 Python、Node.js、Java、Go、C# 和 REST 中的端到端示例，请参阅内容过滤器配置示例。

Google Cloud 控制台

借助 Google Cloud 控制台，您可以为每个内容属性配置阈值。内容过滤器仅使用概率得分。没有使用严重程度得分的选项。

Google Cloud 控制台提供了以下阈值：

• 关闭（默认）：不屏蔽自动回复。
• 屏蔽少部分：当概率得分为 HIGH 时屏蔽。
• 屏蔽部分：当概率得分为 MEDIUM 或 HIGH 时屏蔽。
• 屏蔽大部分：当概率得分为 LOW、MEDIUM 或 HIGH 时屏蔽。

例如，如果您将“危险内容”类别的屏蔽设置设为屏蔽少部分，则系统会屏蔽包含危险内容概率较高的所有部分。允许任何包含危险内容概率较低的部分。默认阈值为 Block some。

如需设置阈值，请参阅以下步骤：

1. 在 Google Cloud 控制台的 Vertex AI 部分中，进入 Vertex AI Studio 页面。

   进入 Vertex AI Studio

2. 在创建新提示下，点击任意按钮以打开提示设计页面。

3. 点击安全设置。

   系统会打开安全设置对话框窗口。

4. 对于每个危害类别，配置所需的阈值。

5. 点击保存。

回答被可配置的内容过滤器阻止时的示例输出

以下是 Vertex AI Gemini API 输出示例，其中回答因包含危险内容而被可配置内容过滤器屏蔽：

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

内容过滤器配置示例

以下示例展示了如何使用 Vertex AI Gemini API 配置内容过滤器：

Gen AI SDK for Python

了解如何安装或更新 Google Gen AI SDK for Python。
如需了解详情，请参阅 Gen AI SDK for Python API 参考文档或 python-genai GitHub 代码库。
设置环境变量以将 Gen AI SDK 与 Vertex AI 搭配使用：

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=us-central1
export GOOGLE_GENAI_USE_VERTEXAI=True

from google import genai
from google.genai.types import (
    GenerateContentConfig,
    HarmCategory,
    HarmBlockThreshold,
    HttpOptions,
    SafetySetting,
)

client = genai.Client(http_options=HttpOptions(api_version="v1"))

system_instruction = "Be as mean as possible."

prompt = """
    Write a list of 5 disrespectful things that I might say to the universe after stubbing my toe in the dark.
"""

safety_settings = [
    SafetySetting(
        category=HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
        threshold=HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    ),
    SafetySetting(
        category=HarmCategory.HARM_CATEGORY_HARASSMENT,
        threshold=HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    ),
    SafetySetting(
        category=HarmCategory.HARM_CATEGORY_HATE_SPEECH,
        threshold=HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    ),
    SafetySetting(
        category=HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
        threshold=HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    ),
]

response = client.models.generate_content(
    model="gemini-2.0-flash-001",
    contents=prompt,
    config=GenerateContentConfig(
        system_instruction=system_instruction,
        safety_settings=safety_settings,
    ),
)

# Response will be `None` if it is blocked.
print(response.text)
# Finish Reason will be `SAFETY` if it is blocked.
print(response.candidates[0].finish_reason)
# Safety Ratings show the levels for each filter.
for safety_rating in response.candidates[0].safety_ratings:
    print(safety_rating)

# Example response:
# None
# FinishReason.SAFETY
# blocked=None category=<HarmCategory.HARM_CATEGORY_HATE_SPEECH: 'HARM_CATEGORY_HATE_SPEECH'> probability=<HarmProbability.NEGLIGIBLE: 'NEGLIGIBLE'> probability_score=1.767152e-05 severity=<HarmSeverity.HARM_SEVERITY_NEGLIGIBLE: 'HARM_SEVERITY_NEGLIGIBLE'> severity_score=None
# blocked=None category=<HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: 'HARM_CATEGORY_DANGEROUS_CONTENT'> probability=<HarmProbability.NEGLIGIBLE: 'NEGLIGIBLE'> probability_score=2.399503e-06 severity=<HarmSeverity.HARM_SEVERITY_NEGLIGIBLE: 'HARM_SEVERITY_NEGLIGIBLE'> severity_score=0.061250776
# blocked=True category=<HarmCategory.HARM_CATEGORY_HARASSMENT: 'HARM_CATEGORY_HARASSMENT'> probability=<HarmProbability.MEDIUM: 'MEDIUM'> probability_score=0.64129734 severity=<HarmSeverity.HARM_SEVERITY_MEDIUM: 'HARM_SEVERITY_MEDIUM'> severity_score=0.2686556
# blocked=None category=<HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: 'HARM_CATEGORY_SEXUALLY_EXPLICIT'> probability=<HarmProbability.NEGLIGIBLE: 'NEGLIGIBLE'> probability_score=5.2786977e-06 severity=<HarmSeverity.HARM_SEVERITY_NEGLIGIBLE: 'HARM_SEVERITY_NEGLIGIBLE'> severity_score=0.043162167

Python 版 Vertex AI SDK

如需了解如何安装或更新 Vertex AI SDK for Python，请参阅安装 Vertex AI SDK for Python。 如需了解详情，请参阅 Python 版 Vertex AI SDK API 参考文档。

import vertexai

from vertexai.generative_models import (
    GenerativeModel,
    HarmCategory,
    HarmBlockThreshold,
    Part,
    SafetySetting,
)

# TODO(developer): Update and un-comment below line
# PROJECT_ID = "your-project-id"
vertexai.init(project=PROJECT_ID, location="us-central1")

model = GenerativeModel("gemini-1.5-flash-002")

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

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

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

print(response.text)
print(response.candidates[0].safety_ratings)
# Example response:
# The image contains a beautiful arrangement of blueberry scones, flowers, coffee, and blueberries.
# The scene is set on a rustic blue background. The image evokes a sense of comfort and indulgence.
# ...

Node.js

在尝试此示例之前，请按照《Vertex AI 快速入门：使用客户端库》中的 Node.js 设置说明执行操作。 如需了解详情，请参阅 Vertex AI Node.js API 参考文档。

如需向 Vertex AI 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

/**
 * TODO(developer): Update these variables before running the sample.
 */
const PROJECT_ID = process.env.CAIP_PROJECT_ID;
const LOCATION = 'us-central1';
const MODEL = 'gemini-1.5-flash-001';

async function setSafetySettings() {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: PROJECT_ID, 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
    safetySettings: [
      {
        category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
        threshold: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
      },
      {
        category: HarmCategory.HARM_CATEGORY_HARASSMENT,
        threshold: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
      },
    ],
  });

  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

在尝试此示例之前，请按照《Vertex AI 快速入门：使用客户端库》中的 Java 设置说明执行操作。 如需了解详情，请参阅 Vertex AI Java API 参考文档。

如需向 Vertex AI 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

在尝试此示例之前，请按照《Vertex AI 快速入门：使用客户端库》中的 Go 设置说明执行操作。 如需了解详情，请参阅 Vertex AI Go API 参考文档。

如需向 Vertex AI 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

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

// generateMultimodalContent generates a response into w, based upon the  provided image.
func generateMultimodalContent(w io.Writer, projectID, location, modelName string) error {
	// location := "us-central1"
	// model := "gemini-1.5-flash-001"
	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("320px-Felis_catus-cat_on_snow.jpg")),
		FileURI:  "gs://cloud-samples-data/generative-ai/image/320px-Felis_catus-cat_on_snow.jpg",
	}

	res, err := model.GenerateContent(ctx, img, genai.Text("describe this image."))
	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#

在尝试此示例之前，请按照《Vertex AI 快速入门：使用客户端库》中的 C# 设置说明执行操作。 如需了解详情，请参阅 Vertex AI C# API 参考文档。

如需向 Vertex AI 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。

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

设置您的环境后，您可以使用 REST 测试文本提示。以下示例会向发布方模型端点发送请求。

在使用任何请求数据之前，请先进行以下替换：

• LOCATION：处理请求的区域。可用的选项包括：

  点击即可展开可用区域的部分列表

  • us-central1
  • us-west4
  • northamerica-northeast1
  • us-east4
  • us-west1
  • asia-northeast3
  • asia-southeast1
  • asia-northeast1
• PROJECT_ID：您的项目 ID。
• MODEL_ID：您要使用的多模态模型 ID。选项包括：
  • gemini-1.0-pro
  • gemini-1.0-pro-vision
• ROLE：与内容关联的对话中的角色。即使在单轮应用场景中，也需要指定角色。 可接受的值包括：
  • USER：指定由您发送的内容。
  • MODEL：指定模型的响应。
• TEXT：要包含在提示中的文本说明。
• SAFETY_CATEGORY：要为其配置阈值的安全类别。可接受的值包括：

  点击即可展开安全类别

  • HARM_CATEGORY_SEXUALLY_EXPLICIT
  • HARM_CATEGORY_HATE_SPEECH
  • HARM_CATEGORY_HARASSMENT
  • HARM_CATEGORY_DANGEROUS_CONTENT
• THRESHOLD：基于概率阻止属于指定安全类别的回答的阈值。可接受的值包括：

  点击即可展开屏蔽阈值

  • BLOCK_NONE
  • BLOCK_ONLY_HIGH
  • BLOCK_MEDIUM_AND_ABOVE（默认）
  • BLOCK_LOW_AND_ABOVE
  BLOCK_LOW_AND_ABOVE 屏蔽得最多，而 BLOCK_ONLY_HIGH 屏蔽得最少。

HTTP 方法和网址：

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

请求 JSON 正文：

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

如需发送请求，请选择以下方式之一：

curl

注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI，或者使用了 Cloud Shell，这会使您自动登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

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

注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

$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

您应该收到类似以下内容的 JSON 响应。

响应

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

示例 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": "OFF"
    },
    {
      "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"
    }
  ]
}'

引用过滤器

Vertex AI 的生成式代码功能旨在生成原创内容。Gemini 的设计旨在限制大量复制现有内容的可能性。如果 Gemini 功能确实直接引用了某个网页上的大量内容，则会注明相应内容来源于该页面。

有时，我们可能会在多个网页上发现相同的内容。Gemini 会尝试将您引导至热门来源。如果此类功能引用了代码库，则引用中还可能提及适用的开源许可。您须负责遵守所有许可要求。

如需了解引用过滤器的元数据，请参阅过滤器 API 参考文档。

公民诚信过滤器

Preview

This feature is subject to the "Pre-GA Offerings Terms" in the General Service Terms section of the Service Specific Terms. Pre-GA features are available "as is" and might have limited support. For more information, see the launch stage descriptions.

公民诚信过滤器会检测并屏蔽提及或涉及政治选举和候选人的提示。此过滤器默认处于停用状态。如需启用此功能，请将 CIVIC_INTEGRITY 的屏蔽阈值设置为以下任一值。您指定的值无关紧要。

• BLOCK_LOW_AND_ABOVE
• BLOCK_MEDIUM_AND_ABOVE
• BLOCK_ONLY_HIGH

以下 Python 代码展示了如何启用公民诚信过滤器：

  generative_models.SafetySetting(
      category=generative_models.HarmCategory.CIVIC_INTEGRITY,
      threshold=generative_models.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
  ),

如需详细了解公民诚信过滤器，请与您的 Google Cloud代表联系。

最佳做法

虽然内容过滤器有助于防止出现不安全内容，但偶尔也会屏蔽安全内容或漏掉有害内容。Gemini 1.5 Flash 和 Gemini 1.5 Pro 等高级模型即使没有过滤器也能生成安全的回答。测试不同的过滤器设置，在确保安全性和允许适当内容之间找到合适的平衡点。

后续步骤

• 了解系统安全指令。
• 了解滥用监控。
• 详细了解 Responsible AI。
• 了解数据治理。