Langsung ke konten utama

Masuk

Model audio native baru tersedia untuk Live API. Pelajari lebih lanjut

Halaman ini diterjemahkan oleh Cloud Translation API.

• Beranda
• Gemini API
• Model

Apakah informasi ini membantu?

Pemahaman gambar

Model Gemini dibangun dari awal untuk mendukung multimodalitas, sehingga dapat melakukan berbagai tugas pemrosesan gambar dan computer vision, termasuk tetapi tidak terbatas pada pemberian teks gambar, klasifikasi, dan menjawab pertanyaan visual tanpa harus melatih model ML khusus.

Tips: Selain kemampuan multimodal umumnya, model Gemini (2.0 dan yang lebih baru) menawarkan akurasi yang lebih baik untuk kasus penggunaan tertentu seperti deteksi objek dan segmentasi, melalui pelatihan tambahan. Lihat bagian Kemampuan untuk mengetahui detail selengkapnya.

Meneruskan gambar ke Gemini

Anda dapat memberikan gambar sebagai input ke Gemini menggunakan dua metode:

• Meneruskan data gambar inline: Ideal untuk file yang lebih kecil (ukuran total permintaan kurang dari 20 MB, termasuk perintah).
• Mengupload gambar menggunakan File API: Direkomendasikan untuk file yang lebih besar atau untuk menggunakan kembali gambar di beberapa permintaan.

Meneruskan data gambar inline

Anda dapat meneruskan data gambar inline dalam permintaan ke generateContent. Anda dapat menyediakan data gambar sebagai string berenkode Base64 atau dengan membaca file lokal secara langsung (bergantung pada bahasa).

Contoh berikut menunjukkan cara membaca gambar dari file lokal dan meneruskannya ke generateContent API untuk diproses.

PythonJavaScript

  from google.genai import types

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

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

  print(response.text)

Anda juga dapat mengambil gambar dari URL, mengonversinya ke byte, dan meneruskannya ke generateContent seperti yang ditunjukkan dalam contoh berikut.

PythonJavaScript

from google import genai
from google.genai import types

import requests

image_path = "https://goo.gle/instrument-img"
image_bytes = requests.get(image_path).content
image = types.Part.from_bytes(
  data=image_bytes, mime_type="image/jpeg"
)

client = genai.Client()

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=["What is this image?", image],
)

print(response.text)

Catatan: Data gambar inline membatasi ukuran total permintaan Anda (perintah teks, petunjuk sistem, dan byte inline) hingga 20 MB. Untuk permintaan yang lebih besar, upload file gambar menggunakan File API. Files API juga lebih efisien untuk skenario yang menggunakan gambar yang sama berulang kali.

Mengupload gambar menggunakan File API

Untuk file besar atau agar dapat menggunakan file gambar yang sama berulang kali, gunakan Files API. Kode berikut mengupload file gambar, lalu menggunakan file tersebut dalam panggilan ke generateContent. Lihat panduan Files API untuk mengetahui informasi dan contoh selengkapnya.

PythonJavaScript

from google import genai

client = genai.Client()

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

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

print(response.text)

Membuat perintah dengan beberapa gambar

Anda dapat memberikan beberapa gambar dalam satu perintah dengan menyertakan beberapa objek gambar Part dalam array contents. Ini dapat berupa campuran data inline (file lokal atau URL) dan referensi File API.

PythonJavaScript

from google import genai
from google.genai import types

client = genai.Client()

# 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.5-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)

Deteksi objek

Mulai dari Gemini 2.0, model dilatih lebih lanjut untuk mendeteksi objek dalam gambar dan mendapatkan koordinat kotak pembatasnya. Koordinat, relatif terhadap dimensi gambar, diskalakan ke [0, 1000]. Anda harus membatalkan penskalaan koordinat ini berdasarkan ukuran gambar asli Anda.

Python

from google import genai
from google.genai import types
from PIL import Image
import json

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

image = Image.open("/path/to/image.png")

config = types.GenerateContentConfig(
  response_mime_type="application/json"
  )

response = client.models.generate_content(model="gemini-2.5-flash",
                                          contents=[image, prompt],
                                          config=config
                                          )

width, height = image.size
bounding_boxes = json.loads(response.text)

converted_bounding_boxes = []
for bounding_box in bounding_boxes:
    abs_y1 = int(bounding_box["box_2d"][0]/1000 * height)
    abs_x1 = int(bounding_box["box_2d"][1]/1000 * width)
    abs_y2 = int(bounding_box["box_2d"][2]/1000 * height)
    abs_x2 = int(bounding_box["box_2d"][3]/1000 * width)
    converted_bounding_boxes.append([abs_x1, abs_y1, abs_x2, abs_y2])

