マルチモーダルプロンプトリクエストを送信する

Gemini モデルファミリーには、マルチモーダルプロンプトリクエストに対応するモデルが含まれています。マルチモーダルとは、プロンプトで複数のモダリティ（入力タイプ）を使用できることを示します。マルチモーダルではないモデルは、テキストのみのプロンプトを受け入れます。モダリティには、テキスト、音声、動画などがあります。

Gemini API を使用してマルチモーダルソリューションを実装する方法はいくつかあります。たとえば、Python、Node.js、Java、Go の SDK、Google Cloud コンソール、REST API などです。このドキュメントの後半のコードサンプルでは、これらのオプションを使用してマルチモーダルソリューションを作成する方法を示します。

Gemini マルチモーダルモデルは次のとおりです。

Gemini 1.0 Pro Vision
Gemini 1.5 Pro（プレビュー）

次の表に、各マルチモーダル Gemini API がプロンプトリクエストで対応しているモダリティを示します。

モデル	テキスト	コード	画像	音声	動画	動画 / 音声	PDF
Gemini 1.0 Pro
Gemini 1.0 Pro Vision
Gemini 1.5 Pro（プレビュー）

Google Cloud コンソールでマルチモーダルモデルを確認するには、Model Garden で gemini-1.0-pro-vision モデルカードまたは gemini-1.5-pro モデルカードを選択します。

Model Garden に移動

Gemini モデルでサポートされている言語の一覧については、モデル情報の言語サポートをご覧ください。マルチモーダルプロンプトの設計方法について詳しくは、マルチモーダルプロンプトを設計するをご覧ください。モバイルアプリやウェブアプリから Gemini を直接使用することをお考えの場合は、Android、Swift、ウェブの Google AI SDK をご覧ください。

マルチモーダルモデルの違い

次の表に、Gemini マルチモーダルモデルの違いを示します。この情報を使用して、最適なモデルを決定してください。

テキスト

Gemini マルチモーダルモデル間のテキストモダリティの違いは次のとおりです。

モデル	テキストモダリティの詳細
Gemini 1.0 Pro Vision	トークンの最大数は 16,384 個です。1 ページあたり 250 語とすると、これは約 128 ページの本に相当します。この上限には、入力トークンと出力トークンの両方が含まれます。出力トークンの最大数は 2,048 個です。
Gemini 1.5 Pro（プレビュー）	コンテキストの長さは 100 万トークンで、これは約 4,000 ページの本に相当します。モデルは書籍、複数の PDF、ユーザーマニュアルなどの長いテキストを出力できます。

コード

コードを扱う場合の Gemini マルチモーダルモデルの違いは次のとおりです。

モデル	コードのモダリティの詳細
Gemini 1.0 Pro Vision	トークンの最大数は 16,384 個です。1 ページあたり 250 語とすると、これは約 128 ページの本に相当します。この上限には、入力トークンと出力トークンの両方が含まれます。出力トークンの最大数は 2,048 個です。
Gemini 1.5 Pro（プレビュー）	コンテキストの長さは 100 万トークンです。モデルはコードベース全体またはアプリケーションコードベース全体で動作できます。

画像

Gemini マルチモーダルモデルの画像モダリティの違いは次のとおりです。

モデル	画像モダリティの詳細
Gemini 1.0 Pro Vision	プロンプトあたりの画像の最大数は 16 です。
Gemini 1.5 Pro（プレビュー）	プロンプトあたりの画像の最大数は 3,000 です。

音声（音声のみ）

Gemini マルチモーダルモデル間の音声モダリティには、次のような違いがあります。

モデル	音声モダリティの詳細
Gemini 1.0 Pro Vision	音声はサポートされていません。
Gemini 1.5 Pro（プレビュー）	プロンプトあたりの音声の最大時間は約 8.4 時間、または最大 100 万トークンです。音声の要約、文字起こし、翻訳のために音声を理解できます。

動画

Gemini マルチモーダルモデルの動画モダリティには、次のような違いがあります。

モデル	動画モダリティの詳細
Gemini 1.0 Pro Vision	動画の長さは最大 2 分です。プロンプトあたりの動画の最大数は 1 です。動画内の音声は無視されます。
Gemini 1.5 Pro（プレビュー）	音声が含まれる場合、動画の最大長は約 50 分です。音声なしの動画の最大再生時間は 1 時間です。プロンプトあたりの動画の最大数は 10 です。モデルは、動画データと音声データの両方を使用してプロンプトに応答できます。たとえば、動画内の視覚的なコンテンツと音声の両方を使用して動画を要約します。

モデル

動画モダリティの詳細

Gemini 1.0 Pro Vision

動画の長さは最大 2 分です。プロンプトあたりの動画の最大数は 1 です。動画内の音声は無視されます。

Gemini 1.5 Pro（プレビュー）

音声が含まれる場合、動画の最大長は約 50 分です。音声なしの動画の最大再生時間は 1 時間です。プロンプトあたりの動画の最大数は 10 です。モデルは、動画データと音声データの両方を使用してプロンプトに応答できます。たとえば、動画内の視覚的なコンテンツと音声の両方を使用して動画を要約します。

PDF

Gemini マルチモーダルモデルの PDF モダリティには、次のような違いがあります。

