发送多模态提示请求

Gemini 模型系列包含可处理多模态提示请求的模型。多模态一词表示您可以在一个提示中使用多种模态（或输入类型）。非多模态模型仅接受文本提示。模态可以包括文本、音频、视频等。

您可以通过多种方式使用 Gemini API 实现多模态解决方案，包括 Python、Node.js、Java 和 Go SDK、Google Cloud 控制台以及 REST API。本文档后面的代码示例演示了如何使用这些选项创建多模态解决方案。

多模态 Gemini 模型包括：

  • Gemini 1.5 Flash
  • Gemini 1.5 Pro
  • Gemini 1.0 Pro Vision

下表显示了每个多模态 Gemini API 在问题请求中支持的模态。

模型 文本 代码 图片 音频 视频 视频/音频 PDF
Gemini 1.5 Flash
Gemini 1.5 Pro
Gemini 1.0 Pro Vision
Gemini 1.0 Pro

如需在 Google Cloud 控制台中探索多模态模型，请在 Model Garden 中选择其模型卡片：

如需查看 Gemini 模型支持的语言列表，请参阅模型信息语言支持。如需详细了解如何设计多模态提示，请参阅设计多模态提示。如果您正在寻找一种直接在移动应用和 Web 应用中使用 Gemini 的方法，请查看适用于 Android、Swift 和 Web 的 Google AI SDK。

多模态模型的区别

多模态 Gemini 模型之间的区别在以下表格中有所说明。您可以根据这些信息来帮助确定哪种模型最适合您。

文本

以下是多模态 Gemini 模型在文本模态方面的一些区别：

模型 文本模态详细信息
Gemini 1.5 Flash、
Gemini 1.5 Pro		 上下文长度为 100 万个词元，相当于一本 4,000 页左右的书。这可让模型输出长文本，例如图书、多个 PDF 文件或用户手册。
Gemini 1.0 Pro Vision 词元数量上限为 16,384，或者一本 128 页左右的书（假设每页有 250 个字）。此上限包括输入和输出词元。输出词元的数量上限为 2,048。

代码

以下是多模态 Gemini 模型在处理代码时的一些区别：

模型 代码模态详细信息
Gemini 1.5 Flash、
Gemini 1.5 Pro		 上下文长度为 100 万个词元，可让模型使用整个代码库或整个应用代码库。
Gemini 1.0 Pro Vision 词元数量上限为 16,384，或者一本 128 页左右的书（假设每页有 250 个字）。此上限包括输入和输出词元。输出词元的数量上限为 2,048。

映像

以下是多模态 Gemini 模型在图片模态方面的一些区别：

模型 图片模态详细信息
Gemini 1.5 Flash、
Gemini 1.5 Pro		 每个问题的图片数量上限为 3,000 张。
Gemini 1.0 Pro Vision 每个问题的图片数量上限为 16 张。

音频（仅限语音）

以下是多模态 Gemini 模型在音频模态方面的一些区别：

模型 音频模态详情
Gemini 1.5 Flash、
Gemini 1.5 Pro		 每个问题的音频最大小时数约为 8.4 小时，即最多 100 万个词元。系统可以理解语音用于音频摘要、转写和翻译。
Gemini 1.0 Pro Vision 不支持音频。

视频

以下是多模态 Gemini 模型在视频模态方面的一些区别：

模型 视频模态详细信息
Gemini 1.5 Flash、
Gemini 1.5 Pro		 包含音频时，视频时长上限约为 50 分钟。不含音频时，视频时长上限为 1 小时。每个提示的视频数量上限为 10。模型能够使用视频和音频数据来回答问题。例如，它可以使用视频中的视觉内容和语音总结视频。
Gemini 1.0 Pro Vision 视频时长上限为 2 分钟。每个提示的视频数量上限为 1。视频中的音频会被忽略。

PDF

以下是多模态 Gemini 模型在 PDF 模态方面的一些区别：

模型 PDF 模态详情
Gemini 1.5 Flash、
Gemini 1.5 Pro		 每个问题的页面数量上限为 300。PDF 文件大小上限为 30MB。
Gemini 1.0 Pro Vision 每个问题的页数上限为 16 页。PDF 文件大小上限为 30MB。

快速入门

使用以下代码示例开始使用 Gemini API。每个代码示例都演示了如何使用不同的模态。本文档中的部分代码示例适用于所有多模态 Gemini 模型，而某些示例仅适用于 Gemini 1.5 Pro。每个代码示例都指定了它适用于哪些模型。

如需测试和迭代多模态提示，我们建议使用 Google Cloud 控制台。如需以编程方式向模型发送多模态提示，您可以使用 REST API、Vertex AI SDK for Python 或以下标签页中显示的其他受支持的库和 SDK。

单张图片

以下各个标签页中的示例代码展示了识别图片中内容的不同方式。此示例适用于所有多模态 Gemini 模型。

Python

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generate_content 中的 stream 参数。

  response = model.generate_content(contents=[...], stream = True)

对于非流式回答，请移除该参数或将参数设置为 False。

示例代码

import vertexai

from vertexai.generative_models import GenerativeModel, Part

# TODO(developer): Update and un-comment below line
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

model = GenerativeModel(model_name="gemini-1.5-flash-001")

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

# Query the model
response = model.generate_content([image_file, "what is this image?"])
print(response.text)

Java

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

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generateContentStream 方法。

  public ResponseStream generateContentStream(Content content)

对于非流式回答，请使用 generateContent 方法。

  public GenerateContentResponse generateContent(Content content)

示例代码

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.util.Base64;

public class MultimodalQuery {

  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-001";
    String dataImageBase64 = "your-base64-encoded-image";

    String output = multimodalQuery(projectId, location, modelName, dataImageBase64);
    System.out.println(output);
  }


  // Ask the model to recognise the brand associated with the logo image.
  public static String multimodalQuery(String projectId, String location, String modelName,
      String dataImageBase64) 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)) {
      String output;
      byte[] imageBytes = Base64.getDecoder().decode(dataImageBase64);

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              "What is this image?",
              PartMaker.fromMimeTypeAndData("image/png", imageBytes)
          ));

      output = ResponseHandler.getText(response);
      return output;
    }
  }
}

Node.js

在尝试此示例之前，请按照《生成式 AI 快速入门：使用 Node.js SDK》中的 Node.js 设置说明执行操作。如需了解详情，请参阅适用于 Gemini 的 Node.js SDK 参考文档。

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generateContentStream 方法。

  const streamingResp = await generativeModel.generateContentStream(request);

对于非流式回答，请使用 generateContent 方法。

  const streamingResp = await generativeModel.generateContent(request);

示例代码

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

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function createNonStreamingMultipartContent(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.0-pro-vision-001',
  image = 'gs://generativeai-downloads/images/scones.jpg',
  mimeType = 'image/jpeg'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  // Instantiate the model
  const generativeVisionModel = vertexAI.getGenerativeModel({
    model: model,
  });

  // For images, the SDK supports both Google Cloud Storage URI and base64 strings
  const filePart = {
    fileData: {
      fileUri: image,
      mimeType: mimeType,
    },
  };

  const textPart = {
    text: 'what is shown in this image?',
  };

  const request = {
    contents: [{role: 'user', parts: [filePart, textPart]}],
  };

  console.log('Prompt Text:');
  console.log(request.contents[0].parts[1].text);

  console.log('Non-Streaming Response Text:');
  // Create the response stream
  const responseStream =
    await generativeVisionModel.generateContentStream(request);

  // Wait for the response stream to complete
  const aggregatedResponse = await responseStream.response;

  // Select the text from the response
  const fullTextResponse =
    aggregatedResponse.candidates[0].content.parts[0].text;

  console.log(fullTextResponse);
}

REST