print("Image size: ", width, height)
print("Bounding boxes:", converted_bounding_boxes)

Catatan: Model ini juga mendukung pembuatan kotak pembatas berdasarkan petunjuk kustom, seperti: "Tampilkan kotak pembatas semua objek hijau dalam gambar ini". Fitur ini juga mendukung label kustom seperti "beri label pada item dengan alergen yang mungkin terkandung di dalamnya".

Untuk contoh lainnya, lihat notebook berikut di Gemini Cookbook:

• Notebook pemahaman spasial 2D
• Notebook penunjuk 3D eksperimental

Segmentasi

Mulai dari Gemini 2.5, model tidak hanya mendeteksi item, tetapi juga menyegmentasikannya dan memberikan masker konturnya.

Model memprediksi daftar JSON, dengan setiap item mewakili mask segmentasi. Setiap item memiliki kotak pembatas ("box_2d") dalam format [y0, x0, y1, x1] dengan koordinat yang dinormalisasi antara 0 dan 1000, label ("label") yang mengidentifikasi objek, dan terakhir mask segmentasi di dalam kotak pembatas, sebagai png yang dienkode base64 yang merupakan peta probabilitas dengan nilai antara 0 dan 255. Masker perlu diubah ukurannya agar sesuai dengan dimensi kotak pembatas, lalu dikonversi menjadi biner pada ambang batas keyakinan Anda (127 untuk titik tengah).

Catatan: Untuk hasil yang lebih baik, nonaktifkan pemikiran dengan menyetel anggaran pemikiran ke 0. Lihat contoh kode di bawah.

Python

from google import genai
from google.genai import types
from PIL import Image, ImageDraw
import io
import base64
import json
import numpy as np
import os

client = genai.Client()

def parse_json(json_output: str):
  # Parsing out the markdown fencing
  lines = json_output.splitlines()
  for i, line in enumerate(lines):
    if line == "```json":
      json_output = "\n".join(lines[i+1:])  # Remove everything before "```json"
      output = json_output.split("```")[0]  # Remove everything after the closing "```"
      break  # Exit the loop once "```json" is found
  return json_output