モデル	PDF のモダリティの詳細
Gemini 1.0 Pro Vision	プロンプトあたりのページ数は最大 16 ページです。PDF の最大ファイルサイズは 50 MB です。
Gemini 1.5 Pro（プレビュー）	プロンプトあたりのページ数の上限は 300 ページです。PDF の最大ファイルサイズは 50 MB です。

クイックスタート

次のコードサンプルを使用して、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

# Initialize Vertex AI
vertexai.init(project=project_id, location=location)

# Load the model
model = GenerativeModel(model_name="gemini-1.0-pro-vision-001")

# Load example image
image_url = "gs://generativeai-downloads/images/scones.jpg"
image_content = Part.from_uri(image_url, "image/jpeg")

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

Node.js

このサンプルを試す前に、Node.js SDK を使用した生成 AI クイックスタートの Node.js の設定手順を実施してください。詳細については、Node.js SDK for Gemini リファレンスドキュメントをご覧ください。

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',
  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);
}

Java

このサンプルを試す前に、Vertex AI クイックスタートの Java の設定手順を実施してください。詳細については、Vertex AI Java SDK for Gemini リファレンスドキュメントをご覧ください。

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスの場合は、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";
    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/jpg", imageBytes)
          ));

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

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: 温度は、レスポンス生成時のサンプリングに使用されます。レスポンス生成は、topP と topK が適用された場合に発生します。温度は、トークン選択のランダム性の度合いを制御します。温度が低いほど、確定的で自由度や創造性を抑えたレスポンスが求められるプロンプトに適しています。一方、温度が高いと、より多様で創造的な結果を導くことができます。温度が 0 の場合、確率が最も高いトークンが常に選択されます。この場合、特定のプロンプトに対するレスポンスはほとんど確定的ですが、わずかに変動する可能性は残ります。
モデルが返すレスポンスが一般的すぎる、短すぎる、あるいはフォールバック（代替）レスポンスが返ってくる場合は、温度を高く設定してみてください。
TOP_P: トップ P は、モデルが出力用にトークンを選択する方法を変更します。トークンは、確率の合計がトップ P 値に等しくなるまで、確率の高いもの（トップ K を参照）から低いものへと選択されます。たとえば、トークン A、B、C の確率が 0.3、0.2、0.1 であり、トップ P 値が 0.5 であるとします。この場合、モデルは温度を使用して A または B を次のトークンとして選択し、C は候補から除外します。
ランダムなレスポンスを減らしたい場合は小さい値を、ランダムなレスポンスを増やしたい場合は大きい値を指定します。
TOP_K: トップ K は、モデルが出力用にトークンを選択する方法を変更します。トップ K が 1 の場合、次に選択されるトークンは、モデルの語彙内のすべてのトークンで最も確率の高いものであることになります（グリーディデコードとも呼ばれます）。トップ K が 3 の場合は、最も確率が高い上位 3 つのトークンから次のトークン選択されることになります（温度を使用します）。
トークン選択のそれぞれのステップで、最も高い確率を持つトップ K のトークンがサンプリングされます。その後、トークンはトップ P に基づいてさらにフィルタリングされ、最終的なトークンは温度サンプリングを用いて選択されます。

ランダムなレスポンスを減らしたい場合は小さい値を、ランダムなレスポンスを増やしたい場合は大きい値を指定します。
MAX_OUTPUT_TOKENS: レスポンス内に生成できるトークンの最大数。1 トークンは約 4 文字です。100 トークンは約 60～80 語に相当します。
レスポンスを短くしたい場合は小さい値を、長くしたい場合は大きい値を指定します。
STOP_SEQUENCES: レスポンスでいずれかの文字列が検出された場合に、テキストの生成を停止するようモデルに指示する文字列のリストを指定します。レスポンスで文字列が複数回出現する場合、レスポンスでは最初に見つかった箇所が切り捨てられます。文字列では大文字と小文字が区別されます。

たとえば、stopSequences が指定されていない場合に、次のレスポンスが返されたとします。

public static string reverse(string myString)

この場合に、stopSequences が ["Str", "reverse"] に設定されているレスポンスは次のとおりです。

public static string

HTTP メソッドと URL:

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

注: 次のコマンドは、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:GENERATE_RESPONSE_METHOD"

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:GENERATE_RESPONSE_METHOD" | Select-Object -Expand Content

次のような JSON レスポンスが返されます。

レスポンス

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": " Yes the animal in the picture is a cat."
          }
        ]
      }
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 263,
    "candidatesTokenCount": 10,
    "totalTokenCount": 273
  }
}

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

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスの場合は、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-pro-preview-0409")

