试用 Gemini 1.5 模型，这是 Vertex AI 中最新的多模态模型，看看您可以运用多达 200 万词元的上下文窗口构建怎样的应用。 试用 Gemini 1.5 模型，这是 Vertex AI 中最新的多模态模型，看看您可以运用多达 200 万词元的上下文窗口构建怎样的应用。

配置安全属性

大语言模型 (LLM) 可能会生成意料之外的输出，包括令人反感、不顾他人感受或事实上不正确的文本。为了保证安全性并防止滥用，Gemini 使用安全过滤器来阻止其确定可能有害的提示和回答。

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

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

不安全的提示

Vertex AI Gemini API 提供以下 enum 代码之一，以解释提示被拒绝的原因：

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

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

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

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

不安全的回答

为了确定哪些回答可能不安全，Vertex AI Gemini API 使用以下过滤条件：

不可配置的安全过滤器，可阻止儿童性虐待内容 (CSAM) 和个人身份信息 (PII)。
可配置的安全过滤器，可根据安全属性列表及其用户配置的屏蔽阈值来屏蔽不安全的内容。您可以根据自己的用例和业务需求，为每项属性配置屏蔽阈值。如需了解详情，请参阅可配置的安全过滤器。
引用过滤条件，可防止滥用并确保正确引用受版权保护的内容。如需了解详情，请参阅引用过滤器。

LLM 以文本单元（称为词元）的形式生成回答。模型停止生成词元，因为它到达自然停止点或有一个过滤条件阻止回答。Vertex AI Gemini API 提供以下 enum 代码之一，以说明词元生成停止的原因：

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

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

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

可配置的安全过滤器

Gemini 会根据安全属性列表评估内容，其中包括可能被视为敏感的有害类别和主题。对于每个属性，Vertex AI Gemini API 会根据内容不安全的可能性分配一个安全得分，并根据有害内容的严重程度分配另一个安全得分。

可配置的安全过滤器的版本控制不与模型版本无关。Google 不会更新之前发布的模型版本的可配置安全过滤器。不过，它可能会更新模型的未来版本的可配置安全过滤器。

安全属性

Gemini 会根据以下安全属性来评估内容：

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

概率分数和严重性分数的比较

概率安全属性反映了模型回答与相应安全属性相关联的可能性。关联置信度分数介于 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。如需了解详情，请参阅 HarmBlockMethod API 参考文档。

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

BLOCK_LOW_AND_ABOVE：当概率得分或严重级别得分为 LOW、MEDIUM 或 HIGH 时进行屏蔽。
BLOCK_MEDIUM_AND_ABOVE：当概率得分或严重级别得分为 MEDIUM 或 HIGH 时阻止。
BLOCK_ONLY_HIGH：当概率得分或严重级别得分为 HIGH 时屏蔽。
HARM_BLOCK_THRESHOLD_UNSPECIFIED：使用默认阈值进行屏蔽。
BLOCK_NONE（受限）：BLOCK_NONE 安全设置会移除自动回答屏蔽，让您可以使用返回的得分配置自己的安全准则。这是一个受限字段，仅可供 GA 模型版本的所有用户使用。当您使用 Gemini 1.5 Flash 或 Gemini 1.5 Pro 时，音频和视频输入不支持 BLOCK_NONE。

如需访问 BLOCK_NONE 设置，您可以执行以下操作：

通过 Gemini 安全过滤器许可名单表单申请列入许可名单，或者
使用 Google Cloud 账单结算参考文档，将账号类型更改为按月账单结算。

默认阈值为 BLOCK_MEDIUM_AND_ABOVE。如需了解详情，请参阅 HarmBlockThreshold API 参考文档。

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

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

这样做会屏蔽大部分被归类为危险内容的内容。

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

Google Cloud 控制台

借助 Google Cloud 控制台，您可以为每个安全属性配置阈值。安全过滤条件仅使用概率得分。无法使用严重程度得分。

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

屏蔽少量：当概率得分为 HIGH 时屏蔽。
屏蔽部分：当概率得分为 MEDIUM 或 HIGH 时屏蔽。
屏蔽大部分：当概率得分为 LOW、MEDIUM 或 HIGH 时屏蔽。

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

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

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

进入 Vertex AI Studio
在创建新提示下，点击任意按钮以打开提示设计页面。
点击安全设置。

系统会打开安全设置对话框窗口。
对于每个安全属性，配置所需的阈值。
点击保存。

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

以下是 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 配置安全过滤条件：

Python

如需了解如何安装或更新 Vertex AI SDK for Python，请参阅安装 Vertex AI SDK for Python。如需了解详情，请参阅 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

在尝试此示例之前，请按照《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.
 */
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

在尝试此示例之前，请按照《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)
              .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

在尝试此示例之前，请按照《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 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#

在尝试此示例之前，请按照《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" }
  },
  "safety_settings": {
    "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": "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"
    }
  ]
}'

引用过滤器

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

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

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

后续步骤

详细了解 Responsible AI。
了解数据治理。