Hiểu hình ảnh

Các mô hình Gemini có thể xử lý hình ảnh, cho phép nhiều trường hợp sử dụng của nhà phát triển tiên phong mà trước đây cần có các mô hình dành riêng cho miền. Một số tính năng thị giác của Gemini bao gồm khả năng:

  • Chú thích và trả lời các câu hỏi về hình ảnh
  • Chuyển văn bản và suy luận trên tệp PDF, bao gồm tối đa 2 triệu mã thông báo
  • Phát hiện các đối tượng trong hình ảnh và trả về toạ độ hộp giới hạn cho các đối tượng đó
  • Phân đoạn các đối tượng trong hình ảnh

Gemini được xây dựng từ đầu để trở thành mô hình đa phương thức và chúng tôi tiếp tục đẩy mạnh ranh giới của những gì có thể. Hướng dẫn này cho biết cách sử dụng API Gemini để tạo phản hồi văn bản dựa trên dữ liệu đầu vào hình ảnh và thực hiện các nhiệm vụ thường gặp về việc hiểu hình ảnh.

Trước khi bắt đầu

Trước khi gọi Gemini API, hãy đảm bảo bạn đã cài đặt SDK mà bạn chọn và khoá Gemini API đã được định cấu hình và sẵn sàng sử dụng.

Nhập hình ảnh

Bạn có thể cung cấp hình ảnh làm dữ liệu đầu vào cho Gemini theo các cách sau:

  • Tải tệp hình ảnh lên bằng File API trước khi đưa ra yêu cầu đến generateContent. Sử dụng phương thức này cho các tệp lớn hơn 20 MB hoặc khi bạn muốn sử dụng lại tệp trên nhiều yêu cầu.
  • Truyền dữ liệu hình ảnh cùng dòng bằng yêu cầu đến generateContent. Sử dụng phương thức này cho các tệp nhỏ hơn (<20 MB tổng kích thước yêu cầu) hoặc hình ảnh được tìm nạp trực tiếp từ URL.

Tải tệp hình ảnh lên

Bạn có thể sử dụng API Tệp để tải tệp hình ảnh lên. Luôn sử dụng API Tệp khi tổng kích thước yêu cầu (bao gồm cả tệp, lời nhắc văn bản, hướng dẫn hệ thống, v.v.) lớn hơn 20 MB hoặc nếu bạn dự định sử dụng cùng một hình ảnh trong nhiều lời nhắc.

Mã sau đây sẽ tải một tệp hình ảnh lên rồi sử dụng tệp đó trong lệnh gọi đến generateContent.

Python

from google import genai

client = genai.Client(api_key="GOOGLE_API_KEY")

myfile = client.files.upload(file="path/to/sample.jpg")

response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=[myfile, "Caption this image."])

print(response.text)

JavaScript

import {
  GoogleGenAI,
  createUserContent,
  createPartFromUri,
} from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

async function main() {
  const myfile = await ai.files.upload({
    file: "path/to/sample.jpg",
    config: { mimeType: "image/jpeg" },
  });

  const response = await ai.models.generateContent({
    model: "gemini-2.0-flash",
    contents: createUserContent([
      createPartFromUri(myfile.uri, myfile.mimeType),
      "Caption this image.",
    ]),
  });
  console.log(response.text);
}

await main();

Go

file, err := client.UploadFileFromPath(ctx, "path/to/sample.jpg", nil)
if err != nil {
    log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)

model := client.GenerativeModel("gemini-2.0-flash")
resp, err := model.GenerateContent(ctx,
    genai.FileData{URI: file.URI},
    genai.Text("Caption this image."))
if err != nil {
    log.Fatal(err)
}

printResponse(resp)

REST

IMAGE_PATH="path/to/sample.jpg"
MIME_TYPE=$(file -b --mime-type "${IMAGE_PATH}")
NUM_BYTES=$(wc -c < "${IMAGE_PATH}")
DISPLAY_NAME=IMAGE