prompt = """
Your 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)

単一の動画

以下の各タブでは、プロンプトリクエストに動画を含めるさまざまな方法について説明します。これらの PDF サンプルは、すべての Gemini マルチモーダルモデルで使用できます。

Python

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスの場合は、generate_content の stream パラメータを使用します。

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

非ストリーミングレスポンスの場合は、パラメータを削除するか、パラメータを False に設定します。

サンプルコード

import vertexai

from vertexai.generative_models import GenerativeModel, Part

# Initialize Vertex AI
vertexai.init(project=project_id, location=location)
# Load the model
vision_model = GenerativeModel(model_name="gemini-1.0-pro-vision-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)

C#

このサンプルを試す前に、Vertex AI クイックスタート: クライアントライブラリの使用にある C# の設定手順を完了してください。詳細については、Vertex AI C# API のリファレンスドキュメントをご覧ください。


using Google.Api.Gax.Grpc;
using Google.Cloud.AIPlatform.V1;
using System.Collections.Generic;
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"
    )
    {
        // Create client
        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        // Prompt
        string prompt = "What's in the video?";
        string videoUri = "gs://cloud-samples-data/video/animals.mp4";

        // Initialize request argument(s)
        var content = new Content
        {
            Role = "USER"
        };
        content.Parts.AddRange(new List<Part>()
        {
            new() {
                Text = prompt
            },
            new() {
                FileData = new() {
                    MimeType = "video/mp4",
                    FileUri = videoUri
                }
            }
        });

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}"
        };
        generateContentRequest.Contents.Add(content);

        // Make the request, returning a streaming response
        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        // Read streaming responses from server until complete
        AsyncResponseStream<GenerateContentResponse> responseStream = response.GetResponseStream();
        await foreach (GenerateContentResponse responseItem in responseStream)
        {
            fullText.Append(responseItem.Candidates[0].Content.Parts[0].Text);
        }
        return fullText.ToString();
    }
}

Node.js

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスの場合は、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'
) {
  // 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);
}

Java

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスの場合は、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";

    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);
    }
  }
}

Go

このサンプルを試す前に、Vertex AI クイックスタートの Go の設定手順を実施してください。詳細については、Vertex AI Go SDK for Gemini リファレンスドキュメントをご覧ください。

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスの場合は、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"
	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
	img := genai.FileData{
		MIMEType: mime.TypeByExtension(filepath.Ext(video)),
		FileURI:  video,
	}

	res, err := model.GenerateContent(ctx, img, 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
}

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: 温度は、レスポンス生成時のサンプリングに使用されます。レスポンス生成は、topP と topK が適用された場合に発生します。温度は、トークン選択のランダム性の度合いを制御します。温度が低いほど、確定的で自由度や創造性を抑えたレスポンスが求められるプロンプトに適しています。一方、温度が高いと、より多様で創造的な結果を導くことができます。温度が 0 の場合、確率が最も高いトークンが常に選択されます。この場合、特定のプロンプトに対するレスポンスはほとんど確定的ですが、わずかに変動する可能性は残ります。
モデルが返すレスポンスが一般的すぎる、短すぎる、あるいはフォールバック（代替）レスポンスが返ってくる場合は、温度を高く設定してみてください。
TOP_P: トップ P は、モデルが出力用にトークンを選択する方法を変更します。トークンは、確率の合計がトップ P 値に等しくなるまで、確率の高いもの（トップ K を参照）から低いものへと選択されます。たとえば、トークン A、B、C の確率が 0.3、0.2、0.1 であり、トップ P 値が 0.5 であるとします。この場合、モデルは温度を使用して A または B を次のトークンとして選択し、C は候補から除外します。
ランダムなレスポンスを減らしたい場合は小さい値を、ランダムなレスポンスを増やしたい場合は大きい値を指定します。
TOP_K: トップ K は、モデルが出力用にトークンを選択する方法を変更します。トップ K が 1 の場合、次に選択されるトークンは、モデルの語彙内のすべてのトークンで最も確率の高いものであることになります（グリーディデコードとも呼ばれます）。トップ K が 3 の場合は、最も確率が高い上位 3 つのトークンから次のトークン選択されることになります（温度を使用します）。
トークン選択のそれぞれのステップで、最も高い確率を持つトップ K のトークンがサンプリングされます。その後、トークンはトップ P に基づいてさらにフィルタリングされ、最終的なトークンは温度サンプリングを用いて選択されます。

ランダムなレスポンスを減らしたい場合は小さい値を、ランダムなレスポンスを増やしたい場合は大きい値を指定します。
MAX_OUTPUT_TOKENS: レスポンス内に生成できるトークンの最大数。1 トークンは約 4 文字です。100 トークンは約 60～80 語に相当します。
レスポンスを短くしたい場合は小さい値を、長くしたい場合は大きい値を指定します。
STOP_SEQUENCES: レスポンスでいずれかの文字列が検出された場合に、テキストの生成を停止するようモデルに指示する文字列のリストを指定します。レスポンスで文字列が複数回出現する場合、レスポンスでは最初に見つかった箇所が切り捨てられます。文字列では大文字と小文字が区別されます。

たとえば、stopSequences が指定されていない場合に、次のレスポンスが返されたとします。

public static string reverse(string myString)

この場合に、stopSequences が ["Str", "reverse"] に設定されているレスポンスは次のとおりです。

public static string

HTTP メソッドと URL:

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 レスポンスが返されます。

レスポンス

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": " Yes the animal in the picture is a cat."
          }
        ]
      }
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 263,
    "candidatesTokenCount": 10,
    "totalTokenCount": 273
  }
}

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 コンソールでマルチモーダルプロンプトを送信する手順は次のとおりです。

Google Cloud コンソールの [Vertex AI] セクションで、[Vertex AI Studio] ページに移動します。
Vertex AI Studio に移動
[プロンプトの設計（シングルターン）] で [開く] をクリックします。
モデルとパラメータを構成します。
- リージョン: 使用するリージョンを選択します。
- モデル: [Gemini Pro Vision] を選択します。
- Temperature: スライダーまたはテキストボックスを使用して、温度の値を入力します。
  温度は、レスポンス生成時のサンプリングに使用されます。レスポンス生成は、topP と topK が適用された場合に発生します。温度は、トークン選択のランダム性の度合いを制御します。温度が低いほど、確定的で自由度や創造性を抑えたレスポンスが求められるプロンプトに適しています。一方、温度が高いと、より多様で創造的な結果を導くことができます。温度が 0 の場合、確率が最も高いトークンが常に選択されます。この場合、特定のプロンプトに対するレスポンスはほとんど確定的ですが、わずかに変動する可能性は残ります。
  モデルが返すレスポンスが一般的すぎる、短すぎる、あるいはフォールバック（代替）レスポンスが返ってくる場合は、温度を高く設定してみてください。
- トークンの上限: スライダーまたはテキストボックスを使用して、最大出力の上限値を入力します。
  レスポンスで生成できるトークンの最大数。1 トークンは約 4 文字です。100 トークンは約 60～80 語に相当します。
  レスポンスを短くしたい場合は小さい値を、長くしたい場合は大きい値を指定します。
- 停止シーケンスを追加: 停止シーケンスを入力します。これは文字列（スペースを含む）で、モデルがこれに接するとレスポンスの生成を停止します。このシーケンスはレスポンスには含まれません。停止シーケンスは 5 つまで追加できます。
省略可: 詳細パラメータを構成するには、[詳細] をクリックして、次のように構成します。

クリックして詳細構成を開く

トップ K: スライダーまたはテキストボックスを使用して、トップ K の値を入力します。
トップ K は、モデルが出力用にトークンを選択する方法を変更します。トップ K が 1 の場合、次に選択されるトークンは、モデルの語彙内のすべてのトークンで最も確率の高いものであることになります（グリーディデコードとも呼ばれます）。トップ K が 3 の場合は、最も確率が高い上位 3 つのトークンから次のトークン選択されることになります（温度を使用します）。
トークン選択のそれぞれのステップで、最も高い確率を持つトップ K のトークンがサンプリングされます。その後、トークンはトップ P に基づいてさらにフィルタリングされ、最終的なトークンは温度サンプリングを用いて選択されます。

ランダムなレスポンスを減らしたい場合は小さい値を、ランダムなレスポンスを増やしたい場合は大きい値を指定します。
Top-P: スライダーまたはテキストボックスを使用して、Top-P の値を入力します。確率の合計が Top-P の値と等しくなるまで、最も確率が高いものから最も確率が低いものの順に、トークンが選択されます。結果を最小にするには、Top-P を 0 に設定します。

Google Cloud コンソールはストリーミングのみをサポートしています。ストリーミングでは、生成されたときにプロンプトのレスポンスを受信します。メッセージボックスにメッセージを入力して、モデルとの会話を開始する準備ができました。

モデルは、以前のメッセージを新しいレスポンスのコンテキストとして使用します。プロンプトに画像、PDF、または動画を含めるには、アイコンをクリックします。

マルチモーダルプロンプトの詳細については、マルチモーダルプロンプトを設計するをご覧ください。
省略可: プロンプトを [マイプロンプト] に保存するには、[ 保存] をクリックします。
省略可: プロンプトの Python コードまたは curl コマンドを取得するには、[コードを取得] をクリックします。
省略可: 以前のメッセージをすべて消去するには、[ CLEAR CONVERSATION] をクリックします。

単一の音声

以下では、音声ファイルを使用してポッドキャストを要約する方法について説明します。このサンプルは、Gemini 1.5 Pro（プレビュー）でのみ動作します。

Python

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスの場合は、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-pro-preview-0409")

  prompt = """
  Please provide a summary for the audio.
  Provide chapter titles with timestamps, 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

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスの場合は、generate_content の stream パラメータを使用します。

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