您可以使用 REST 测试文本提示，方法是使用 Vertex AI API 向发布方模型端点发送 POST 请求。

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

  • GENERATE_RESPONSE_METHOD：您希望模型生成的回答类型。选择一种方法来生成您希望返回模型回答的方式：
    • streamGenerateContent：在生成回答时进行流式传输，以降低真人受众群体对于延迟的感知度。
    • generateContent：回答在完全生成后返回。
  • 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-vision
  • ROLE：与内容关联的对话中的角色。即使在单轮应用场景中，也需要指定角色。 可接受的值包括：
    • USER：指定由您发送的内容。
  • TEXT：要包含在提示中的文本说明。
  • B64_BASE：要在提示中包含内嵌的图片、PDF 或视频的 base64 编码。添加媒体内嵌时，您还必须指定 MIMETYPE。
  • FILE_URI：要包含在提示中的图片或视频的 Cloud Storage URI。存储该文件的存储桶必须位于发送请求的 Google Cloud 项目中。您还必须指定 MIMETYPE。
  • MIME_TYPE：在 data 或 fileUri 字段中指定的图片、PDF 或视频的媒体类型。可接受的值包括：

    点击即可展开 MIME 类型

    • application/pdf
    • audio/mpeg
    • audio/mp3
    • audio/wav
    • image/png
    • image/jpeg
    • text/plain
    • video/mov
    • video/mpeg
    • video/mp4
    • video/mpg
    • video/avi
    • video/wmv
    • video/mpegps
    • video/flv
  • 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 屏蔽得最少。
  • TEMPERATURE：温度 (temperature) 在生成回答期间用于采样，在应用 topP 和 topK 时会生成回答。温度可以控制词元选择的随机性。 较低的温度有利于需要更少开放性或创造性回复的提示，而较高的温度可以带来更具多样性或创造性的结果。温度为 0 表示始终选择概率最高的词元。在这种情况下，给定提示的回复大多是确定的，但可能仍然有少量变化。

    如果模型返回的回答过于笼统、过于简短，或者模型给出后备回答，请尝试提高温度。

  • TOP_P：Top-P 可更改模型选择输出词元的方式。系统会按照概率从最高（见 top-K）到最低的顺序选择词元，直到所选词元的概率总和等于 top-P 的值。例如，如果词元 A、B 和 C 的概率分别为 0.3、0.2 和 0.1，并且 top-P 值为 0.5，则模型将选择 A 或 B 作为下一个词元（通过温度确定），并会排除 C，将其作为候选词元。

    指定较低的值可获得随机程度较低的回答，指定较高的值可获得随机程度较高的回答。

  • TOP_K：Top-K 可更改模型选择输出词元的方式。如果 top-K 设为 1，表示所选词元是模型词汇表的所有词元中概率最高的词元（也称为贪心解码）。如果 top-K 设为 3，则表示系统将从 3 个概率最高的词元（通过温度确定）中选择下一个词元。

    在每个词元选择步骤中，系统都会对概率最高的 top-K 词元进行采样。然后，系统会根据 top-P 进一步过滤词元，并使用温度采样选择最终的词元。

    指定较低的值可获得随机程度较低的回答，指定较高的值可获得随机程度较高的回答。

  • MAX_OUTPUT_TOKENS：回答中可生成的词元数量上限。词元约为 4 个字符。100 个词元对应大约 60-80 个单词。

    指定较低的值可获得较短的回答，指定较高的值可获得可能较长的回答。

  • STOP_SEQUENCES：指定一个字符串列表，告知模型在响应中遇到其中一个字符串时，停止生成文本。如果某个字符串在响应中多次出现，则响应会在首次出现的位置截断。字符串区分大小写。

    例如，未指定 stopSequences 时，如果下面的内容是返回的回复：

    public static string reverse(string myString)

    则返回的回复为以下内容，其中 stopSequences 设置为 ["Str", "reverse"]：

    public static string

HTTP 方法和网址：

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

请求 JSON 正文： 

{
  "contents": {
    "role": "ROLE",
    "parts": [
      {
        "inlineDATA": {
          "mimeType": "MIME_TYPE",
          "data": "B64_BASE_IMAGE"
        }
      },
      {
        "fileData": {
          "mimeType": "MIME_TYPE",
          "fileUri": "FILE_URI"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  },
  "safety_settings": {
    "category": "SAFETY_CATEGORY",
    "threshold": "THRESHOLD"
  },
  "generation_config": {
    "temperature": TEMPERATURE,
    "topP": TOP_P,
    "topK": TOP_K,
    "candidateCount": 1,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "stopSequences": STOP_SEQUENCES,
  }
}

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

curl

将请求正文保存在名为 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:GENERATE_RESPONSE_METHOD"

PowerShell

将请求正文保存在名为 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:GENERATE_RESPONSE_METHOD" | Select-Object -Expand Content

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

示例 curl 命令

LOCATION="us-central1"
MODEL_ID="gemini-1.0-pro-vision"
PROJECT_ID="test-project"

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json"
https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:${GENERATE_RESPONSE_METHOD} -d \
$'{
  "contents": {
    "role": "user",
    "parts": [
      {
        "fileData": {
          "mimeType": "image/png",
          "fileUri": "gs://my-bucket/images/cat.png"
        }
      },
      {
        "text": "Describe this picture."
      },
    ]
  },
  "safety_settings": {
    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
    "threshold": "BLOCK_LOW_AND_ABOVE"
  },
  "generation_config": {
    "temperature": 0.4,
    "topP": 1,
    "topK": 32,
    "maxOutputTokens": 2048,
  }
}'

单个 PDF 文件

以下标签页展示了如何使用 Python SDK 在提示请求中添加 PDF 文件。此 PDF 文件示例适用于所有 Gemini 多模态模型。

Python

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generate_content 中的 stream 参数。

  response = model.generate_content(contents=[...], stream = True)

对于非流式回答，请移除该参数或将参数设置为 False。

示例代码

import vertexai

from vertexai.generative_models import GenerativeModel, Part

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

model = GenerativeModel(model_name="gemini-1.5-flash-001")

prompt = """
You are a very professional document summarization specialist.
Please summarize the given document.
"""

pdf_file_uri = "gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf"
pdf_file = Part.from_uri(pdf_file_uri, mime_type="application/pdf")
contents = [pdf_file, prompt]

response = model.generate_content(contents)
print(response.text)

Java

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

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generateContentStream 方法。

  public ResponseStream generateContentStream(Content content)

对于非流式回答，请使用 generateContent 方法。

  public GenerateContentResponse generateContent(Content content)

示例代码


import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.IOException;

public class PdfInput {

  public static void main(String[] args) throws IOException {
    // 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";

    pdfInput(projectId, location, modelName);
  }

  // Analyzes the given video input.
  public static String pdfInput(String projectId, String location, String modelName)
      throws IOException {
    // 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)) {
      String pdfUri = "gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf";

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              "You are a very professional document summarization specialist.\n"
                  + "Please summarize the given document.",
              PartMaker.fromMimeTypeAndData("application/pdf", pdfUri)
          ));

      String output = ResponseHandler.getText(response);
      System.out.println(output);
      return output;
    }
  }
}

Node.js

在尝试此示例之前，请按照《生成式 AI 快速入门：使用 Node.js SDK》中的 Node.js 设置说明执行操作。如需了解详情，请参阅适用于 Gemini 的 Node.js SDK 参考文档。

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generateContentStream 方法。

  const streamingResp = await generativeModel.generateContentStream(request);

对于非流式回答，请使用 generateContent 方法。

  const streamingResp = await generativeModel.generateContent(request);

示例代码

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

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function analyze_pdf(projectId = 'PROJECT_ID') {
  const vertexAI = new VertexAI({project: projectId, location: 'us-central1'});

  const generativeModel = vertexAI.getGenerativeModel({
    model: 'gemini-1.5-pro-preview-0409',
  });

  const filePart = {
    file_data: {
      file_uri: 'gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf',
      mime_type: 'application/pdf',
    },
  };
  const textPart = {
    text: `
    You are a very professional document summarization specialist.
    Please summarize the given document.`,
  };

  const request = {
    contents: [{role: 'user', parts: [filePart, textPart]}],
  };

  const resp = await generativeModel.generateContent(request);
  const contentResponse = await resp.response;
  console.log(JSON.stringify(contentResponse));
}

C#

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

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


using Google.Cloud.AIPlatform.V1;
using System;
using System.Threading.Tasks;

public class PdfInput
{
    public async Task<string> SummarizePdf(
        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();

        string prompt = @"You are a very professional document summarization specialist.
Please summarize the given document.";

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = prompt },
                        new Part { FileData = new() { MimeType = "application/pdf", FileUri = "gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf" }}
                    }
                }
            }
        };

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);

        return responseText;
    }
}

单个视频

以下各个标签页展示了在提示请求中添加视频的不同方式。这些 PDF 文件示例适用于所有 Gemini 多模态模型。

Python

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generate_content 中的 stream 参数。

  response = model.generate_content(contents=[...], stream = True)

对于非流式回答，请移除该参数或将参数设置为 False。

示例代码

import vertexai

from vertexai.generative_models import GenerativeModel, Part

# TODO(developer): Update and un-comment below line
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

vision_model = GenerativeModel(model_name="gemini-1.5-flash-001")

# Generate text
response = vision_model.generate_content(
    [
        Part.from_uri(
            "gs://cloud-samples-data/video/animals.mp4", mime_type="video/mp4"
        ),
        "What is in the video?",
    ]
)
print(response.text)

Java

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

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generateContentStream 方法。

  public ResponseStream generateContentStream(Content content)

对于非流式回答，请使用 generateContent 方法。

  public GenerateContentResponse generateContent(Content content)