tmp_header_file=upload-header.tmp

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "https://generativelanguage.googleapis.com/upload/v1beta/files?key=${GOOGLE_API_KEY}" \
  -D upload-header.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${IMAGE_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

# Now generate content using that file
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"file_data":{"mime_type": "${MIME_TYPE}", "file_uri": '$file_uri'}},
          {"text": "Caption this image."}]
        }]
      }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.json

Để tìm hiểu thêm về cách làm việc với tệp phương tiện, hãy xem API Tệp.

Truyền dữ liệu hình ảnh cùng dòng

Thay vì tải tệp hình ảnh lên, bạn có thể truyền dữ liệu hình ảnh cùng dòng trong yêu cầu đến generateContent. Phương thức này phù hợp với các hình ảnh nhỏ hơn (tổng kích thước yêu cầu dưới 20 MB) hoặc hình ảnh được tìm nạp trực tiếp từ URL.

Bạn có thể cung cấp dữ liệu hình ảnh dưới dạng chuỗi được mã hoá Base64 hoặc bằng cách trực tiếp đọc các tệp cục bộ (tuỳ thuộc vào SDK).

Tệp hình ảnh cục bộ:

Python

  from google.genai import types

  with open('path/to/small-sample.jpg', 'rb') as f:
      img_bytes = f.read()

  response = client.models.generate_content(
    model='gemini-2.0-flash',
    contents=[
      types.Part.from_bytes(
        data=img_bytes,
        mime_type='image/jpeg',
      ),
      'Caption this image.'
    ]
  )

  print(response.text)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });
const base64ImageFile = fs.readFileSync("path/to/small-sample.jpg", {
  encoding: "base64",
});

const contents = [
  {
    inlineData: {
      mimeType: "image/jpeg",
      data: base64ImageFile,
    },
  },
  { text: "Caption this image." },
];

const response = await ai.models.generateContent({
  model: "gemini-2.0-flash",
  contents: contents,
});
console.log(response.text);

Go

model := client.GenerativeModel("gemini-2.0-flash")

bytes, err := os.ReadFile("path/to/small-sample.jpg")
if err != nil {
  log.Fatal(err)
}

prompt := []genai.Part{
  genai.Blob{MIMEType: "image/jpeg", Data: bytes},
  genai.Text("Caption this image."),
}

resp, err := model.GenerateContent(ctx, prompt...)
if err != nil {
  log.Fatal(err)
}

for _, c := range resp.Candidates {
  if c.Content != nil {
    fmt.Println(*c.Content)
  }
}

REST

IMG_PATH=/path/to/your/image1.jpg

if [[ "$(base64 --version 2>&1)" = *"FreeBSD"* ]]; then
  B64FLAGS="--input"
else
  B64FLAGS="-w0"
fi

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
            {
              "inline_data": {
                "mime_type":"image/jpeg",
                "data": "'\$(base64 \$B64FLAGS \$IMG_PATH)'"
              }
            },
            {"text": "Caption this image."},
        ]
      }]
    }' 2> /dev/null

Hình ảnh từ URL:

Python

from google import genai
from google.genai import types

import requests

image_path = "https://goo.gle/instrument-img"
image = requests.get(image_path)

client = genai.Client(api_key="GOOGLE_API_KEY")
response = client.models.generate_content(
    model="gemini-2.0-flash-exp",
    contents=["What is this image?",
              types.Part.from_bytes(data=image.content, mime_type="image/jpeg")])

print(response.text)

JavaScript

import { GoogleGenAI } from "@google/genai";

async function main() {
  const ai = new GoogleGenAI({ apiKey: process.env.GOOGLE_API_KEY });

  const imageUrl = "https://goo.gle/instrument-img";

  const response = await fetch(imageUrl);
  const imageArrayBuffer = await response.arrayBuffer();
  const base64ImageData = Buffer.from(imageArrayBuffer).toString('base64');

  const result = await ai.models.generateContent({
    model: "gemini-2.0-flash",
    contents: [
    {
      inlineData: {
        mimeType: 'image/jpeg',
        data: base64ImageData,
      },
    },
    { text: "Caption this image." }
  ],
  });
  console.log(result.text);
}