def extract_segmentation_masks(image_path: str, output_dir: str = "segmentation_outputs"):
  # Load and resize image
  im = Image.open(image_path)
  im.thumbnail([1024, 1024], Image.Resampling.LANCZOS)

  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.
  """

  config = types.GenerateContentConfig(
    thinking_config=types.ThinkingConfig(thinking_budget=0) # set thinking_budget to 0 for better results in object detection
  )

  response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[prompt, im], # Pillow images can be directly passed as inputs (which will be converted by the SDK)
    config=config
  )

  # Parse JSON response
  items = json.loads(parse_json(response.text))

  # Create output directory
  os.makedirs(output_dir, exist_ok=True)

  # Process each mask
  for i, item in enumerate(items):
      # Get bounding box coordinates
      box = item["box_2d"]
      y0 = int(box[0] / 1000 * im.size[1])
      x0 = int(box[1] / 1000 * im.size[0])
      y1 = int(box[2] / 1000 * im.size[1])
      x1 = int(box[3] / 1000 * im.size[0])

      # Skip invalid boxes
      if y0 >= y1 or x0 >= x1:
          continue

      # Process mask
      png_str = item["mask"]
      if not png_str.startswith("data:image/png;base64,"):
          continue

      # Remove prefix
      png_str = png_str.removeprefix("data:image/png;base64,")
      mask_data = base64.b64decode(png_str)
      mask = Image.open(io.BytesIO(mask_data))

      # Resize mask to match bounding box
      mask = mask.resize((x1 - x0, y1 - y0), Image.Resampling.BILINEAR)

      # Convert mask to numpy array for processing
      mask_array = np.array(mask)

      # Create overlay for this mask
      overlay = Image.new('RGBA', im.size, (0, 0, 0, 0))
      overlay_draw = ImageDraw.Draw(overlay)

      # Create overlay for the mask
      color = (255, 255, 255, 200)
      for y in range(y0, y1):
          for x in range(x0, x1):
              if mask_array[y - y0, x - x0] > 128:  # Threshold for mask
                  overlay_draw.point((x, y), fill=color)

      # Save individual mask and its overlay
      mask_filename = f"{item['label']}_{i}_mask.png"
      overlay_filename = f"{item['label']}_{i}_overlay.png"

      mask.save(os.path.join(output_dir, mask_filename))

      # Create and save overlay
      composite = Image.alpha_composite(im.convert('RGBA'), overlay)
      composite.save(os.path.join(output_dir, overlay_filename))
      print(f"Saved mask and overlay for {item['label']} to {output_dir}")

# Example usage
if __name__ == "__main__":
  extract_segmentation_masks("path/to/image.png")

Lihat contoh segmentasi dalam panduan cookbook untuk contoh yang lebih mendetail.

Contoh output segmentasi dengan objek dan mask segmentasi

Format gambar yang didukung

Gemini mendukung jenis MIME format gambar berikut:

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

Kemampuan

Semua versi model Gemini bersifat multimodal dan dapat digunakan dalam berbagai tugas pemrosesan gambar dan computer vision, termasuk, tetapi tidak terbatas pada pemberian teks pada gambar, pertanyaan dan jawaban visual, klasifikasi gambar, deteksi dan segmentasi objek.

Gemini dapat mengurangi kebutuhan untuk menggunakan model ML khusus, bergantung pada persyaratan kualitas dan performa Anda.

Beberapa versi model yang lebih baru dilatih secara khusus untuk meningkatkan akurasi tugas khusus selain kemampuan umum:

• Model Gemini 2.0 dilatih lebih lanjut untuk mendukung deteksi objek yang lebih baik.

• Model Gemini 2.5 dilatih lebih lanjut untuk mendukung segmentasi yang ditingkatkan selain deteksi objek.

Batasan dan informasi teknis utama

Batas file

Gemini 2.5 Pro/Flash, 2.0 Flash, 1.5 Pro, dan 1.5 Flash mendukung maksimal 3.600 file gambar per permintaan.

Penghitungan token

• Gemini 1.5 Flash dan Gemini 1.5 Pro: 258 token jika kedua dimensi <= 384 piksel. Gambar yang lebih besar disusun dalam petak (petak min. 256 piksel, maks. 768 piksel, diubah ukurannya menjadi 768x768), dengan setiap petak berharga 258 token.
• Gemini 2.0 Flash dan Gemini 2.5 Flash/Pro: 258 token jika kedua dimensi <= 384 piksel. Gambar yang lebih besar diatur menjadi ubin 768x768 piksel, yang masing-masing berharga 258 token.

Formula kasar untuk menghitung jumlah kartu adalah sebagai berikut:

• Hitung ukuran unit pangkas yang kira-kira: floor(min(width, height) / 1.5).
• Bagi setiap dimensi dengan ukuran unit pangkas dan kalikan bersama untuk mendapatkan jumlah petak.

Misalnya, gambar berdimensi 960x540 akan memiliki ukuran unit pangkas 360. Bagilah setiap dimensi dengan 360 dan jumlah petak adalah 3 * 2 = 6.

Tips dan praktik terbaik

• Pastikan gambar diputar dengan benar.
• Gunakan gambar yang jelas dan tidak buram.
• Saat menggunakan satu gambar dengan teks, tempatkan perintah teks setelah bagian gambar dalam array contents.

Langkah berikutnya

Panduan ini menunjukkan cara mengupload file gambar dan membuat output teks dari input gambar. Untuk mempelajari lebih lanjut, lihat referensi berikut:

• Files API: Pelajari lebih lanjut cara mengupload dan mengelola file untuk digunakan dengan Gemini.
• Petunjuk sistem: Petunjuk sistem memungkinkan Anda mengarahkan perilaku model berdasarkan kebutuhan dan kasus penggunaan spesifik Anda.
• Strategi perintah file: Gemini API mendukung perintah dengan data teks, gambar, audio, dan video, yang juga dikenal sebagai perintah multimodal.
• Panduan keamanan: Terkadang model AI generatif menghasilkan output yang tidak terduga, seperti output yang tidak akurat, bias, atau menyinggung. Pemrosesan pasca-output dan evaluasi manusia sangat penting untuk membatasi risiko bahaya dari output tersebut.

Apakah informasi ini membantu?

Kecuali dinyatakan lain, konten di halaman ini dilisensikan berdasarkan Lisensi Creative Commons Attribution 4.0, sedangkan contoh kode dilisensikan berdasarkan Lisensi Apache 2.0. Untuk mengetahui informasi selengkapnya, lihat Kebijakan Situs Google Developers. Java adalah merek dagang terdaftar dari Oracle dan/atau afiliasinya.

Terakhir diperbarui pada 2025-10-11 UTC.

• Persyaratan
• Privasi