示例代码

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.IOException;

public class MultimodalVideoInput {

  public static void main(String[] args) throws IOException {
    // 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-001";

    multimodalVideoInput(projectId, location, modelName);
  }

  // Analyzes the given video input.
  public static void multimodalVideoInput(String projectId, String location, String modelName)
      throws IOException {
    // 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)) {
      String videoUri = "gs://cloud-samples-data/video/animals.mp4";

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              "What is in the video?",
              PartMaker.fromMimeTypeAndData("video/mp4", videoUri)
          ));

      String output = ResponseHandler.getText(response);
      System.out.println(output);
    }
  }
}

Node.js

在尝试此示例之前，请按照《生成式 AI 快速入门：使用 Node.js SDK》中的 Node.js 设置说明执行操作。如需了解详情，请参阅适用于 Gemini 的 Node.js SDK 参考文档。

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generateContentStream 方法。

  const streamingResp = await generativeModel.generateContentStream(request);

对于非流式回答，请使用 generateContent 方法。

  const streamingResp = await generativeModel.generateContent(request);

示例代码

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

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function sendMultiModalPromptWithVideo(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.0-pro-vision-001'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  const generativeVisionModel = vertexAI.getGenerativeModel({
    model: model,
  });

  // Pass multimodal prompt
  const request = {
    contents: [
      {
        role: 'user',
        parts: [
          {
            fileData: {
              fileUri: 'gs://cloud-samples-data/video/animals.mp4',
              mimeType: 'video/mp4',
            },
          },
          {
            text: 'What is in the video?',
          },
        ],
      },
    ],
  };

  // Create the response
  const response = await generativeVisionModel.generateContent(request);
  // Wait for the response to complete
  const aggregatedResponse = await response.response;
  // Select the text from the response
  const fullTextResponse =
    aggregatedResponse.candidates[0].content.parts[0].text;

  console.log(fullTextResponse);
}

Go

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

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 GenerateContentStream 方法。

  iter := model.GenerateContentStream(ctx, genai.Text("Tell me a story about a lumberjack and his giant ox. Keep it very short."))

对于非流式回答，请使用 GenerateContent 方法。

  resp, err := model.GenerateContent(ctx, genai.Text("What is the average size of a swallow?"))

示例代码

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

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

// generateMultimodalContent generates a response into w, based upon the prompt
// and video provided.
// video is a Google Cloud Storage path starting with "gs://"
func generateMultimodalContent(w io.Writer, prompt, video, projectID, location, modelName string) error {
	// prompt := "What is in this video?"
	// video := "gs://cloud-samples-data/video/animals.mp4"
	// location := "us-central1"
	// modelName := "gemini-1.0-pro-vision-001"
	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)

	// Given a video file URL, prepare video file as genai.Part
	part := genai.FileData{
		MIMEType: mime.TypeByExtension(filepath.Ext(video)),
		FileURI:  video,
	}

	res, err := model.GenerateContent(ctx, part, genai.Text(prompt))
	if err != nil {
		return fmt.Errorf("unable to generate contents: %v", err)
	}

	if len(res.Candidates) == 0 ||
		len(res.Candidates[0].Content.Parts) == 0 {
		return errors.New("empty response from model")
	}

	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;

public class MultimodalVideoInput
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.0-pro-vision"
    )
    {
        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 = "What's in the video?" },
                        new Part { FileData = new() { MimeType = "video/mp4", FileUri = "gs://cloud-samples-data/video/animals.mp4" }}
                    }
                }
            }
        };

        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        AsyncResponseStream<GenerateContentResponse> responseStream = response.GetResponseStream();
        await foreach (GenerateContentResponse responseItem in responseStream)
        {
            fullText.Append(responseItem.Candidates[0].Content.Parts[0].Text);
        }
        return fullText.ToString();
    }
}

REST

您可以使用 REST 测试文本提示，方法是使用 Vertex AI API 向发布方模型端点发送 POST 请求。

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

  • GENERATE_RESPONSE_METHOD：您希望模型生成的回答类型。选择一种方法来生成您希望返回模型回答的方式：
    • streamGenerateContent：在生成回答时进行流式传输，以降低真人受众群体对于延迟的感知度。
    • generateContent：回答在完全生成后返回。
  • 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-vision
  • ROLE：与内容关联的对话中的角色。即使在单轮应用场景中，也需要指定角色。 可接受的值包括：
    • USER：指定由您发送的内容。
  • TEXT：要包含在提示中的文本说明。
  • B64_BASE：要在提示中包含内嵌的图片、PDF 或视频的 base64 编码。添加媒体内嵌时，您还必须指定 MIMETYPE。
  • FILE_URI：要包含在提示中的图片或视频的 Cloud Storage URI。存储该文件的存储桶必须位于发送请求的 Google Cloud 项目中。您还必须指定 MIMETYPE。
  • MIME_TYPE：在 data 或 fileUri 字段中指定的图片、PDF 或视频的媒体类型。可接受的值包括：

    点击即可展开 MIME 类型

    • application/pdf
    • audio/mpeg
    • audio/mp3
    • audio/wav
    • image/png
    • image/jpeg
    • text/plain
    • video/mov
    • video/mpeg
    • video/mp4
    • video/mpg
    • video/avi
    • video/wmv
    • video/mpegps
    • video/flv
  • 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 屏蔽得最少。
  • TEMPERATURE：温度 (temperature) 在生成回答期间用于采样，在应用 topP 和 topK 时会生成回答。温度可以控制词元选择的随机性。 较低的温度有利于需要更少开放性或创造性回复的提示，而较高的温度可以带来更具多样性或创造性的结果。温度为 0 表示始终选择概率最高的词元。在这种情况下，给定提示的回复大多是确定的，但可能仍然有少量变化。

    如果模型返回的回答过于笼统、过于简短，或者模型给出后备回答，请尝试提高温度。

  • TOP_P：Top-P 可更改模型选择输出词元的方式。系统会按照概率从最高（见 top-K）到最低的顺序选择词元，直到所选词元的概率总和等于 top-P 的值。例如，如果词元 A、B 和 C 的概率分别为 0.3、0.2 和 0.1，并且 top-P 值为 0.5，则模型将选择 A 或 B 作为下一个词元（通过温度确定），并会排除 C，将其作为候选词元。

    指定较低的值可获得随机程度较低的回答，指定较高的值可获得随机程度较高的回答。

  • TOP_K：Top-K 可更改模型选择输出词元的方式。如果 top-K 设为 1，表示所选词元是模型词汇表的所有词元中概率最高的词元（也称为贪心解码）。如果 top-K 设为 3，则表示系统将从 3 个概率最高的词元（通过温度确定）中选择下一个词元。

    在每个词元选择步骤中，系统都会对概率最高的 top-K 词元进行采样。然后，系统会根据 top-P 进一步过滤词元，并使用温度采样选择最终的词元。

    指定较低的值可获得随机程度较低的回答，指定较高的值可获得随机程度较高的回答。

  • MAX_OUTPUT_TOKENS：回答中可生成的词元数量上限。词元约为 4 个字符。100 个词元对应大约 60-80 个单词。

    指定较低的值可获得较短的回答，指定较高的值可获得可能较长的回答。

  • STOP_SEQUENCES：指定一个字符串列表，告知模型在响应中遇到其中一个字符串时，停止生成文本。如果某个字符串在响应中多次出现，则响应会在首次出现的位置截断。字符串区分大小写。

    例如，未指定 stopSequences 时，如果下面的内容是返回的回复：

    public static string reverse(string myString)

    则返回的回复为以下内容，其中 stopSequences 设置为 ["Str", "reverse"]：

    public static string

HTTP 方法和网址：

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

请求 JSON 正文： 