非ストリーミングレスポンスの場合は、パラメータを削除するか、パラメータを False に設定します。

サンプルコード

import http.client
import typing
import urllib.request
import vertexai

from vertexai.generative_models import GenerativeModel, Image

# Initialize Vertex AI
vertexai.init(project=project_id, location=location)

# create helper function
def load_image_from_url(image_url: str) -> Image:
    with urllib.request.urlopen(image_url) as response:
        response = typing.cast(http.client.HTTPResponse, response)
        image_bytes = response.read()
    return Image.from_bytes(image_bytes)

# Load images from Cloud Storage URI
landmark1 = load_image_from_url(
    "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png"
)
landmark2 = load_image_from_url(
    "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png"
)
landmark3 = load_image_from_url(
    "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png"
)

# Pass multimodal prompt
model = GenerativeModel(model_name="gemini-1.0-pro-vision-001")
response = model.generate_content(
    [
        landmark1,
        "city: Rome, Landmark: the Colosseum",
        landmark2,
        "city: Beijing, Landmark: Forbidden City",
        landmark3,
    ]
)
print(response)

C#


using Google.Api.Gax.Grpc;
using Google.Cloud.AIPlatform.V1;
using Google.Protobuf;
using System.Collections.Generic;
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"
    )
    {
        // Create client
        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        // Images
        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");

        // Initialize request argument(s)
        var content = new Content
        {
            Role = "USER"
        };
        content.Parts.AddRange(new List<Part>()
        {
            new()
            {
                InlineData = new()
                {
                    MimeType = "image/png",
                    Data = colosseum

                }
            },
            new()
            {
                Text = "city: Rome, Landmark: the Colosseum"
            },
            new()
            {
                InlineData = new()
                {
                    MimeType = "image/png",
                    Data = forbiddenCity
                }
            },
            new()
            {
                Text = "city: Beijing, Landmark: Forbidden City"
            },
            new()
            {
                InlineData = new()
                {
                    MimeType = "image/png",
                    Data = christRedeemer
                }
            }
        });

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}"
        };
        generateContentRequest.Contents.Add(content);

        // Make the request, returning a streaming response
        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        // Read streaming responses from server until complete
        AsyncResponseStream<GenerateContentResponse> responseStream = response.GetResponseStream();
        await foreach (GenerateContentResponse responseItem in responseStream)
        {
            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);
    }
}

