मीडिया का रिज़ॉल्यूशन

media_resolution पैरामीटर से यह कंट्रोल किया जाता है कि Gemini API, मीडिया इनपुट को कैसे प्रोसेस करता है. जैसे, इमेज, वीडियो, ऑडियो, और PDF दस्तावेज़. इसके लिए, मीडिया इनपुट के लिए ज़्यादा से ज़्यादा टोकन की संख्या तय की जाती है. इससे, रिस्पॉन्स की क्वालिटी, इंतज़ार में लगने वाले समय, और लागत के बीच सही तालमेल बिठाया जा सकता है. विज़ुअल और दस्तावेज़ के इनपुट के लिए, रिज़ॉल्यूशन सेटिंग के हिसाब से टोकन का बंटवारा किया जाता है. वहीं, ऑडियो इनपुट के लिए, सभी रिज़ॉल्यूशन लेवल पर हर सेकंड के हिसाब से टोकन की संख्या तय होती है. अलग-अलग सेटिंग, डिफ़ॉल्ट वैल्यू, और टोकन की संख्या के बारे में जानने के लिए, टोकन की संख्या वाला सेक्शन देखें.

अनुरोध में शामिल हर मीडिया ऑब्जेक्ट (कॉन्टेंट आइटम) के लिए, मीडिया रिज़ॉल्यूशन कॉन्फ़िगर किया जा सकता है. यह सुविधा Gemini 4 और Gemini 3 मॉडल के लिए उपलब्ध है.

हर कॉन्टेंट आइटम के लिए मीडिया रिज़ॉल्यूशन सेट करना (Gemini 4 और Gemini 3 मॉडल)

Gemini 4 और Gemini 3 मॉडल में, अनुरोध में शामिल हर मीडिया ऑब्जेक्ट के लिए मीडिया रिज़ॉल्यूशन सेट किया जा सकता है. इससे, टोकन के इस्तेमाल को बेहतर तरीके से ऑप्टिमाइज़ किया जा सकता है. एक ही अनुरोध में, अलग-अलग रिज़ॉल्यूशन लेवल का इस्तेमाल किया जा सकता है. उदाहरण के लिए, किसी मुश्किल डायग्राम के लिए हाई रिज़ॉल्यूशन और किसी सामान्य कॉन्टेक्चुअल इमेज के लिए लो रिज़ॉल्यूशन का इस्तेमाल किया जा सकता है.

from google import genai

client = genai.Client()

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

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input=[
        {"type": "text", "text": "Describe this image:"},
        {
            "type": "image",
            "uri": myfile.uri,
            "mime_type": myfile.mime_type,
            "resolution": "high"
        }
    ]
)
print(interaction.output_text)

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

const ai = new GoogleGenAI({});

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

  const interaction = await ai.interactions.create({
    model: "gemini-3.8-flash",
    input: [
      { type: "text", text: "Describe this image:" },
      {
        type: "image",
        uri: myfile.uri,
        mime_type: myfile.mimeType,
        resolution: "high"
      }
    ],
  });
  console.log(interaction.output_text);
}

await main();

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.Content;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.ImageContent;
import com.google.genai.gaos.models.interactions.ImageContentMimeType;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.TextContent;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;
import java.util.List;

Client client = new Client();

Content textContent = TextContent.builder().text("Describe the details in this high-resolution image.").build();
Content imageContent =
    ImageContent.builder()
        .uri("gs://cloud-samples-data/generative-ai/image/scones.jpg")
        .mimeType(ImageContentMimeType.IMAGE_JPEG)
        .build();

List<Content> contents = Arrays.asList(textContent, imageContent);

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.8-flash"))
        .input(InteractionsInput.ofContent(contents))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(interaction.outputText().orElse(""));

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    uploadedFile, err := client.Files.UploadFromPath(ctx, "path/to/image.jpg", nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-3.8-flash"),
            Input: interactions.NewInteractionsInput([]interactions.Content{
                interactions.NewContent(interactions.TextContent{
                    Text: "Describe the details in this high-resolution image.",
                }),
                interactions.NewContent(interactions.ImageContent{
                    URI:        genai.Ptr(uploadedFile.URI),
                    MimeType:   interactions.ImageContentMimeType(uploadedFile.MIMEType).ToPointer(),
                    Resolution: interactions.MediaResolutionHigh.ToPointer(),
                }),
            }),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    if res.Interaction.OutputText != nil {
        fmt.Println(*res.Interaction.OutputText)
    }
}

# First upload the file using the Files API, then use the URI:
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3.8-flash",
    "input": [
      {"type": "text", "text": "Describe this image:"},
      {
        "type": "image",
        "uri": "YOUR_FILE_URI",
        "mime_type": "image/jpeg",
        "resolution": "high"
      }
    ]
  }'

उपलब्ध रिज़ॉल्यूशन वैल्यू

Gemini API, मीडिया रिज़ॉल्यूशन के लिए ये लेवल तय करता है:

• unspecified: यह डिफ़ॉल्ट सेटिंग है. इस लेवल के लिए टोकन की संख्या, Gemini 4/3 और Gemini के पुराने मॉडल के बीच काफ़ी अलग-अलग होती है.
• low: इसमें टोकन की संख्या कम होती है. इससे, प्रोसेसिंग की स्पीड बढ़ती है और लागत कम होती है. हालांकि, इसमें कम जानकारी मिलती है.
• medium: इसमें जानकारी, लागत, और इंतज़ार में लगने वाले समय के बीच सही तालमेल होता है.
• high: इसमें टोकन की संख्या ज़्यादा होती है. इससे मॉडल को काम करने के लिए ज़्यादा जानकारी मिलती है. हालांकि, इसमें इंतज़ार में लगने वाला समय और लागत बढ़ जाती है.
• ultra_high (सिर्फ़ हर कॉन्टेंट आइटम के लिए): इसमें टोकन की संख्या सबसे ज़्यादा होती है. इसका इस्तेमाल, खास इस्तेमाल के उदाहरणों के लिए किया जाता है. जैसे, कंप्यूटर का इस्तेमाल.

ध्यान दें कि ज़्यादातर इस्तेमाल के उदाहरणों के लिए, high सेटिंग सबसे अच्छी परफ़ॉर्मेंस देती है.

इनमें से हर लेवल के लिए जनरेट होने वाले टोकन की सटीक संख्या, मीडिया के टाइप (इमेज, वीडियो, ऑडियो, PDF) और मॉडल के वर्शन दोनों पर निर्भर करती है.

टोकन की संख्या

यहां दी गई टेबल में, हर मॉडल फ़ैमिली के लिए, हर media_resolution वैल्यू और मीडिया टाइप के लिए, टोकन की अनुमानित संख्या की खास जानकारी दी गई है.

Gemini 4 और Gemini 3 मॉडल

सही रिज़ॉल्यूशन चुनना

• डिफ़ॉल्ट (unspecified): डिफ़ॉल्ट सेटिंग से शुरू करें. इसे, ज़्यादातर इस्तेमाल के उदाहरणों के लिए, क्वालिटी, इंतज़ार में लगने वाले समय, और लागत के बीच सही तालमेल बिठाने के लिए ऑप्टिमाइज़ किया गया है.
• low: इसका इस्तेमाल उन स्थितियों में करें जहां लागत और इंतज़ार में लगने वाला समय सबसे अहम हो और ज़्यादा जानकारी की ज़रूरत न हो.
• medium / high: जब किसी टास्क के लिए, मीडिया में मौजूद जटिल जानकारी को समझने की ज़रूरत हो, तब रिज़ॉल्यूशन बढ़ाएं. इसकी ज़रूरत अक्सर, जटिल विज़ुअल विश्लेषण, चार्ट पढ़ने या ज़्यादा जानकारी वाले दस्तावेज़ को समझने के लिए होती है.
• ultra_high - यह सेटिंग सिर्फ़ हर कॉन्टेंट आइटम के लिए उपलब्ध है. इसका इस्तेमाल, खास इस्तेमाल के उदाहरणों के लिए किया जाता है. जैसे, कंप्यूटर का इस्तेमाल. इसके अलावा, इसका इस्तेमाल तब किया जाता है, जब टेस्टिंग से पता चलता है कि high के मुकाबले, इससे बेहतर नतीजे मिलते हैं.
• हर कॉन्टेंट आइटम के लिए कंट्रोल (Gemini 4 और Gemini 3): इससे टोकन के इस्तेमाल को ऑप्टिमाइज़ किया जाता है. उदाहरण के लिए, एक ऐसे प्रॉम्प्ट में जिसमें कई इमेज शामिल हैं, किसी जटिल डायग्राम के लिए high और सामान्य कॉन्टेक्चुअल इमेज के लिए low या medium का इस्तेमाल करें.

सुझाई गई सेटिंग

यहां, मीडिया के हर टाइप के लिए, मीडिया रिज़ॉल्यूशन की सुझाई गई सेटिंग दी गई हैं.

क्वालिटी, इंतज़ार में लगने वाले समय, और लागत के बीच सही तालमेल बिठाने के लिए, अपने ऐप्लिकेशन पर अलग-अलग रिज़ॉल्यूशन सेटिंग की जांच करें और उनके असर का आकलन करें.

वीडियो प्रोसेसिंग मोड के साथ संबंध

media_resolution और प्रोसेसिंग पैरामीटर, वीडियो इनपुट के अलग-अलग पहलुओं को कंट्रोल करते हैं:

• media_resolution से, हर फ़्रेम के रिज़ॉल्यूशन (हर फ़्रेम के लिए टोकन की संख्या) को कंट्रोल किया जाता है.
• processing / media_processing से यह कंट्रोल किया जाता है कि वीडियो का कौनसा कॉन्टेंट, कॉन्टेक्स्ट में लोड किया जाए.

एक ही वीडियो इनपुट के लिए, दोनों सेटिंग सेट की जा सकती हैं. उदाहरण के लिए, किसी लंबे वीडियो के लिए, टोकन के कुल इस्तेमाल को कम करने के लिए, कम मीडिया रिज़ॉल्यूशन के साथ एजेंटिक प्रोसेसिंग का इस्तेमाल किया जा सकता है.

वीडियो प्रोसेसिंग मोड के बारे में ज़्यादा जानने के लिए, एजेंटिक वीडियो को समझने की गाइड देखें.

वर्शन के साथ काम करने वाली सुविधाओं की खास जानकारी

• हर कॉन्टेंट आइटम के लिए resolution सेट करने की सुविधा, Gemini 4 और Gemini 3 मॉडल के लिए उपलब्ध है.

अगले चरण

• Gemini API की मल्टीमॉडल क्षमताओं के बारे में ज़्यादा जानने के लिए, इमेज को समझने, वीडियो को समझने, ऑडियो को समझने, और दस्तावेज़ को समझने की गाइड पढ़ें.