{
  "contents": {
    "role": "ROLE",
    "parts": [
      {
        "inlineDATA": {
          "mimeType": "MIME_TYPE",
          "data": "B64_BASE_IMAGE"
        }
      },
      {
        "fileData": {
          "mimeType": "MIME_TYPE",
          "fileUri": "FILE_URI"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  },
  "safety_settings": {
    "category": "SAFETY_CATEGORY",
    "threshold": "THRESHOLD"
  },
  "generation_config": {
    "temperature": TEMPERATURE,
    "topP": TOP_P,
    "topK": TOP_K,
    "candidateCount": 1,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "stopSequences": STOP_SEQUENCES,
  }
}

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

curl

将请求正文保存在名为 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:GENERATE_RESPONSE_METHOD"

PowerShell

将请求正文保存在名为 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:GENERATE_RESPONSE_METHOD" | Select-Object -Expand Content

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

示例 curl 命令

LOCATION="us-central1"
MODEL_ID="gemini-1.0-pro-vision"
PROJECT_ID="test-project"

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json"
https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:${GENERATE_RESPONSE_METHOD} -d \
$'{
  "contents": {
    "role": "user",
    "parts": [
      {
        "fileData": {
          "mimeType": "image/png",
          "fileUri": "gs://my-bucket/images/cat.png"
        }
      },
      {
        "text": "Describe this picture."
      },
    ]
  },
  "safety_settings": {
    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
    "threshold": "BLOCK_LOW_AND_ABOVE"
  },
  "generation_config": {
    "temperature": 0.4,
    "topP": 1,
    "topK": 32,
    "maxOutputTokens": 2048,
  }
}'

控制台

如需使用 Google Cloud 控制台发送多模态提示，请执行以下操作：

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

    转到 Vertex AI Studio

  2. 在提示设计（单轮）下，点击打开。

  3. 配置模型和参数：

    • 区域：选择您要使用的区域。
    • 模型：选择 Gemini Pro Vision。

    • 温度：使用滑块或文本框输入温度值。

      温度 (temperature) 在生成回复期间用于采样，在应用 topP 和 topK 时会生成回复。温度可以控制词元选择的随机性。 较低的温度有利于需要更少开放性或创造性回复的提示，而较高的温度可以带来更具多样性或创造性的结果。温度为 0 表示始终选择概率最高的词元。在这种情况下，给定提示的回复大多是确定的，但可能仍然有少量变化。

      如果模型返回的回答过于笼统、过于简短，或者模型给出后备回答，请尝试提高温度。

    • 词元上限：使用滑块或文本框输入输出上限值。

      回答中可生成的词元数量上限。词元约为 4 个字符。100 个词元对应大约 60-80 个单词。

      指定较低的值可获得较短的回答，指定较高的值可获得可能较长的回答。

    • 添加停止序列：输入停止序列，即模型遇到时停止回复的一系列字符（包括空格）。该序列不包含在回复中。您最多可以添加五个停止序列。
  4. 可选：如需配置高级参数，请点击高级，然后按如下方式进行配置：

    5. 点击即可展开高级配置

    • Top-K：使用滑块或文本框输入 top-K 值。

      Top-K 可更改模型选择输出词元的方式。如果 top-K 设为 1，表示所选词元是模型词汇表的所有词元中概率最高的词元（也称为贪心解码）。如果 top-K 设为 3，则表示系统将从 3 个概率最高的词元（通过温度确定）中选择下一个词元。

      在每个词元选择步骤中，系统都会对概率最高的 top-K 词元进行采样。然后，系统会根据 top-P 进一步过滤词元，并使用温度采样选择最终的词元。

      指定较低的值可获得随机程度较低的回答，指定较高的值可获得随机程度较高的回答。

    • Top-P：使用滑块或文本框输入 top-P 值。 系统会按照概率从最高到最低的顺序选择词元，直到所选词元的概率总和等于 top-P 的值。如需获得数量最小的变量结果，请将 top-P 设置为 0。

  5. Google Cloud 控制台仅支持流式传输，涉及在生成对提示的回答时接收这些回答。您现在可以在消息框中输入消息，以开始与模型对话。

    随后，模型会使用之前的消息作为新回复的语境。如需在提示中添加图片、PDF 或视频，请点击 图标。

    如需了解多模态提示，请参阅设计多模态提示。

  6. 可选：如需将提示保存到我的提示，请点击 保存。
  7. 可选：如需获取提示的 Python 代码或 curl 命令，请点击 获取代码。
  8. 可选：如需清除之前的所有消息，请点击 清除对话

单一音频

下面展示了如何使用音频文件来总结播客。 此示例仅适用于 Gemini 1.5 Pro。

Python

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generate_content 中的 stream 参数。

  response = model.generate_content(contents=[...], stream = True)

对于非流式回答，请移除该参数或将参数设置为 False。

示例代码


  import vertexai
  from vertexai.generative_models import GenerativeModel, Part

  # TODO(developer): Update and un-comment below lines
  # project_id = "PROJECT_ID"

  vertexai.init(project=project_id, location="us-central1")

  model = GenerativeModel(model_name="gemini-1.5-flash-001")

  prompt = """
  Please provide a summary for the audio.
  Provide chapter titles, be concise and short, no need to provide chapter summaries.
  Do not make up any information that is not part of the audio and do not be verbose.
"""

  audio_file_uri = "gs://cloud-samples-data/generative-ai/audio/pixel.mp3"
  audio_file = Part.from_uri(audio_file_uri, mime_type="audio/mpeg")

  contents = [audio_file, prompt]

  response = model.generate_content(contents)
  print(response.text)

高级示例

以下示例比前面的示例更复杂。

多张图片

以下各个标签页展示了在提示请求中添加多张图片的不同方式。这些图片示例适用于所有多模态 Gemini 模型。

Python

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generate_content 中的 stream 参数。

  response = model.generate_content(contents=[...], stream = True)

对于非流式回答，请移除该参数或将参数设置为 False。

示例代码

import vertexai

from vertexai.generative_models import GenerativeModel, Part

# TODO(developer): Update and un-comment below line
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

# Load images from Cloud Storage URI
image_file1 = Part.from_uri(
    "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark1.png",
    mime_type="image/png",
)
image_file2 = Part.from_uri(
    "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark2.png",
    mime_type="image/png",
)
image_file3 = Part.from_uri(
    "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark3.png",
    mime_type="image/png",
)

model = GenerativeModel(model_name="gemini-1.5-flash-001")
response = model.generate_content(
    [
        image_file1,
        "city: Rome, Landmark: the Colosseum",
        image_file2,
        "city: Beijing, Landmark: Forbidden City",
        image_file3,
    ]
)
print(response.text)

Java

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

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generateContentStream 方法。

  public ResponseStream generateContentStream(Content content)

对于非流式回答，请使用 generateContent 方法。

  public GenerateContentResponse generateContent(Content content)

示例代码

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.Content;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class MultimodalMultiImage {

  public static void main(String[] args) throws IOException {
    // 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-001";

    multimodalMultiImage(projectId, location, modelName);
  }

  // Generates content from multiple input images.
  public static void multimodalMultiImage(String projectId, String location, String modelName)
      throws IOException {
    // 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)) {
      GenerativeModel model = new GenerativeModel(modelName, vertexAI);

      Content content = ContentMaker.fromMultiModalData(
          PartMaker.fromMimeTypeAndData("image/png", readImageFile(
              "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png")),
          "city: Rome, Landmark: the Colosseum",
          PartMaker.fromMimeTypeAndData("image/png", readImageFile(
              "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png")),
          "city: Beijing, Landmark: Forbidden City",
          PartMaker.fromMimeTypeAndData("image/png", readImageFile(
              "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png"))
      );

      GenerateContentResponse response = model.generateContent(content);

      String output = ResponseHandler.getText(response);
      System.out.println(output);
    }
  }

  // Reads the image data from the given URL.
  public static byte[] readImageFile(String url) throws IOException {
    URL urlObj = new URL(url);
    HttpURLConnection connection = (HttpURLConnection) urlObj.openConnection();
    connection.setRequestMethod("GET");

    int responseCode = connection.getResponseCode();

    if (responseCode == HttpURLConnection.HTTP_OK) {
      InputStream inputStream = connection.getInputStream();
      ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

      byte[] buffer = new byte[1024];
      int bytesRead;
      while ((bytesRead = inputStream.read(buffer)) != -1) {
        outputStream.write(buffer, 0, bytesRead);
      }

      return outputStream.toByteArray();
    } else {
      throw new RuntimeException("Error fetching file: " + responseCode);
    }
  }
}

Node.js

在尝试此示例之前，请按照《生成式 AI 快速入门：使用 Node.js SDK》中的 Node.js 设置说明执行操作。如需了解详情，请参阅适用于 Gemini 的 Node.js SDK 参考文档。

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generateContentStream 方法。

  const streamingResp = await generativeModel.generateContentStream(request);

对于非流式回答，请使用 generateContent 方法。

  const streamingResp = await generativeModel.generateContent(request);

示例代码

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

async function getBase64(url) {
  const image = await axios.get(url, {responseType: 'arraybuffer'});
  return Buffer.from(image.data).toString('base64');
}

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function sendMultiModalPromptWithImage(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.0-pro-vision-001'
) {
  // For images, the SDK supports base64 strings
  const landmarkImage1 = await getBase64(
    'https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png'
  );
  const landmarkImage2 = await getBase64(
    'https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png'
  );
  const landmarkImage3 = await getBase64(
    'https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png'
  );

  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  const generativeVisionModel = vertexAI.getGenerativeModel({
    model: model,
  });

  // Pass multimodal prompt
  const request = {
    contents: [
      {
        role: 'user',
        parts: [
          {
            inlineData: {
              data: landmarkImage1,
              mimeType: 'image/png',
            },
          },
          {
            text: 'city: Rome, Landmark: the Colosseum',
          },

          {
            inlineData: {
              data: landmarkImage2,
              mimeType: 'image/png',
            },
          },
          {
            text: 'city: Beijing, Landmark: Forbidden City',
          },
          {
            inlineData: {
              data: landmarkImage3,
              mimeType: 'image/png',
            },
          },
        ],
      },
    ],
  };

  // Create the response
  const response = await generativeVisionModel.generateContent(request);
  // Wait for the response to complete
  const aggregatedResponse = await response.response;
  // Select the text from the response
  const fullTextResponse =
    aggregatedResponse.candidates[0].content.parts[0].text;

  console.log(fullTextResponse);
}

Go

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

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 GenerateContentStream 方法。

  iter := model.GenerateContentStream(ctx, genai.Text("Tell me a story about a lumberjack and his giant ox. Keep it very short."))

对于非流式回答，请使用 GenerateContent 方法。

  resp, err := model.GenerateContent(ctx, genai.Text("What is the average size of a swallow?"))

示例代码

import (
	"context"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"os"
	"strings"

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

func main() {
	projectID := os.Getenv("GOOGLE_CLOUD_PROJECT")
	location := "us-central1"
	modelName := "gemini-1.0-pro-vision"
	temperature := 0.4

	if projectID == "" {
		log.Fatal("require environment variable GOOGLE_CLOUD_PROJECT")
	}

	// construct this multimodal prompt:
	// [image of colosseum] city: Rome, Landmark: the Colosseum
	// [image of forbidden city]  city: Beijing, Landmark: the Forbidden City
	// [new image]

	// create prompt image parts
	// colosseum
	colosseum, err := partFromImageURL("https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png")
	if err != nil {
		log.Fatalf("unable to read image: %v", err)
	}
	// forbidden city
	forbiddenCity, err := partFromImageURL("https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png")
	if err != nil {
		log.Fatalf("unable to read image: %v", err)
	}
	// new image
	newImage, err := partFromImageURL("https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png")
	if err != nil {
		log.Fatalf("unable to read image: %v", err)
	}

	// create a multimodal (multipart) prompt
	prompt := []genai.Part{
		colosseum,
		genai.Text("city: Rome, Landmark: the Colosseum "),
		forbiddenCity,
		genai.Text("city: Beijing, Landmark: the Forbidden City "),
		newImage,
	}

	// generate the response
	err = generateMultimodalContent(os.Stdout, prompt, projectID, location, modelName, float32(temperature))
	if err != nil {
		log.Fatalf("unable to generate: %v", err)
	}
}

// generateMultimodalContent provide a generated response using multimodal input
func generateMultimodalContent(w io.Writer, parts []genai.Part, projectID, location, modelName string, temperature float32) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	model := client.GenerativeModel(modelName)
	model.SetTemperature(temperature)

	res, err := model.GenerateContent(ctx, parts...)
	if err != nil {
		return fmt.Errorf("unable to generate contents: %v", err)
	}

	fmt.Fprintf(w, "generated response: %s\n", res.Candidates[0].Content.Parts[0])

	return nil
}

// partFromImageURL create a multimodal prompt part from an image URL
func partFromImageURL(image string) (genai.Part, error) {
	var img genai.Blob

	imageURL, err := url.Parse(image)
	if err != nil {
		return img, err
	}
	res, err := http.Get(image)
	if err != nil || res.StatusCode != 200 {
		return img, err
	}
	defer res.Body.Close()
	data, err := io.ReadAll(res.Body)
	if err != nil {
		return img, fmt.Errorf("unable to read from http: %v", err)
	}

	position := strings.LastIndex(imageURL.Path, ".")
	if position == -1 {
		return img, fmt.Errorf("couldn't find a period to indicate a file extension")
	}
	ext := imageURL.Path[position+1:]

	img = genai.ImageData(ext, data)
	return img, nil
}

C#

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

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


using Google.Api.Gax.Grpc;
using Google.Cloud.AIPlatform.V1;
using Google.Protobuf;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

public class MultimodalMultiImage
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.0-pro-vision"
    )
    {
        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        ByteString colosseum = await ReadImageFileAsync(
            "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png");

        ByteString forbiddenCity = await ReadImageFileAsync(
            "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png");

        ByteString christRedeemer = await ReadImageFileAsync(
            "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png");

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { InlineData = new() { MimeType = "image/png", Data = colosseum }},
                        new Part { Text = "city: Rome, Landmark: the Colosseum" },
                        new Part { InlineData = new() { MimeType = "image/png", Data = forbiddenCity }},
                        new Part { Text = "city: Beijing, Landmark: Forbidden City"},
                        new Part { InlineData = new() { MimeType = "image/png", Data = christRedeemer }}
                    }
                }
            }
        };

        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        AsyncResponseStream<GenerateContentResponse> responseStream = response.GetResponseStream();
        await foreach (GenerateContentResponse responseItem in responseStream)
        {
            fullText.Append(responseItem.Candidates[0].Content.Parts[0].Text);
        }
        return fullText.ToString();
    }

    private static async Task<ByteString> ReadImageFileAsync(string url)
    {
        using HttpClient client = new();
        using var response = await client.GetAsync(url);
        byte[] imageBytes = await response.Content.ReadAsByteArrayAsync();
        return ByteString.CopyFrom(imageBytes);
    }
}