Node.js

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスの場合は、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'
) {
  // 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);
}

Java

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスの場合は、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";

    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);
    }
  }
}

Go

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスの場合は、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
}

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: 温度は、レスポンス生成時のサンプリングに使用されます。レスポンス生成は、topP と topK が適用された場合に発生します。温度は、トークン選択のランダム性の度合いを制御します。温度が低いほど、確定的で自由度や創造性を抑えたレスポンスが求められるプロンプトに適しています。一方、温度が高いと、より多様で創造的な結果を導くことができます。温度が 0 の場合、確率が最も高いトークンが常に選択されます。この場合、特定のプロンプトに対するレスポンスはほとんど確定的ですが、わずかに変動する可能性は残ります。
モデルが返すレスポンスが一般的すぎる、短すぎる、あるいはフォールバック（代替）レスポンスが返ってくる場合は、温度を高く設定してみてください。
TOP_P: トップ P は、モデルが出力用にトークンを選択する方法を変更します。トークンは、確率の合計がトップ P 値に等しくなるまで、確率の高いもの（トップ K を参照）から低いものへと選択されます。たとえば、トークン A、B、C の確率が 0.3、0.2、0.1 であり、トップ P 値が 0.5 であるとします。この場合、モデルは温度を使用して A または B を次のトークンとして選択し、C は候補から除外します。
ランダムなレスポンスを減らしたい場合は小さい値を、ランダムなレスポンスを増やしたい場合は大きい値を指定します。
TOP_K: トップ K は、モデルが出力用にトークンを選択する方法を変更します。トップ K が 1 の場合、次に選択されるトークンは、モデルの語彙内のすべてのトークンで最も確率の高いものであることになります（グリーディデコードとも呼ばれます）。トップ K が 3 の場合は、最も確率が高い上位 3 つのトークンから次のトークン選択されることになります（温度を使用します）。
トークン選択のそれぞれのステップで、最も高い確率を持つトップ K のトークンがサンプリングされます。その後、トークンはトップ P に基づいてさらにフィルタリングされ、最終的なトークンは温度サンプリングを用いて選択されます。

ランダムなレスポンスを減らしたい場合は小さい値を、ランダムなレスポンスを増やしたい場合は大きい値を指定します。
MAX_OUTPUT_TOKENS: レスポンス内に生成できるトークンの最大数。1 トークンは約 4 文字です。100 トークンは約 60～80 語に相当します。
レスポンスを短くしたい場合は小さい値を、長くしたい場合は大きい値を指定します。
STOP_SEQUENCES: レスポンスでいずれかの文字列が検出された場合に、テキストの生成を停止するようモデルに指示する文字列のリストを指定します。レスポンスで文字列が複数回出現する場合、レスポンスでは最初に見つかった箇所が切り捨てられます。文字列では大文字と小文字が区別されます。

たとえば、stopSequences が指定されていない場合に、次のレスポンスが返されたとします。

public static string reverse(string myString)

この場合に、stopSequences が ["Str", "reverse"] に設定されているレスポンスは次のとおりです。

public static string

HTTP メソッドと URL:

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 レスポンスが返されます。

レスポンス

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": " Yes the animal in the picture is a cat."
          }
        ]
      }
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 263,
    "candidatesTokenCount": 10,
    "totalTokenCount": 273
  }
}

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 コンソールでマルチモーダルプロンプトを送信する手順は次のとおりです。

Google Cloud コンソールの [Vertex AI] セクションで、[Vertex AI Studio] ページに移動します。
Vertex AI Studio に移動
[プロンプトの設計（シングルターン）] で [開く] をクリックします。
モデルとパラメータを構成します。
- リージョン: 使用するリージョンを選択します。
- モデル: [Gemini Pro Vision] を選択します。
- Temperature: スライダーまたはテキストボックスを使用して、温度の値を入力します。
  温度は、レスポンス生成時のサンプリングに使用されます。レスポンス生成は、topP と topK が適用された場合に発生します。温度は、トークン選択のランダム性の度合いを制御します。温度が低いほど、確定的で自由度や創造性を抑えたレスポンスが求められるプロンプトに適しています。一方、温度が高いと、より多様で創造的な結果を導くことができます。温度が 0 の場合、確率が最も高いトークンが常に選択されます。この場合、特定のプロンプトに対するレスポンスはほとんど確定的ですが、わずかに変動する可能性は残ります。
  モデルが返すレスポンスが一般的すぎる、短すぎる、あるいはフォールバック（代替）レスポンスが返ってくる場合は、温度を高く設定してみてください。