main();

Go

func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("GOOGLE_API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

model := client.GenerativeModel("gemini-2.0-flash")

// Download the image.
imageResp, err := http.Get("https://goo.gle/instrument-img")
if err != nil {
  panic(err)
}
defer imageResp.Body.Close()

imageBytes, err := io.ReadAll(imageResp.Body)
if err != nil {
  panic(err)
}

// Create the request.
req := []genai.Part{
  genai.ImageData("jpeg", imageBytes),

  genai.Text("Caption this image."),
}

// Generate content.
resp, err := model.GenerateContent(ctx, req...)
if err != nil {
  panic(err)
}

// Handle the response of generated text.
for _, c := range resp.Candidates {
  if c.Content != nil {
    fmt.Println(*c.Content)
  }
}

}

REST

IMG_URL="https://goo.gle/instrument-img"

MIME_TYPE=$(curl -sIL "$IMG_URL" | grep -i '^content-type:' | awk -F ': ' '{print $2}' | sed 's/\r$//' | head -n 1)
if [[ -z "$MIME_TYPE" || ! "$MIME_TYPE" == image/* ]]; then
  MIME_TYPE="image/jpeg"
fi

if [[ "$(base64 --version 2>&1)" = *"FreeBSD"* ]]; then
  B64FLAGS="--input"
else
  B64FLAGS="-w0"
fi

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
            {
              "inline_data": {
                "mime_type":"'"$MIME_TYPE"'",
                "data": "'$(curl -sL "$IMG_URL" | base64 $B64FLAGS)'"
              }
            },
            {"text": "Caption this image."}
        ]
      }]
    }' 2> /dev/null

Một vài điều cần lưu ý về dữ liệu hình ảnh nội tuyến:

  • Tổng kích thước yêu cầu tối đa là 20 MB, bao gồm cả lời nhắc văn bản, hướng dẫn hệ thống và tất cả tệp được cung cấp cùng dòng. Nếu kích thước tệp của bạn khiến tổng kích thước yêu cầu vượt quá 20 MB, hãy sử dụng API Tệp để tải tệp hình ảnh lên để sử dụng trong yêu cầu.
  • Nếu bạn đang sử dụng một mẫu hình ảnh nhiều lần, thì bạn nên tải tệp hình ảnh lên bằng File API để đạt được hiệu quả cao hơn.

Lời nhắc có nhiều hình ảnh

Bạn có thể cung cấp nhiều hình ảnh trong một câu lệnh bằng cách đưa nhiều đối tượng hình ảnh Part vào mảng contents. Các tham chiếu này có thể là sự kết hợp giữa dữ liệu cùng dòng (tệp cục bộ hoặc URL) và tham chiếu API tệp.

Python

from google import genai
from google.genai import types

client = genai.Client(api_key="GOOGLE_API_KEY")

# Upload the first image
image1_path = "path/to/image1.jpg"
uploaded_file = client.files.upload(file=image1_path)

# Prepare the second image as inline data
image2_path = "path/to/image2.png"
with open(image2_path, 'rb') as f:
    img2_bytes = f.read()

# Create the prompt with text and multiple images
response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=[
        "What is different between these two images?",
        uploaded_file,  # Use the uploaded file reference
        types.Part.from_bytes(
            data=img2_bytes,
            mime_type='image/png'
        )
    ]
)

print(response.text)

JavaScript

import {
  GoogleGenAI,
  createUserContent,
  createPartFromUri,
} from "@google/genai";
import * as fs from "node:fs";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

async function main() {
  // Upload the first image
  const image1_path = "path/to/image1.jpg";
  const uploadedFile = await ai.files.upload({
    file: image1_path,
    config: { mimeType: "image/jpeg" },
  });

  // Prepare the second image as inline data
  const image2_path = "path/to/image2.png";
  const base64Image2File = fs.readFileSync(image2_path, {
    encoding: "base64",
  });

  // Create the prompt with text and multiple images
  const response = await ai.models.generateContent({
    model: "gemini-2.0-flash",
    contents: createUserContent([
      "What is different between these two images?",
      createPartFromUri(uploadedFile.uri, uploadedFile.mimeType),
      {
        inlineData: {
          mimeType: "image/png",
          data: base64Image2File,
        },
      },
    ]),
  });
  console.log(response.text);
}

await main();

Go

+    // Upload the first image
image1Path := "path/to/image1.jpg"
uploadedFile, err := client.UploadFileFromPath(ctx, image1Path, nil)
if err != nil {
    log.Fatal(err)
}
defer client.DeleteFile(ctx, uploadedFile.Name)

// Prepare the second image as inline data
image2Path := "path/to/image2.png"
img2Bytes, err := os.ReadFile(image2Path)
if err != nil {
  log.Fatal(err)
}

// Create the prompt with text and multiple images
model := client.GenerativeModel("gemini-2.0-flash")
prompt := []genai.Part{
  genai.Text("What is different between these two images?"),
  genai.FileData{URI: uploadedFile.URI},
  genai.Blob{MIMEType: "image/png", Data: img2Bytes},
}

resp, err := model.GenerateContent(ctx, prompt...)
if err != nil {
  log.Fatal(err)
}

printResponse(resp)

REST

# Upload the first image
IMAGE1_PATH="path/to/image1.jpg"
MIME1_TYPE=$(file -b --mime-type "${IMAGE1_PATH}")
NUM1_BYTES=$(wc -c < "${IMAGE1_PATH}")
DISPLAY_NAME1=IMAGE1

tmp_header_file1=upload-header1.tmp

curl "https://generativelanguage.googleapis.com/upload/v1beta/files?key=${GOOGLE_API_KEY}" \
  -D upload-header1.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM1_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME1_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME1}'}}" 2> /dev/null

upload_url1=$(grep -i "x-goog-upload-url: " "${tmp_header_file1}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file1}"

curl "${upload_url1}" \
  -H "Content-Length: ${NUM1_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${IMAGE1_PATH}" 2> /dev/null > file_info1.json

file1_uri=$(jq ".file.uri" file_info1.json)
echo file1_uri=$file1_uri

# Prepare the second image (inline)
IMAGE2_PATH="path/to/image2.png"
MIME2_TYPE=$(file -b --mime-type "${IMAGE2_PATH}")

if [[ "$(base64 --version 2>&1)" = *"FreeBSD"* ]]; then
  B64FLAGS="--input"
else
  B64FLAGS="-w0"
fi
IMAGE2_BASE64=$(base64 $B64FLAGS $IMAGE2_PATH)

# Now generate content using both images
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "What is different between these two images?"},
          {"file_data":{"mime_type": "'"${MIME1_TYPE}"'", "file_uri": '$file1_uri'}},
          {
            "inline_data": {
              "mime_type":"'"${MIME2_TYPE}"'",
              "data": "'"$IMAGE2_BASE64"'"
            }
          }
        ]
      }]
    }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.json

Lấy hộp giới hạn cho một đối tượng

Các mô hình Gemini được huấn luyện để xác định các đối tượng trong hình ảnh và cung cấp toạ độ hộp giới hạn của các đối tượng đó. Toạ độ được trả về tương ứng với kích thước hình ảnh, được điều chỉnh theo tỷ lệ [0, 1000]. Bạn cần điều chỉnh tỷ lệ các toạ độ này dựa trên kích thước hình ảnh gốc.

Python

prompt = "Detect the all of the prominent items in the image. The box_2d should be [ymin, xmin, ymax, xmax] normalized to 0-1000."

JavaScript

const prompt = "Detect the all of the prominent items in the image. The box_2d should be [ymin, xmin, ymax, xmax] normalized to 0-1000.";

Go

prompt := []genai.Part{
    genai.FileData{URI: sampleImage.URI},
    genai.Text("Detect the all of the prominent items in the image. The box_2d should be [ymin, xmin, ymax, xmax] normalized to 0-1000."),
}

REST

PROMPT="Detect the all of the prominent items in the image. The box_2d should be [ymin, xmin, ymax, xmax] normalized to 0-1000."

Bạn có thể sử dụng hộp giới hạn để phát hiện và bản địa hoá đối tượng trong hình ảnh và video. Bằng cách xác định và phân định chính xác các đối tượng bằng hộp giới hạn, bạn có thể mở khoá nhiều ứng dụng và nâng cao tính thông minh của dự án.

Lợi ích chính

  • Đơn giản: Dễ dàng tích hợp các tính năng phát hiện đối tượng vào ứng dụng của bạn, bất kể bạn có chuyên môn về thị giác máy tính hay không.
  • Có thể tuỳ chỉnh: Tạo hộp giới hạn dựa trên hướng dẫn tuỳ chỉnh (ví dụ: "Tôi muốn xem hộp giới hạn của tất cả các đối tượng màu xanh lục trong hình ảnh này") mà không cần phải huấn luyện mô hình tuỳ chỉnh.

Chi tiết kỹ thuật

  • Dữ liệu đầu vào: Câu lệnh của bạn và các hình ảnh hoặc khung video liên quan.
  • Kết quả: Hộp giới hạn ở định dạng [y_min, x_min, y_max, x_max]. Góc trên cùng bên trái là gốc. Trục x và y lần lượt chạy theo chiều ngang và chiều dọc. Giá trị toạ độ được chuẩn hoá thành 0-1000 cho mỗi hình ảnh.
  • Hình ảnh hoá: Người dùng AI Studio sẽ thấy các hộp giới hạn được lập biểu đồ trong giao diện người dùng.

Đối với nhà phát triển Python, hãy thử sổ tay nhận biết không gian 2D hoặc sổ tay thử nghiệm về thao tác trỏ 3D.

Chuẩn hoá toạ độ

Mô hình trả về toạ độ hộp giới hạn ở định dạng [y_min, x_min, y_max, x_max]. Để chuyển đổi các toạ độ chuẩn hoá này thành toạ độ pixel của hình ảnh gốc, hãy làm theo các bước sau:

  1. Chia mỗi toạ độ đầu ra cho 1000.
  2. Nhân toạ độ x với chiều rộng hình ảnh gốc.
  3. Nhân toạ độ y với chiều cao hình ảnh ban đầu.

Để khám phá các ví dụ chi tiết hơn về cách tạo toạ độ hộp giới hạn và hình ảnh hoá các toạ độ đó trên hình ảnh, hãy xem lại ví dụ về sách dạy nấu ăn về tính năng Phát hiện đối tượng.

Phân đoạn hình ảnh

Kể từ các mô hình Gemini 2.5, các mô hình Gemini được huấn luyện để không chỉ phát hiện các mục mà còn phân đoạn các mục đó và cung cấp mặt nạ của đường viền.

Mô hình này dự đoán một danh sách JSON, trong đó mỗi mục đại diện cho một mặt nạ phân đoạn. Mỗi mục có một hộp giới hạn ("box_2d") ở định dạng [y0, x0, y1, x1] với các toạ độ chuẩn hoá từ 0 đến 1000, một nhãn ("label") xác định đối tượng và cuối cùng là mặt nạ phân đoạn bên trong hộp giới hạn, dưới dạng tệp png được mã hoá base64, là bản đồ xác suất có giá trị từ 0 đến 255. Bạn cần đổi kích thước mặt nạ để khớp với kích thước hộp giới hạn, sau đó chuyển đổi sang nhị phân ở ngưỡng độ tin cậy (127 cho điểm giữa).

Python

prompt = """
  Give the segmentation masks for the wooden and glass items.
  Output a JSON list of segmentation masks where each entry contains the 2D
  bounding box in the key "box_2d", the segmentation mask in key "mask", and
  the text label in the key "label". Use descriptive labels.
"""

JavaScript

const prompt = `
  Give the segmentation masks for the wooden and glass items.
  Output a JSON list of segmentation masks where each entry contains the 2D
  bounding box in the key "box_2d", the segmentation mask in key "mask", and
  the text label in the key "label". Use descriptive labels.
`;

Go

prompt := []genai.Part{
    genai.FileData{URI: sampleImage.URI},
    genai.Text(`
      Give the segmentation masks for the wooden and glass items.
      Output a JSON list of segmentation masks where each entry contains the 2D
      bounding box in the key "box_2d", the segmentation mask in key "mask", and
      the text label in the key "label". Use descriptive labels.
    `),
}

REST

PROMPT='''
  Give the segmentation masks for the wooden and glass items.
  Output a JSON list of segmentation masks where each entry contains the 2D
  bounding box in the key "box_2d", the segmentation mask in key "mask", and
  the text label in the key "label". Use descriptive labels.
'''
Một chiếc bàn có bánh cupcake, trong đó các vật thể bằng gỗ và thủy tinh được làm nổi bật
Mặt nạ của các vật thể bằng gỗ và thủy tinh có trong bức ảnh

Hãy xem ví dụ về phân đoạn trong hướng dẫn về sách dạy nấu ăn để biết ví dụ chi tiết hơn.

Định dạng hình ảnh được hỗ trợ

Gemini hỗ trợ các loại MIME định dạng hình ảnh sau:

  • PNG – image/png
  • JPEG – image/jpeg
  • WEBP – image/webp
  • HEIC – image/heic
  • HEIF – image/heif

Thông tin chi tiết kỹ thuật về hình ảnh

  • Giới hạn về tệp: Gemini 2.5 Pro, 2.0 Flash, 1.5 Pro và 1.5 Flash hỗ trợ tối đa 3.600 tệp hình ảnh cho mỗi yêu cầu.
  • Tính toán mã thông báo:
    • Gemini 1.5 Flash và Gemini 1.5 Pro: 258 mã thông báo nếu cả hai kích thước đều <= 384 pixel. Hình ảnh lớn hơn được xếp kề (kích thước ô tối thiểu 256px, tối đa 768px, đổi kích thước thành 768x768), mỗi ô có giá 258 mã thông báo.
    • Gemini 2.0 Flash: 258 mã thông báo nếu cả hai kích thước <= 384 pixel. Hình ảnh lớn hơn được xếp kề thành các ô 768x768 pixel, mỗi ô có giá 258 mã thông báo.
  • Các phương pháp hay nhất:
    • Đảm bảo hình ảnh được xoay chính xác.
    • Sử dụng hình ảnh rõ ràng, không bị mờ.
    • Khi sử dụng một hình ảnh có văn bản, hãy đặt câu lệnh văn bản sau phần hình ảnh trong mảng contents.

Bước tiếp theo

Hướng dẫn này cho biết cách tải tệp hình ảnh lên và tạo đầu ra văn bản từ dữ liệu đầu vào hình ảnh. Để tìm hiểu thêm, hãy xem các tài nguyên sau:

  • Hướng dẫn hệ thống: Hướng dẫn hệ thống cho phép bạn điều hướng hành vi của mô hình dựa trên nhu cầu và trường hợp sử dụng cụ thể của bạn.
  • Tìm hiểu video: Tìm hiểu cách xử lý dữ liệu đầu vào dạng video.
  • Files API (API Tệp): Tìm hiểu thêm về cách tải lên và quản lý tệp để sử dụng với Gemini.
  • Chiến lược nhắc tệp: Gemini API hỗ trợ nhắc bằng dữ liệu văn bản, hình ảnh, âm thanh và video, còn gọi là nhắc đa phương thức.
  • Hướng dẫn về an toàn: Đôi khi, các mô hình AI tạo sinh tạo ra kết quả không mong muốn, chẳng hạn như kết quả không chính xác, thiên vị hoặc phản cảm. Quá trình xử lý hậu kỳ và đánh giá của con người là điều cần thiết để hạn chế rủi ro gây hại từ những kết quả như vậy.