REST

您可以使用 REST 测试文本提示，方法是使用 Vertex AI API 向发布方模型端点发送 POST 请求。

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

  • GENERATE_RESPONSE_METHOD：您希望模型生成的回答类型。选择一种方法来生成您希望返回模型回答的方式：
    • streamGenerateContent：在生成回答时进行流式传输，以降低真人受众群体对于延迟的感知度。
    • generateContent：回答在完全生成后返回。
  • 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-vision
  • ROLE：与内容关联的对话中的角色。即使在单轮应用场景中，也需要指定角色。 可接受的值包括：
    • USER：指定由您发送的内容。
  • TEXT：要包含在提示中的文本说明。
  • B64_BASE：要在提示中包含内嵌的图片、PDF 或视频的 base64 编码。添加媒体内嵌时，您还必须指定 MIMETYPE。
  • FILE_URI：要包含在提示中的图片或视频的 Cloud Storage URI。存储该文件的存储桶必须位于发送请求的 Google Cloud 项目中。您还必须指定 MIMETYPE。
  • MIME_TYPE：在 data 或 fileUri 字段中指定的图片、PDF 或视频的媒体类型。可接受的值包括：

    点击即可展开 MIME 类型

    • application/pdf
    • audio/mpeg
    • audio/mp3
    • audio/wav
    • image/png
    • image/jpeg
    • text/plain
    • video/mov
    • video/mpeg
    • video/mp4
    • video/mpg
    • video/avi
    • video/wmv
    • video/mpegps
    • video/flv
  • 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 屏蔽得最少。
  • TEMPERATURE：温度 (temperature) 在生成回答期间用于采样，在应用 topP 和 topK 时会生成回答。温度可以控制词元选择的随机性。 较低的温度有利于需要更少开放性或创造性回复的提示，而较高的温度可以带来更具多样性或创造性的结果。温度为 0 表示始终选择概率最高的词元。在这种情况下，给定提示的回复大多是确定的，但可能仍然有少量变化。

    如果模型返回的回答过于笼统、过于简短，或者模型给出后备回答，请尝试提高温度。

  • TOP_P：Top-P 可更改模型选择输出词元的方式。系统会按照概率从最高（见 top-K）到最低的顺序选择词元，直到所选词元的概率总和等于 top-P 的值。例如，如果词元 A、B 和 C 的概率分别为 0.3、0.2 和 0.1，并且 top-P 值为 0.5，则模型将选择 A 或 B 作为下一个词元（通过温度确定），并会排除 C，将其作为候选词元。

    指定较低的值可获得随机程度较低的回答，指定较高的值可获得随机程度较高的回答。

  • TOP_K：Top-K 可更改模型选择输出词元的方式。如果 top-K 设为 1，表示所选词元是模型词汇表的所有词元中概率最高的词元（也称为贪心解码）。如果 top-K 设为 3，则表示系统将从 3 个概率最高的词元（通过温度确定）中选择下一个词元。

    在每个词元选择步骤中，系统都会对概率最高的 top-K 词元进行采样。然后，系统会根据 top-P 进一步过滤词元，并使用温度采样选择最终的词元。

    指定较低的值可获得随机程度较低的回答，指定较高的值可获得随机程度较高的回答。

  • MAX_OUTPUT_TOKENS：回答中可生成的词元数量上限。词元约为 4 个字符。100 个词元对应大约 60-80 个单词。

    指定较低的值可获得较短的回答，指定较高的值可获得可能较长的回答。

  • STOP_SEQUENCES：指定一个字符串列表，告知模型在响应中遇到其中一个字符串时，停止生成文本。如果某个字符串在响应中多次出现，则响应会在首次出现的位置截断。字符串区分大小写。

    例如，未指定 stopSequences 时，如果下面的内容是返回的回复：

    public static string reverse(string myString)

    则返回的回复为以下内容，其中 stopSequences 设置为 ["Str", "reverse"]：

    public static string