- トークンの上限: スライダーまたはテキストボックスを使用して、最大出力の上限値を入力します。
  レスポンスで生成できるトークンの最大数。1 トークンは約 4 文字です。100 トークンは約 60～80 語に相当します。
  レスポンスを短くしたい場合は小さい値を、長くしたい場合は大きい値を指定します。
- 停止シーケンスを追加: 停止シーケンスを入力します。これは文字列（スペースを含む）で、モデルがこれに接するとレスポンスの生成を停止します。このシーケンスはレスポンスには含まれません。停止シーケンスは 5 つまで追加できます。
省略可: 詳細パラメータを構成するには、[詳細] をクリックして、次のように構成します。

クリックして詳細構成を開く

トップ K: スライダーまたはテキストボックスを使用して、トップ K の値を入力します。
トップ K は、モデルが出力用にトークンを選択する方法を変更します。トップ K が 1 の場合、次に選択されるトークンは、モデルの語彙内のすべてのトークンで最も確率の高いものであることになります（グリーディデコードとも呼ばれます）。トップ K が 3 の場合は、最も確率が高い上位 3 つのトークンから次のトークン選択されることになります（温度を使用します）。
トークン選択のそれぞれのステップで、最も高い確率を持つトップ K のトークンがサンプリングされます。その後、トークンはトップ P に基づいてさらにフィルタリングされ、最終的なトークンは温度サンプリングを用いて選択されます。

ランダムなレスポンスを減らしたい場合は小さい値を、ランダムなレスポンスを増やしたい場合は大きい値を指定します。
Top-P: スライダーまたはテキストボックスを使用して、Top-P の値を入力します。確率の合計が Top-P の値と等しくなるまで、最も確率が高いものから最も確率が低いものの順に、トークンが選択されます。結果を最小にするには、Top-P を 0 に設定します。

Google Cloud コンソールはストリーミングのみをサポートしています。ストリーミングでは、生成されたときにプロンプトのレスポンスを受信します。メッセージボックスにメッセージを入力して、モデルとの会話を開始する準備ができました。

モデルは、以前のメッセージを新しいレスポンスのコンテキストとして使用します。プロンプトに画像、PDF、または動画を含めるには、アイコンをクリックします。

マルチモーダルプロンプトの詳細については、マルチモーダルプロンプトを設計するをご覧ください。
省略可: プロンプトを [マイプロンプト] に保存するには、[ 保存] をクリックします。
省略可: プロンプトの Python コードまたは curl コマンドを取得するには、[コードを取得] をクリックします。
省略可: 以前のメッセージをすべて消去するには、[ CLEAR CONVERSATION] をクリックします。

タイムスタンプ付きの音声

以下では、音声ファイルを使用して、タイムスタンプ付きのポッドキャストの文字起こしを行います。このサンプルは、Gemini 1.5 Pro（プレビュー）でのみ動作します。

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("gemini-1.5-pro-preview-0409")

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

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 1.5 Pro（プレビュー）でのみ動作します。

Python

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスの場合は、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-pro-preview-0409")

  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)

すべてのモダリティ

以下は、画像、動画、音声、テキストを同時に処理する方法を示したものです。このサンプルは、Gemini 1.5 Pro（プレビュー）でのみ動作します。

Python

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスの場合は、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-pro-preview-0409")

  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)

モデルパラメータを設定する

マルチモーダルモデルでは、次のモデルパラメータを設定できます。

トップ P

トップ P は、モデルが出力用にトークンを選択する方法を変更します。トークンは、確率の合計がトップ P 値に等しくなるまで、確率の高いもの（トップ K を参照）から低いものへと選択されます。たとえば、トークン A、B、C の確率が 0.3、0.2、0.1 であり、トップ P 値が 0.5 であるとします。この場合、モデルは温度を使用して A または B を次のトークンとして選択し、C は候補から除外します。

ランダムなレスポンスを減らしたい場合は小さい値を、ランダムなレスポンスを増やしたい場合は大きい値を指定します。

トップ K

トップ K は、モデルが出力用にトークンを選択する方法を変更します。トップ K が 1 の場合、次に選択されるトークンは、モデルの語彙内のすべてのトークンで最も確率の高いものであることになります（グリーディデコードとも呼ばれます）。トップ K が 3 の場合は、最も確率が高い上位 3 つのトークンから次のトークン選択されることになります（温度を使用します）。

トークン選択のそれぞれのステップで、最も高い確率を持つトップ K のトークンがサンプリングされます。その後、トークンはトップ P に基づいてさらにフィルタリングされ、最終的なトークンは温度サンプリングを用いて選択されます。

ランダムなレスポンスを減らしたい場合は小さい値を、ランダムなレスポンスを増やしたい場合は大きい値を指定します。

温度

温度は、レスポンス生成時のサンプリングに使用されます。レスポンス生成は、topP と topK が適用された場合に発生します。温度は、トークン選択のランダム性の度合いを制御します。温度が低いほど、確定的で自由度や創造性を抑えたレスポンスが求められるプロンプトに適しています。一方、温度が高いと、より多様で創造的な結果を導くことができます。温度が 0 の場合、確率が最も高いトークンが常に選択されます。この場合、特定のプロンプトに対するレスポンスはほとんど確定的ですが、わずかに変動する可能性は残ります。

モデルが返すレスポンスが一般的すぎる、短すぎる、あるいはフォールバック（代替）レスポンスが返ってくる場合は、温度を高く設定してみてください。

有効なパラメータ値

パラメータ	Gemini 1.0 Pro Vision	Gemini 1.5 Pro（プレビュー）
トップ K	1～40（デフォルトは 32）	非対応
Top-P	0～1.0（デフォルトは 1.0）	0～1.0（デフォルトは 0.95）
Temperature	0～1.0（デフォルトは 0.4）	0～2.0（デフォルトは 1.0）

メディアの要件

プロンプトリクエストでメディアファイルを使用する場合は、次の要件を満たしていることを確認してください。

画像の要件

画像のピクセル数に特に制限はありません。ただし、大きな画像は元のアスペクト比を維持したまま、最大解像度 3,072 x 3,072 に合わせて縮小され、パディングされます。

Gemini 1.0 Pro Vision の場合、1 つの画像は 258 個のトークンに相当します。

Gemini 1.5 Pro（プレビュー）の場合:

アスペクト比が 1.2 未満の画像、または長辺が 768 未満の画像は、それぞれ 258 個のトークンに相当します。
長辺が 768 より大きく、アスペクト比が 1.2 より大きい画像は、長辺に沿って均等に間隔が取られた正方形のタイルで表されます。Gemini で画像を表す際に、タイルが元の画像と一緒に使用されます。1 つのタイルは 258 個のトークンに相当します。たとえば、解像度が 1,000 × 2,000 の画像の場合、258 × 3 = 774 個のトークンが使用されます（元の画像に 1 個、1,000 × 1,000 の正方形のタイルに 2 個）。

プロンプトリクエストに含めることができる画像の最大数は次のとおりです。

Gemini 1.0 Pro Vision: 16
Gemini 1.5 Pro（プレビュー）: 3,000

音声の要件

Gemini 1.5 Pro（プレビュー）は、次の音声 MIME タイプをサポートしています。Gemini 1.0 Pro Vision は音声をサポートしていません。

audio/mp3
audio/wav

動画の要件

動画は 1 fps でサンプリングされます。動画フレームごとに 258 個のトークンが使用されます。

Gemini 1.5 Pro（プレビュー）のみ、オーディオトラックは動画フレームでエンコードされます。オーディオトラックも 1 秒のトランクに分割され、それぞれ 32 個のトークンが使用されます。動画フレームと音声トークンは、タイムスタンプとともにインターリーブされます。タイムスタンプは 7 個のトークンで表されます。

Gemini マルチモーダルモデルは、次の動画 MIME タイプをサポートしています。

動画の MIME タイプ	Gemini 1.0 Pro Vision	Gemini 1.5 Pro（プレビュー）
MOV - `video/mov`
MPEG - `video/mpeg`
MP4 - `video/mp4`
MPG - `video/mpg`
AVI - `video/avi`
WMV - `video/wmv`
MPEGPS - `video/mpegps`
FLS - `video/flv`

PDF の要件

PDF に必要な MIME タイプは application/pdf です。

ベストプラクティス

このセクションでは、さまざまなモダリティのベストプラクティスについて説明します。

画像に関するベストプラクティス

画像を使用する場合は、最適な結果を得るために、次のベストプラクティスと情報を使用してください。