HTTP 方法和网址：

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

请求 JSON 正文： 

{
  "contents": {
    "role": "ROLE",
    "parts": [
      {
        "inlineDATA": {
          "mimeType": "MIME_TYPE",
          "data": "B64_BASE_IMAGE"
        }
      },
      {
        "fileData": {
          "mimeType": "MIME_TYPE",
          "fileUri": "FILE_URI"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  },
  "safety_settings": {
    "category": "SAFETY_CATEGORY",
    "threshold": "THRESHOLD"
  },
  "generation_config": {
    "temperature": TEMPERATURE,
    "topP": TOP_P,
    "topK": TOP_K,
    "candidateCount": 1,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "stopSequences": STOP_SEQUENCES,
  }
}

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

curl

将请求正文保存在名为 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:GENERATE_RESPONSE_METHOD"

PowerShell

将请求正文保存在名为 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:GENERATE_RESPONSE_METHOD" | Select-Object -Expand Content

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

示例 curl 命令

LOCATION="us-central1"
MODEL_ID="gemini-1.0-pro-vision"
PROJECT_ID="test-project"

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json"
https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:${GENERATE_RESPONSE_METHOD} -d \
$'{
  "contents": {
    "role": "user",
    "parts": [
      {
        "fileData": {
          "mimeType": "image/png",
          "fileUri": "gs://my-bucket/images/cat.png"
        }
      },
      {
        "text": "Describe this picture."
      },
    ]
  },
  "safety_settings": {
    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
    "threshold": "BLOCK_LOW_AND_ABOVE"
  },
  "generation_config": {
    "temperature": 0.4,
    "topP": 1,
    "topK": 32,
    "maxOutputTokens": 2048,
  }
}'

控制台

如需使用 Google Cloud 控制台发送多模态提示，请执行以下操作：

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

    转到 Vertex AI Studio

  2. 在提示设计（单轮）下，点击打开。

  3. 配置模型和参数：

    • 区域：选择您要使用的区域。
    • 模型：选择 Gemini Pro Vision。

    • 温度：使用滑块或文本框输入温度值。

      温度 (temperature) 在生成回复期间用于采样，在应用 topP 和 topK 时会生成回复。温度可以控制词元选择的随机性。 较低的温度有利于需要更少开放性或创造性回复的提示，而较高的温度可以带来更具多样性或创造性的结果。温度为 0 表示始终选择概率最高的词元。在这种情况下，给定提示的回复大多是确定的，但可能仍然有少量变化。

      如果模型返回的回答过于笼统、过于简短，或者模型给出后备回答，请尝试提高温度。

    • 词元上限：使用滑块或文本框输入输出上限值。

      回答中可生成的词元数量上限。词元约为 4 个字符。100 个词元对应大约 60-80 个单词。

      指定较低的值可获得较短的回答，指定较高的值可获得可能较长的回答。

    • 添加停止序列：输入停止序列，即模型遇到时停止回复的一系列字符（包括空格）。该序列不包含在回复中。您最多可以添加五个停止序列。
  4. 可选：如需配置高级参数，请点击高级，然后按如下方式进行配置：

    5. 点击即可展开高级配置

    • Top-K：使用滑块或文本框输入 top-K 值。

      Top-K 可更改模型选择输出词元的方式。如果 top-K 设为 1，表示所选词元是模型词汇表的所有词元中概率最高的词元（也称为贪心解码）。如果 top-K 设为 3，则表示系统将从 3 个概率最高的词元（通过温度确定）中选择下一个词元。

      在每个词元选择步骤中，系统都会对概率最高的 top-K 词元进行采样。然后，系统会根据 top-P 进一步过滤词元，并使用温度采样选择最终的词元。

      指定较低的值可获得随机程度较低的回答，指定较高的值可获得随机程度较高的回答。

    • Top-P：使用滑块或文本框输入 top-P 值。 系统会按照概率从最高到最低的顺序选择词元，直到所选词元的概率总和等于 top-P 的值。如需获得数量最小的变量结果，请将 top-P 设置为 0。

  5. Google Cloud 控制台仅支持流式传输，涉及在生成对提示的回答时接收这些回答。您现在可以在消息框中输入消息，以开始与模型对话。

    随后，模型会使用之前的消息作为新回复的语境。如需在提示中添加图片、PDF 或视频，请点击 图标。

    如需了解多模态提示，请参阅设计多模态提示。

  6. 可选：如需将提示保存到我的提示，请点击 保存。
  7. 可选：如需获取提示的 Python 代码或 curl 命令，请点击 获取代码。
  8. 可选：如需清除之前的所有消息，请点击 清除对话

音频转写

下面展示了如何使用音频文件转写面试内容。 此示例仅适用于 Gemini 1.5 Pro。

Go

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

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 GenerateContentStream 方法。

  iter := model.GenerateContentStream(ctx, genai.Text("Tell me a story about a lumberjack and his giant ox. Keep it very short."))

对于非流式回答，请使用 GenerateContent 方法。

  resp, err := model.GenerateContent(ctx, genai.Text("What is the average size of a swallow?"))

示例代码

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

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

// audioPrompt is a sample prompt type consisting of one audio asset, and a text question.
type audioPrompt struct {
	// audio is a Google Cloud Storage path starting with "gs://"
	audio string
	// question asked to the model
	question string
}

// transcribeAudio generates a response into w, based upon the prompt
// and audio provided.
// audio is a Google Cloud Storage path starting with "gs://"
func transcribeAudio(w io.Writer, prompt audioPrompt, projectID, location, modelName string) error {
	// prompt := audioPrompt{
	// 	audio: "gs://cloud-samples-data/generative-ai/audio/pixel.mp3",
	// 	question: `
	// 		Can you transcribe this interview, in the format of timecode, speaker, caption.
	// 		Use speaker A, speaker B, etc. to identify speakers.
	// 	`,
	// },
	// location := "us-central1"
	// modelName := "gemini-1.5-pro-preview-0409"
	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)

	// Optional: set an explicit temperature
	model.SetTemperature(0.4)

	// Given an audio file URL, prepare audio file as genai.Part
	img := genai.FileData{
		MIMEType: mime.TypeByExtension(filepath.Ext(prompt.audio)),
		FileURI:  prompt.audio,
	}

	res, err := model.GenerateContent(ctx, img, genai.Text(prompt.question))
	if err != nil {
		return fmt.Errorf("unable to generate contents: %w", err)
	}

	if len(res.Candidates) == 0 ||
		len(res.Candidates[0].Content.Parts) == 0 {
		return errors.New("empty response from model")
	}

	fmt.Fprintf(w, "generated transcript:\n%s\n", res.Candidates[0].Content.Parts[0])
	return nil
}

C#

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

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


using Google.Cloud.AIPlatform.V1;
using System;
using System.Threading.Tasks;

public class AudioInputTranscription
{
    public async Task<string> TranscribeAudio(
        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();

        string prompt = @"Can you transcribe this interview, in the format of timecode, speaker, caption.
Use speaker A, speaker B, etc. to identify speakers.";

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = prompt },
                        new Part { FileData = new() { MimeType = "audio/mp3", FileUri = "gs://cloud-samples-data/generative-ai/audio/pixel.mp3" } }
                    }
                }
            }
        };

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);

        return responseText;
    }
}

带音频的视频

下面展示了如何总结包含音频的视频文件，并返回带有时间戳的章节。此示例仅适用于 Gemini 1.5 Pro。

Python

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generate_content 中的 stream 参数。

  response = model.generate_content(contents=[...], stream = True)

对于非流式回答，请移除该参数或将参数设置为 False。

示例代码


import vertexai
from vertexai.generative_models import GenerativeModel, Part

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

model = GenerativeModel(model_name="gemini-1.5-flash-001")

prompt = """
Provide a description of the video.
The description should also contain anything important which people say in the video.
"""

video_file_uri = "gs://cloud-samples-data/generative-ai/video/pixel8.mp4"
video_file = Part.from_uri(video_file_uri, mime_type="video/mp4")

contents = [video_file, prompt]

response = model.generate_content(contents)
print(response.text)

Java

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

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generateContentStream 方法。

  public ResponseStream generateContentStream(Content content)