画像内のテキストを検出する必要がある場合は、1 つの画像を使用するプロンプトのほうが、複数の画像を使用するプロンプトよりも優れた結果が得られます。
プロンプトに 1 つの画像が含まれている場合は、テキストプロンプトの前に画像を配置します。
プロンプトに複数の画像が含まれており、これらの画像をプロンプトの後半で参照する場合、またはモデルレスポンスでモデルが参照する場合は、各画像の前にインデックスを付けると役立つ可能性があります。インデックスには 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.
```
画像の解像度が高いほど良い結果が得られます。
プロンプトにいくつかの例を含めます。
画像を適切な向きに回転してから、プロンプトに追加します。
ぼやけた画像は使用しないでください。

動画に関するベストプラクティス

動画を使用する場合は、最良の結果を得るために、次のベストプラクティスと情報を使用してください。

1 つのプロンプトに複数の動画を使用しないことをおすすめします。
プロンプトに 1 つの動画が含まれている場合は、テキストプロンプトの前に動画を配置します。
Gemini 1.0 Pro Vision を使用している場合、モデルは動画を非連続な画像フレームとして処理します。音声は含まれません。モデルで動画の一部のコンテンツが欠落している場合は、動画を短くして、モデルが動画コンテンツの大部分をキャプチャできるようにします。
Gemini 1.0 Pro Vision を使用している場合は、最初の 2 分間の情報のみが処理されます。
Gemini 1.0 Pro Vision を使用している場合、音声情報やタイムスタンプメタデータは分析されません。このため、字幕読み上げ音声や時間関連の情報（スピードやリズムなど）といった音声入力が必要なユースケースでは、モデルが適切に機能しない場合があります。
音声付き動画のタイムスタンプのローカライズが必要な場合は、モデルに MM:SS 形式のタイムスタンプを生成させます。最初の 2 桁が分、最後の 2 桁が秒を表します。タイムスタンプに関する質問にも同じ形式を使用します。

PDF に関するベストプラクティス

PDF を使用する場合は、次のベストプラクティスと情報を参考にしてください。

PDF は画像として扱われるため、PDF の 1 ページは 1 つの画像として扱われます。
- サポートされるページ数は、モデルがサポートできる画像の数が上限になります。Gemini 1.0 Pro Vision の場合は 16 個です。Gemini 1.5 Pro の場合は 300 個です。ドキュメントが長い場合は、複数の PDF に分割して処理することを検討してください。
- PDF を入力として使用する場合の費用は Gemini の画像処理の料金に準じます。たとえば、Gemini API 呼び出しで 2 ページの PDF を含めると、入力として 2 つの画像を処理する場合の料金が発生します。
プロンプトに 1 つの PDF が含まれている場合は、テキストプロンプトの前に PDF を配置します。
スキャンした画像のテキストではなく、テキストとしてレンダリングされたテキストを含む PDF を使用します。この形式では、テキストが機械で判読可能になるため、スキャンした画像を PDF にした場合よりも、モデルによる編集、検索、操作が容易になります。これにより、契約書など、テキストの多いドキュメントを扱う際に最適な結果が得られます。

マルチモーダルプロンプトに関するその他のヒントについては、マルチモーダルプロンプトを設計するをご覧ください。

マルチモーダルの制限事項

Gemini マルチモーダルモデルは多くのマルチモーダルユースケースに対応していますが、モデルの制限事項も理解しておく必要があります。

空間推論: 画像や PDF 内のテキストやオブジェクトの位置を正確に特定することはできません。オブジェクトの数も推定値しか返されない場合があります。
医療目的での使用: 医療画像（X 線、CT スキャンなど）の解釈や医学的なアドバイスの提供には適していません。
人物認識: このモデルは、画像内の著名人以外の人物を特定することを目的としたものではありません。
コンテンツの管理: Google の安全に関するポリシーに違反する画像や動画に対する回答は拒否されます。
精度: 低品質、回転、極端に低解像度の画像を解釈する際に、ハルシネーションや誤りが発生する可能性があります。また、画像や PDF ドキュメント内の手書きテキストを解釈する際に、ハルシネーションが発生することもあります。
非音声の認識: 音声をサポートするモデルでは、音声以外の音を認識する際に誤りが発生する可能性があります。
高速モーション: サンプリングレートが 1 秒あたり 1 フレーム（fps）に固定されているため、動画内の高速モーションを理解する際に誤りが発生する可能性があります。

次のステップ

チャットプロンプトリクエストの送信方法を学習する。
責任ある AI のベストプラクティスと Vertex AI の安全フィルタについて学習する。

マルチモーダル プロンプト リクエストを送信する

マルチモーダル モデルの違い

テキスト

コード

画像

音声（音声のみ）

動画

PDF

クイックスタート

単一の画像

Python

ストリーミング レスポンスと非ストリーミング レスポンス

サンプルコード

Node.js

ストリーミング レスポンスと非ストリーミング レスポンス

サンプルコード

Java

ストリーミング レスポンスと非ストリーミング レスポンス

サンプルコード

REST

curl

PowerShell

レスポンス

curl コマンドの例

単一の PDF

Python

ストリーミング レスポンスと非ストリーミング レスポンス

サンプルコード

単一の動画

Python

ストリーミング レスポンスと非ストリーミング レスポンス

サンプルコード

C#

Node.js

ストリーミング レスポンスと非ストリーミング レスポンス

サンプルコード

Java

ストリーミング レスポンスと非ストリーミング レスポンス

サンプルコード

Go

ストリーミング レスポンスと非ストリーミング レスポンス

サンプルコード

REST

curl

PowerShell

レスポンス

curl コマンドの例

コンソール

単一の音声

Python

ストリーミング レスポンスと非ストリーミング レスポンス

サンプルコード

高度なサンプル

複数の画像

Python

ストリーミング レスポンスと非ストリーミング レスポンス

サンプルコード

C#

Node.js

ストリーミング レスポンスと非ストリーミング レスポンス

サンプルコード

Java

ストリーミング レスポンスと非ストリーミング レスポンス

サンプルコード

Go

ストリーミング レスポンスと非ストリーミング レスポンス

サンプルコード

REST

curl

PowerShell

レスポンス

curl コマンドの例

コンソール

タイムスタンプ付きの音声

音声付きの動画

Python

ストリーミング レスポンスと非ストリーミング レスポンス

サンプルコード

すべてのモダリティ

Python

マルチモーダルプロンプトリクエストを送信する

マルチモーダルモデルの違い

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスと非ストリーミングレスポンス

ストリーミングレスポンスと非ストリーミングレスポンス

モデルパラメータを設定する

ベストプラクティス

画像に関するベストプラクティス

動画に関するベストプラクティス

PDF に関するベストプラクティス