对于非流式回答，请使用 generateContent 方法。

  public GenerateContentResponse generateContent(Content content)

示例代码


import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.IOException;

public class VideoInputWithAudio {

  public static void main(String[] args) throws IOException {
    // 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";

    videoAudioInput(projectId, location, modelName);
  }

  // Analyzes the given video input, including its audio track.
  public static String videoAudioInput(String projectId, String location, String modelName)
      throws IOException {
    // 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)) {
      String videoUri = "gs://cloud-samples-data/generative-ai/video/pixel8.mp4";

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              "Provide a description of the video.\n The description should also "
                  + "contain anything important which people say in the video.",
              PartMaker.fromMimeTypeAndData("video/mp4", videoUri)
          ));

      String output = ResponseHandler.getText(response);
      System.out.println(output);

      return output;
    }
  }
}

Node.js

在尝试此示例之前，请按照《生成式 AI 快速入门：使用 Node.js SDK》中的 Node.js 设置说明执行操作。如需了解详情，请参阅适用于 Gemini 的 Node.js SDK 参考文档。

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generateContentStream 方法。

  const streamingResp = await generativeModel.generateContentStream(request);

对于非流式回答，请使用 generateContent 方法。

  const streamingResp = await generativeModel.generateContent(request);

示例代码

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

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function analyze_video_with_audio(projectId = 'PROJECT_ID') {
  const vertexAI = new VertexAI({project: projectId, location: 'us-central1'});

  const generativeModel = vertexAI.getGenerativeModel({
    model: 'gemini-1.5-pro-preview-0409',
  });

  const filePart = {
    file_data: {
      file_uri: 'gs://cloud-samples-data/generative-ai/video/pixel8.mp4',
      mime_type: 'video/mp4',
    },
  };
  const textPart = {
    text: `
    Provide a description of the video.
    The description should also contain anything important which people say in the video.`,
  };

  const request = {
    contents: [{role: 'user', parts: [filePart, textPart]}],
  };

  const resp = await generativeModel.generateContent(request);
  const contentResponse = await resp.response;
  console.log(JSON.stringify(contentResponse));
}

C#

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

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


using Google.Cloud.AIPlatform.V1;
using System;
using System.Threading.Tasks;

public class VideoInputWithAudio
{
    public async Task<string> DescribeVideo(
        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();

        string prompt = @"Provide a description of the video.
The description should also contain anything important which people say in the video.";

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = prompt },
                        new Part { FileData = new() { MimeType = "video/mp4", FileUri = "gs://cloud-samples-data/generative-ai/video/pixel8.mp4" }}
                    }
                }
            }
        };

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);

        return responseText;
    }
}

所有模态

以下示例展示了如何同时处理图片、视频、音频和文本。此示例适用于 Gemini 1.5 Pro 和 Gemini 1.5 Flash。

Python

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generate_content 中的 stream 参数。

  response = model.generate_content(contents=[...], stream = True)

对于非流式回答，请移除该参数或将参数设置为 False。

示例代码


  import vertexai
  from vertexai.generative_models import GenerativeModel, Part

  # TODO(developer): Update and un-comment below lines
  # project_id = "PROJECT_ID"

  vertexai.init(project=project_id, location="us-central1")

  model = GenerativeModel(model_name="gemini-1.5-flash-001")

  video_file_uri = (
      "gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4"
  )
  video_file = Part.from_uri(video_file_uri, mime_type="video/mp4")

  image_file_uri = "gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png"
  image_file = Part.from_uri(image_file_uri, mime_type="image/png")

  prompt = """
  Watch each frame in the video carefully and answer the questions.
  Only base your answers strictly on what information is available in the video attached.
  Do not make up any information that is not part of the video and do not be too
  verbose, be to the point.

  Questions:
  - When is the moment in the image happening in the video? Provide a timestamp.
  - What is the context of the moment and what does the narrator say about it?
"""

  contents = [
      video_file,
      image_file,
      prompt,
  ]

  response = model.generate_content(contents)
  print(response.text)

Java

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

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generateContentStream 方法。

  public ResponseStream generateContentStream(Content content)

对于非流式回答，请使用 generateContent 方法。

  public GenerateContentResponse generateContent(Content content)

示例代码


import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.IOException;

public class MultimodalAllInput {

  public static void main(String[] args) throws IOException {
    // 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";

    multimodalAllInput(projectId, location, modelName);
  }

  // A request containing a text prompt, a video, and a picture.
  public static String multimodalAllInput(String projectId, String location, String modelName)
      throws IOException {
    // 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)) {
      String videoUri = "gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4";
      String imageUri = "gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png";

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              PartMaker.fromMimeTypeAndData("video/mp4", videoUri),
              PartMaker.fromMimeTypeAndData("image/png", imageUri),
              "Watch each frame in the video carefully and answer the questions.\n"
                  + "Only base your answers strictly on what information is available in "
                  + "the video attached. Do not make up any information that is not part "
                  + "of the video and do not be too verbose, be to the point.\n\n"
                  + "Questions:\n"
                  + "- When is the moment in the image happening in the video? "
                  + "Provide a timestamp.\n"
                  + "- What is the context of the moment and what does the narrator say about it?"
          ));

      String output = ResponseHandler.getText(response);
      System.out.println(output);

      return output;
    }
  }
}

Node.js

在尝试此示例之前，请按照《生成式 AI 快速入门：使用 Node.js SDK》中的 Node.js 设置说明执行操作。如需了解详情，请参阅适用于 Gemini 的 Node.js SDK 参考文档。

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

流式回答和非流式回答

您可以选择模型是生成流式回答还是非流式回答。流式传输涉及在生成对提示的回答时接收这些回答。也就是说，只要模型生成输出词元，就会发送这些输出词元。只有在生成所有输出词元后，才会发送对提示的非流式回答。

对于流式回答，请使用 generateContentStream 方法。

  const streamingResp = await generativeModel.generateContentStream(request);

对于非流式回答，请使用 generateContent 方法。

  const streamingResp = await generativeModel.generateContent(request);

示例代码

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

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function analyze_all_modalities(projectId = 'PROJECT_ID') {
  const vertexAI = new VertexAI({project: projectId, location: 'us-central1'});

  const generativeModel = vertexAI.getGenerativeModel({
    model: 'gemini-1.5-pro-preview-0409',
  });

  const videoFilePart = {
    file_data: {
      file_uri:
        'gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4',
      mime_type: 'video/mp4',
    },
  };
  const imageFilePart = {
    file_data: {
      file_uri:
        'gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png',
      mime_type: 'image/png',
    },
  };

  const textPart = {
    text: `
    Watch each frame in the video carefully and answer the questions.
    Only base your answers strictly on what information is available in the video attached.
    Do not make up any information that is not part of the video and do not be too
    verbose, be to the point.

    Questions:
    - When is the moment in the image happening in the video? Provide a timestamp.
    - What is the context of the moment and what does the narrator say about it?`,
  };

  const request = {
    contents: [{role: 'user', parts: [videoFilePart, imageFilePart, textPart]}],
  };

  const resp = await generativeModel.generateContent(request);
  const contentResponse = await resp.response;
  console.log(JSON.stringify(contentResponse));
}

C#

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

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


using Google.Cloud.AIPlatform.V1;
using System;
using System.Threading.Tasks;

public class MultimodalAllInput
{
    public async Task<string> AnswerFromMultimodalInput(
        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();

        string prompt = "Watch each frame in the video carefully and answer the questions.\n"
                  + "Only base your answers strictly on what information is available in "
                  + "the video attached. Do not make up any information that is not part "
                  + "of the video and do not be too verbose, be to the point.\n\n"
                  + "Questions:\n"
                  + "- When is the moment in the image happening in the video? "
                  + "Provide a timestamp.\n"
                  + "- What is the context of the moment and what does the narrator say about it?";

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = prompt },
                        new Part { FileData = new() { MimeType = "video/mp4", FileUri = "gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4" } },
                        new Part { FileData = new() { MimeType = "image/png", FileUri = "gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png" } }
                    }
                }
            }
        };

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);

        return responseText;
    }
}

设置模型参数

可以对多模态模型设置以下模型参数：

Top-P

Top-P 可更改模型选择输出词元的方式。系统会按照概率从最高（见 top-K）到最低的顺序选择词元，直到所选词元的概率总和等于 top-P 的值。例如，如果词元 A、B 和 C 的概率分别为 0.3、0.2 和 0.1，并且 top-P 值为 0.5，则模型将选择 A 或 B 作为下一个词元（通过温度确定），并会排除 C，将其作为候选词元。

指定较低的值可获得随机程度较低的回答，指定较高的值可获得随机程度较高的回答。

Top-K

Top-K 可更改模型选择输出词元的方式。如果 top-K 设为 1，表示所选词元是模型词汇表的所有词元中概率最高的词元（也称为贪心解码）。如果 top-K 设为 3，则表示系统将从 3 个概率最高的词元（通过温度确定）中选择下一个词元。

在每个词元选择步骤中，系统都会对概率最高的 top-K 词元进行采样。然后，系统会根据 top-P 进一步过滤词元，并使用温度采样选择最终的词元。

指定较低的值可获得随机程度较低的回答，指定较高的值可获得随机程度较高的回答。

温度

温度 (temperature) 在生成回复期间用于采样，在应用 topP 和 topK 时会生成回复。温度可以控制词元选择的随机性。 较低的温度有利于需要更少开放性或创造性回复的提示，而较高的温度可以带来更具多样性或创造性的结果。温度为 0 表示始终选择概率最高的词元。在这种情况下，给定提示的回复大多是确定的，但可能仍然有少量变化。

如果模型返回的回答过于笼统、过于简短，或者模型给出后备回答，请尝试提高温度。

有效的参数值

参数 Gemini 1.0 Pro Vision Gemini 1.5 Pro Gemini 1.5 Flash
Top-K 1 - 40（默认为 32） 不支持 不支持
Top-P 0 - 1.0（默认 1.0） 0 - 1.0（默认 0.95） 0 - 1.0（默认 0.95）
温度 0 - 1.0（默认 0.4） 0 - 2.0（默认 1.0） 0 - 2.0（默认 1.0）

媒体要求

在提示请求中使用媒体文件时，请确保其符合以下要求：

图片要求

多模态 Gemini 模型支持以下图片 MIME 类型：

图片 Mime 类型 Gemini 1.5 Flash Gemini 1.5 Pro Gemini 1.0 Pro Vision
PNG - image/png
JPEG - image/jpeg

对图片中的像素数量没有具体限制。不过，较大的图片会被缩小和填充，以适应最大分辨率 (3072 x 3072)，同时保留其原始宽高比。

对于 Gemini 1.0 Pro Vision，每张图片占 258 个词元。

对于 Gemini 1.5 Flash 和 Gemini 1.5 Pro：

  • 如果图片的宽高比的两个维度小于或等于 384，则使用 258 个词元。
  • 如果图片宽高比的某个维度大于 384，则图片会被剪裁成图块。每个图块大小默认为最小维度（宽度或高度）除以 1.5。如有必要，系统会调整每个图块，使其不小于 256 且不大于 768。随后系统会将每个图块的大小调整为 768x768，并使用 258 个词元。

问题请求中的图片数量上限为：

  • 16（针对 Gemini 1.0 Pro Vision）
  • 3,000（针对 Gemini 1.5 Flash 和 Gemini 1.5 Pro）

音频要求

Gemini 1.5 Flash 和 Gemini 1.5 Pro 支持以下音频 MIME 类型。 Gemini 1.0 Pro Vision 不支持音频。

音频 MIME 类型 Gemini 1.5 Flash Gemini 1.5 Pro Gemini 1.0 Pro Vision
AAC - audio/aac
FLAC - audio/flac
MP3 - audio/mp3
MPA - audio/m4a
MPEG - audio/mpeg
MPGA - audio/mpga
MP4 - audio/mp4
OPUS - audio/opus
PCM - audio/pcm
WAV - audio/wav
WEBM - audio/webm

视频要求

视频采样率为 1fps。每个视频帧占 258 个词元。

对于 Gemini 1.5 Flash 和 Gemini 1.5 Pro，音轨随视频帧一起进行编码。音轨还会拆分为时长 1 秒的主干，每个主干占 32 个词元。视频帧和音频词元与其时间戳交错在一起。时间戳表示为 7 个词元。

多模态 Gemini 模型支持以下视频 MIME 类型：

视频 MIME 类型 Gemini 1.5 Flash Gemini 1.5 Pro Gemini 1.0 Pro Vision
FLV - video/x-flv
MOV - video/mov
MPEG - video/mpeg
MPEGPS - video/mpegps
MPG - video/mpg
MP4 - video/mp4
WEBM - video/webm
WMV - video/wmv
3GPP - video/3gpp

PDF 文件要求

PDF 文件所需的 MIME 类型为 application/pdf。

最佳实践

本部分介绍了适用于不同模态的最佳实践。

图片最佳做法

使用图片时，请遵循以下最佳实践和信息以获得最佳结果。

  • 如果您想要检测图片中的文本，则使用包含单张图片的提示可生成比包含多张图片的提示更好的结果。
  • 如果提示包含单张图片，请将该图片放在文本提示前面。

  • 如果提示中有多个图片，并且您希望稍后在提示中引用这些图片，或者希望模型在模型响应中引用这些图片，则在图片之前为每张图片提供索引会有所帮助。对于索引，请使用 a b c 或 image 1 image 2 image 3。以下是在提示中使用已编入索引的图片的示例：

    image 1 <piano_recital.jpeg>
image 2 <family_dinner.jpeg>
image 3 <coffee_shop.jpeg>

Write a blogpost about my day using image 1 and image 2. Then, give me ideas
for tomorrow based on image 3.

  • 图片分辨率越高，效果越好。

  • 在提示中添加一些示例。

  • 请先将图片旋转到适当方向，然后再将其添加到提示中。

  • 避免使用模糊的图片。

视频最佳实践

使用视频时，请遵循以下最佳实践和信息以获得最佳结果：

  • 每个提示最多使用一个视频。
  • 如果提示包含单个视频，请将该视频放在文本提示前面。
  • 如果您使用的是 Gemini 1.0 Pro Vision，则模型会将视频作为视频中的非连续图片帧进行处理。音频不包括音频。 如果您发现模型从视频中缺少某些内容，请尝试缩短视频，以便模型捕获更多视频内容。
  • 如果您使用的是 Gemini 1.0 Pro Vision，则模型仅处理前两分钟的信息。
  • 如果您使用的是 Gemini 1.0 Pro Vision，则模型不会分析任何音频信息或时间戳元数据。因此，在需要音频输入（例如为音频添加字幕）或时间相关信息（例如速度或节奏）的用例中，模型可能表现不佳。
  • 如果需要对包含音频的视频进行时间戳本地化，请让模型生成 MM:SS 格式的时间戳，其中前两位数表示分钟，后两位数表示秒。对于询问时间戳的问题，请使用相同的格式。

PDF 文件最佳实践

使用 PDF 文件时，请遵循以下最佳实践和信息以获得最佳结果：

  • PDF 文件被视为图片，因此 PDF 文件的单页被视为一张图片。
    • 支持的页面数取决于模型可以支持的图片数量。对于 Gemini 1.0 Pro Vision，上限为 16。对于 Gemini 1.5 Pro 和 Gemini 1.5 Flash，上限为 300。如果您的文档很长，请考虑将其拆分为多个 PDF 进行处理。
    • 使用 PDF 作为输入时，费用遵循 Gemini 图片价格。例如，如果您在 Gemini API 调用中包含一个两页的 PDF 文件，则会产生处理两张图片的输入费用。
  • 如果提示包含单个 PDF 文件，请将 PDF 文件放在文本提示前面。
  • 使用以文本形式呈现的 PDF 文件，而不是使用扫描图片中的文本。此格式可确保文本是机器可读的，与扫描的图片 PDF 相比，文本更易于模型修改、搜索和操作。在使用合同等包含大量文本的文档时，这样可以提供最佳结果。

如需了解更多多模态提示，请参阅设计多模态提示。

多模态限制

虽然 Gemini 多模态模型在许多多模态用户案例中表现出强大功能，但了解模型的限制非常重要：

  • 空间推理：模型在定位图片和 PDF 文件中的文本或对象时并不精确。它们可能只返回对象数的近似值。
  • 医疗用途：模型不适合解读医学图片（例如 X 光片和 CT 扫描），也不适合提供医学建议。
  • 人物识别：模型不应用于识别图片中并非名人的人。
  • 内容审核：模型拒绝对违反我们安全政策的图片或视频提供回答。
  • 准确率：模型在解读低画质、旋转或分辨率极低的图片时可能会产生幻觉或出错。在解读图片或 PDF 文档中的手写文本时，模型也可能会产生幻觉。
  • 非语音声音识别：支持音频的模型可能会在识别非语音声音时犯错。
  • 高速运动：由于固定的每秒 1 帧 (fps) 采样率，因此模型在理解视频中的高速运动时可能会出错。
  • 仅音频的时间戳：支持音频的模型无法为带有音频文件的请求准确生成时间戳。这包括细分和时间本地化时间戳。对于带有包含音频的视频的输入，可以准确生成时间戳。
  • 转写标点符号：Gemini 1.5 Flash 返回的转写内容可能不包含标点符号。

后续步骤