Image generation

Gemini API का इस्तेमाल करके, Gemini की पहले से मौजूद कई मोड वाली सुविधाओं या Google के इमेज जनरेट करने वाले खास मॉडल, Imagen की मदद से इमेज जनरेट की जा सकती हैं. ज़्यादातर इस्तेमाल के उदाहरणों के लिए, Gemini से शुरुआत करें. खास टास्क के लिए Imagen चुनें. इनमें इमेज की क्वालिटी अहम होती है. ज़्यादा जानकारी के लिए, सही मॉडल चुनना सेक्शन देखें.

जनरेट की गई सभी इमेज में SynthID वॉटरमार्क शामिल होता है.

शुरू करने से पहले

पक्का करें कि इमेज जनरेट करने के लिए, इस्तेमाल किया जा रहा मॉडल और वर्शन काम करता हो:

• Gemini के लिए, Gemini 2.0 Flash की मदद से झलक वाली इमेज जनरेट करने की सुविधा का इस्तेमाल करें.

• Imagen के लिए, Imagen 3 का इस्तेमाल करें. ध्यान दें कि यह मॉडल सिर्फ़ पैसे चुकाकर ली जाने वाली सदस्यता पर उपलब्ध है.

एक ही लाइब्रेरी का इस्तेमाल करके, Gemini और Imagen 3, दोनों को ऐक्सेस किया जा सकता है.

Gemini का इस्तेमाल करके इमेज जनरेट करना

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

आपको अपने कॉन्फ़िगरेशन में responseModalities: ["TEXT", "IMAGE"] शामिल करना होगा. इन मॉडल के साथ, सिर्फ़ इमेज वाला आउटपुट नहीं मिलता.

इमेज जनरेट करने की सुविधा (टेक्स्ट से इमेज)

यहां दिए गए कोड में, जानकारी वाले प्रॉम्प्ट के आधार पर इमेज जनरेट करने का तरीका बताया गया है:

from google import genai
from google.genai import types
from PIL import Image
from io import BytesIO
import base64

client = genai.Client()

contents = ('Hi, can you create a 3d rendered image of a pig '
            'with wings and a top hat flying over a happy '
            'futuristic scifi city with lots of greenery?')

response = client.models.generate_content(
    model="gemini-2.0-flash-preview-image-generation",
    contents=contents,
    config=types.GenerateContentConfig(
      response_modalities=['TEXT', 'IMAGE']
    )
)

for part in response.candidates[0].content.parts:
  if part.text is not None:
    print(part.text)
  elif part.inline_data is not None:
    image = Image.open(BytesIO((part.inline_data.data)))
    image.save('gemini-native-image.png')
    image.show()

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

async function main() {

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

  const contents =
    "Hi, can you create a 3d rendered image of a pig " +
    "with wings and a top hat flying over a happy " +
    "futuristic scifi city with lots of greenery?";

  // Set responseModalities to include "Image" so the model can generate  an image
  const response = await ai.models.generateContent({
    model: "gemini-2.0-flash-preview-image-generation",
    contents: contents,
    config: {
      responseModalities: [Modality.TEXT, Modality.IMAGE],
    },
  });
  for (const part of response.candidates[0].content.parts) {
    // Based on the part type, either show the text or save the image
    if (part.text) {
      console.log(part.text);
    } else if (part.inlineData) {
      const imageData = part.inlineData.data;
      const buffer = Buffer.from(imageData, "base64");
      fs.writeFileSync("gemini-native-image.png", buffer);
      console.log("Image saved as gemini-native-image.png");
    }
  }
}

main();

package main

import (
  "context"
  "fmt"
  "os"
  "google.golang.org/genai"
)

func main() {

  ctx := context.Background()
  client, _ := genai.NewClient(ctx, &genai.ClientConfig{
      APIKey:  os.Getenv("GEMINI_API_KEY"),
      Backend: genai.BackendGeminiAPI,
  })

  config := &genai.GenerateContentConfig{
      ResponseModalities: []string{"TEXT", "IMAGE"},
  }

  result, _ := client.Models.GenerateContent(
      ctx,
      "gemini-2.0-flash-preview-image-generation",
      genai.Text("Hi, can you create a 3d rendered image of a pig " +
                 "with wings and a top hat flying over a happy " +
                 "futuristic scifi city with lots of greenery?"),
      config,
  )

  for _, part := range result.Candidates[0].Content.Parts {
      if part.Text != "" {
          fmt.Println(part.Text)
      } else if part.InlineData != nil {
          imageBytes := part.InlineData.Data
          outputFilename := "gemini_generated_image.png"
          _ = os.WriteFile(outputFilename, imageBytes, 0644)
      }
  }
}

curl -s -X POST \
  "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-preview-image-generation:generateContent?key=$GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "parts": [
        {"text": "Hi, can you create a 3d rendered image of a pig with wings and a top hat flying over a happy futuristic scifi city with lots of greenery?"}
      ]
    }],
    "generationConfig":{"responseModalities":["TEXT","IMAGE"]}
  }' \
  | grep -o '"data": "[^"]*"' \
  | cut -d'"' -f4 \
  | base64 --decode > gemini-native-image.png

इमेज में बदलाव करना (टेक्स्ट और इमेज को एक-दूसरे में बदलना)

इमेज में बदलाव करने के लिए, इनपुट के तौर पर कोई इमेज जोड़ें. नीचे दिए गए उदाहरण में, Base64 कोड में बदली गई इमेज अपलोड करने का तरीका बताया गया है. एक से ज़्यादा इमेज और बड़े पेलोड के लिए, इमेज इनपुट सेक्शन देखें.

from google import genai
from google.genai import types
from PIL import Image
from io import BytesIO

import PIL.Image

image = PIL.Image.open('/path/to/image.png')

client = genai.Client()

text_input = ('Hi, This is a picture of me.'
            'Can you add a llama next to me?',)

response = client.models.generate_content(
    model="gemini-2.0-flash-preview-image-generation",
    contents=[text_input, image],
    config=types.GenerateContentConfig(
      response_modalities=['TEXT', 'IMAGE']
    )
)

for part in response.candidates[0].content.parts:
  if part.text is not None:
    print(part.text)
  elif part.inline_data is not None:
    image = Image.open(BytesIO(part.inline_data.data))
    image.show()

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

async function main() {

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

  // Load the image from the local file system
  const imagePath = "path/to/image.png";
  const imageData = fs.readFileSync(imagePath);
  const base64Image = imageData.toString("base64");

  // Prepare the content parts
  const contents = [
    { text: "Can you add a llama next to the image?" },
    {
      inlineData: {
        mimeType: "image/png",
        data: base64Image,
      },
    },
  ];

  // Set responseModalities to include "Image" so the model can generate an image
  const response = await ai.models.generateContent({
    model: "gemini-2.0-flash-preview-image-generation",
    contents: contents,
    config: {
      responseModalities: [Modality.TEXT, Modality.IMAGE],
    },
  });
  for (const part of response.candidates[0].content.parts) {
    // Based on the part type, either show the text or save the image
    if (part.text) {
      console.log(part.text);
    } else if (part.inlineData) {
      const imageData = part.inlineData.data;
      const buffer = Buffer.from(imageData, "base64");
      fs.writeFileSync("gemini-native-image.png", buffer);
      console.log("Image saved as gemini-native-image.png");
    }
  }
}

main();

package main

import (
 "context"
 "fmt"
 "os"
 "google.golang.org/genai"
)

func main() {

 ctx := context.Background()
 client, _ := genai.NewClient(ctx, &genai.ClientConfig{
     APIKey:  os.Getenv("GEMINI_API_KEY"),
     Backend: genai.BackendGeminiAPI,
 })

 imagePath := "/path/to/image.png"
 imgData, _ := os.ReadFile(imagePath)

 parts := []*genai.Part{
   genai.NewPartFromText("Hi, This is a picture of me. Can you add a llama next to me?"),
   &genai.Part{
     InlineData: &genai.Blob{
       MIMEType: "image/png",
       Data:     imgData,
     },
   },
 }

 contents := []*genai.Content{
   genai.NewContentFromParts(parts, genai.RoleUser),
 }

 config := &genai.GenerateContentConfig{
     ResponseModalities: []string{"TEXT", "IMAGE"},
 }

 result, _ := client.Models.GenerateContent(
     ctx,
     "gemini-2.0-flash-preview-image-generation",
     contents,
     config,
 )

 for _, part := range result.Candidates[0].Content.Parts {
     if part.Text != "" {
         fmt.Println(part.Text)
     } else if part.InlineData != nil {
         imageBytes := part.InlineData.Data
         outputFilename := "gemini_generated_image.png"
         _ = os.WriteFile(outputFilename, imageBytes, 0644)
     }
 }
}

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

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

IMG_BASE64=$(base64 "$B64FLAGS" "$IMG_PATH" 2>&1)

curl -X POST \
  "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-preview-image-generation:generateContent?key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -d "{
      \"contents\": [{
        \"parts\":[
            {\"text\": \"'Hi, This is a picture of me. Can you add a llama next to me\"},
            {
              \"inline_data\": {
                \"mime_type\":\"image/jpeg\",
                \"data\": \"$IMG_BASE64\"
              }
            }
        ]
      }],
      \"generationConfig\": {\"responseModalities\": [\"TEXT\", \"IMAGE\"]}
    }"  \
  | grep -o '"data": "[^"]*"' \
  | cut -d'"' -f4 \
  | base64 --decode > gemini-edited-image.png

इमेज जनरेट करने के अन्य मोड

Gemini, प्रॉम्प्ट के स्ट्रक्चर और संदर्भ के आधार पर, इमेज के साथ इंटरैक्ट करने के अन्य मोड के साथ काम करता है. इनमें ये शामिल हैं:

• टेक्स्ट से इमेज और टेक्स्ट (इंटरलीव्ड): इससे मिलते-जुलते टेक्स्ट वाली इमेज जनरेट होती हैं.
  • प्रॉम्प्ट का उदाहरण: "पेल्हा की रेसिपी जनरेट करें. इसमें इमेज भी शामिल होनी चाहिए."
• इमेज और टेक्स्ट को इमेज और टेक्स्ट में बदलना (इंटरलीव किया गया): इनपुट इमेज और टेक्स्ट का इस्तेमाल करके, मिलती-जुलती नई इमेज और टेक्स्ट बनाएं.
  • प्रॉम्प्ट का उदाहरण: (फ़र्निश किए गए कमरे की इमेज के साथ) "मेरे स्पेस में सोफ़े के कौनसे दूसरे रंग काम करेंगे? क्या आप इमेज को अपडेट कर सकते हैं?"
• कई बार बातचीत करके इमेज में बदलाव करना (चैट): बातचीत के दौरान इमेज जनरेट करना या उनमें बदलाव करना.
  • प्रॉम्प्ट के उदाहरण: [नीली कार की इमेज अपलोड करें.] , "इस कार को कन्वर्टिबल में बदलें.", "अब रंग को पीले में बदलें."

सीमाएं

• सबसे अच्छी परफ़ॉर्मेंस के लिए, इन भाषाओं का इस्तेमाल करें: EN, es-MX, ja-JP, zh-CN, hi-IN.
• इमेज जनरेशन में ऑडियो या वीडियो इनपुट का इस्तेमाल नहीं किया जा सकता.
• ऐसा हो सकता है कि इमेज जनरेट करने की सुविधा हमेशा ट्रिगर न हो:
  • मॉडल सिर्फ़ टेक्स्ट आउटपुट कर सकता है. इमेज के आउटपुट के लिए साफ़ तौर पर पूछें. उदाहरण के लिए, "इमेज जनरेट करें", "काम करते समय इमेज दें", "इमेज अपडेट करें".
  • ऐसा हो सकता है कि मॉडल, डेटा जनरेट करने के दौरान ही रुक जाए. फिर से कोशिश करें या कोई दूसरा प्रॉम्प्ट आज़माएं.
• किसी इमेज के लिए टेक्स्ट जनरेट करते समय, Gemini सबसे बेहतर तरीके से काम करता है. इसके लिए, पहले टेक्स्ट जनरेट करें और फिर उस टेक्स्ट के साथ इमेज जनरेट करने के लिए कहें.
• कुछ इलाकों/देशों में इमेज जनरेट करने की सुविधा उपलब्ध नहीं है. ज़्यादा जानकारी के लिए, मॉडल देखें.

Imagen 3 का इस्तेमाल करके इमेज जनरेट करना

इस उदाहरण में, Imagen 3 की मदद से इमेज जनरेट करने का तरीका बताया गया है:

from google import genai
from google.genai import types
from PIL import Image
from io import BytesIO

client = genai.Client(api_key='GEMINI_API_KEY')

response = client.models.generate_images(
    model='imagen-3.0-generate-002',
    prompt='Robot holding a red skateboard',
    config=types.GenerateImagesConfig(
        number_of_images= 4,
    )
)
for generated_image in response.generated_images:
  image = Image.open(BytesIO(generated_image.image.image_bytes))
  image.show()

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

async function main() {

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

  const response = await ai.models.generateImages({
    model: 'imagen-3.0-generate-002',
    prompt: 'Robot holding a red skateboard',
    config: {
      numberOfImages: 4,
    },
  });

  let idx = 1;
  for (const generatedImage of response.generatedImages) {
    let imgBytes = generatedImage.image.imageBytes;
    const buffer = Buffer.from(imgBytes, "base64");
    fs.writeFileSync(`imagen-${idx}.png`, buffer);
    idx++;
  }
}

main();

package main

import (
  "context"
  "fmt"
  "os"
  "google.golang.org/genai"
)

func main() {

  ctx := context.Background()
  client, _ := genai.NewClient(ctx, &genai.ClientConfig{
      APIKey:  os.Getenv("GEMINI_API_KEY"),
      Backend: genai.BackendGeminiAPI,
  })

  config := &genai.GenerateImagesConfig{
      NumberOfImages: 4,
  }

  response, _ := client.Models.GenerateImages(
      ctx,
      "imagen-3.0-generate-002",
      "Robot holding a red skateboard",
      config,
  )

  for n, image := range response.GeneratedImages {
      fname := fmt.Sprintf("imagen-%d.png", n)
          _ = os.WriteFile(fname, image.Image.ImageBytes, 0644)
  }
}

curl -X POST \
    "https://generativelanguage.googleapis.com/v1beta/models/imagen-3.0-generate-002:predict?key=GEMINI_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
        "instances": [
          {
            "prompt": "Robot holding a red skateboard"
          }
        ],
        "parameters": {
          "sampleCount": 4
        }
      }'

Imagen मॉडल के पैरामीटर

फ़िलहाल, Imagen सिर्फ़ अंग्रेज़ी में प्रॉम्प्ट और इन पैरामीटर के साथ काम करता है:

• numberOfImages: जनरेट की जाने वाली इमेज की संख्या, 1 से 4 के बीच होनी चाहिए. डिफ़ॉल्ट रूप से, यह संख्या 4 होती है.
• aspectRatio: जनरेट की गई इमेज का आसपेक्ट रेशियो बदलता है. "1:1", "3:4", "4:3", "9:16", और "16:9" वैल्यू इस्तेमाल की जा सकती हैं. डिफ़ॉल्ट रूप से, यह "1:1" पर सेट होता है.
• personGeneration: मॉडल को लोगों की इमेज जनरेट करने की अनुमति दें. ये वैल्यू इस्तेमाल की जा सकती हैं:
  • "DONT_ALLOW": लोगों की इमेज जनरेट करने की सुविधा को ब्लॉक करें.
  • "ALLOW_ADULT": वयस्कों की इमेज जनरेट करें, लेकिन बच्चों की नहीं. यह डिफ़ॉल्ट विकल्प है.

सही मॉडल चुनना

Gemini को तब चुनें, जब:

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

Imagen 3 को तब चुनें, जब:

• इमेज की क्वालिटी, फ़ोटो जैसी क्वालिटी, कला से जुड़ी जानकारी या खास स्टाइल (जैसे, इंप्रेशनिज्म, ऐनिमेशन) को प्राथमिकता दी जाती है.
• प्रॉडक्ट के बैकग्राउंड में बदलाव करने या इमेज को बड़ा करने जैसी खास तरह की एडिटिंग करने के लिए.
• ब्रैंडिंग, स्टाइल या लोगो और प्रॉडक्ट डिज़ाइन जनरेट करना.

Imagen के प्रॉम्प्ट के लिए गाइड

Imagen की गाइड के इस सेक्शन में बताया गया है कि टेक्स्ट से इमेज में बदलने वाले प्रॉम्प्ट में बदलाव करके, अलग-अलग नतीजे कैसे मिल सकते हैं. साथ ही, इसमें ऐसी इमेज के उदाहरण भी दिए गए हैं जिन्हें बनाया जा सकता है.

प्रॉम्प्ट लिखने के बारे में बुनियादी जानकारी

अच्छा प्रॉम्प्ट, जानकारी देने वाला और साफ़ होता है. साथ ही, इसमें काम के कीवर्ड और बदलाव करने वाले शब्दों का इस्तेमाल किया जाता है. अपने विषय, कॉन्टेक्स्ट, और स्टाइल के बारे में सोचकर शुरुआत करें.

1. सब्जेक्ट: किसी भी प्रॉम्प्ट के लिए सबसे पहले सब्जेक्ट के बारे में सोचें: वह ऑब्जेक्ट, व्यक्ति, जानवर या सीन जिसकी आपको इमेज चाहिए.

2. कॉन्टेक्स्ट और बैकग्राउंड: जिस बैकग्राउंड या कॉन्टेक्स्ट में ऑब्जेक्ट को रखा जाएगा वह भी उतना ही अहम है. अपने विषय को अलग-अलग तरह के बैकग्राउंड में रखकर देखें. उदाहरण के लिए, सफ़ेद बैकग्राउंड वाला स्टूडियो, बाहरी या अंदरूनी माहौल.

3. स्टाइल: आखिर में, अपनी पसंद के मुताबिक इमेज का स्टाइल जोड़ें. स्टाइल सामान्य (पेंटिंग, फ़ोटो, स्केच) या खास (पेस्टल पेंटिंग, चारकोल ड्रॉइंग, आइसोमेट्रिक 3D) हो सकते हैं. स्टाइल को आपस में भी जोड़ा जा सकता है.

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

Imagen 3 आपके आइडिया को ज़्यादा जानकारी वाली इमेज में बदल सकता है. भले ही, आपके प्रॉम्प्ट छोटे हों या लंबे और ज़्यादा जानकारी वाले. बार-बार पूछे जाने वाले सवालों के ज़रिए, अपने विज़न को बेहतर बनाएं. साथ ही, जब तक आपको बेहतर नतीजा न मिल जाए, तब तक जानकारी जोड़ते रहें.

छोटे प्रॉम्प्ट की मदद से, तुरंत इमेज जनरेट की जा सकती है.

लंबे प्रॉम्प्ट की मदद से, खास जानकारी जोड़ी जा सकती है और अपनी इमेज बनाई जा सकती है.

Imagen के लिए प्रॉम्प्ट लिखने के बारे में अन्य सलाह:

• ज़्यादा जानकारी देने वाली भाषा का इस्तेमाल करें: Imagen 3 के लिए, ज़्यादा जानकारी देने वाले विशेषण और क्रियाविशेषण का इस्तेमाल करें.
• संदर्भ दें: अगर ज़रूरी हो, तो एआई को समझने में मदद करने के लिए, बैकग्राउंड की जानकारी शामिल करें.
• किसी कलाकार या स्टाइल का रेफ़रंस दें: अगर आपको किसी खास स्टाइल का इस्तेमाल करना है, तो किसी कलाकार या आर्ट मूवमेंट का रेफ़रंस देना मददगार हो सकता है.
• प्रॉम्प्ट इंजीनियरिंग टूल का इस्तेमाल करना: प्रॉम्प्ट इंजीनियरिंग टूल या संसाधनों का इस्तेमाल करके, अपने प्रॉम्प्ट को बेहतर बनाएं और बेहतर नतीजे पाएं.
• अपनी निजी और ग्रुप इमेज में चेहरे की जानकारी को बेहतर बनाना: फ़ोटो के फ़ोकस के तौर पर चेहरे की जानकारी दें. उदाहरण के लिए, प्रॉम्प्ट में "पोर्ट्रेट" शब्द का इस्तेमाल करें.

इमेज में टेक्स्ट जनरेट करना

Imagen, इमेज में टेक्स्ट जोड़ सकता है. इससे, क्रिएटिव इमेज जनरेट करने के ज़्यादा अवसर मिलते हैं. इस सुविधा का ज़्यादा से ज़्यादा फ़ायदा पाने के लिए, नीचे दिए गए दिशा-निर्देशों का पालन करें:

• आश्वस्त होकर बार-बार आज़माएं: आपको तब तक इमेज फिर से जनरेट करनी पड़ सकती है, जब तक आपको अपनी पसंद का लुक नहीं मिल जाता. Imagen का टेक्स्ट इंटिग्रेशन अब भी बेहतर हो रहा है. कभी-कभी एक से ज़्यादा बार कोशिश करने पर सबसे अच्छे नतीजे मिलते हैं.
• टेक्स्ट को छोटा रखें: बेहतर टेक्स्ट जनरेट करने के लिए, टेक्स्ट को 25 या इससे कम वर्णों में रखें.

• एक से ज़्यादा वाक्यांश: ज़्यादा जानकारी देने के लिए, दो या तीन अलग-अलग वाक्यांशों के साथ प्रयोग करें. बेहतर कॉम्पोज़िशन के लिए, तीन से ज़्यादा वाक्यांश इस्तेमाल न करें.

  

• गाइड प्लेसमेंट: Imagen, निर्देश के मुताबिक टेक्स्ट को प्लेस करने की कोशिश कर सकता है. हालांकि, कभी-कभी इसमें बदलाव हो सकते हैं. इस सुविधा को लगातार बेहतर बनाया जा रहा है.

• फ़ॉन्ट स्टाइल सेट करना: सामान्य फ़ॉन्ट स्टाइल सेट करें, ताकि Imagen की चुनी गई फ़ॉन्ट स्टाइल पर इसका असर पड़े. फ़ॉन्ट को पूरी तरह से कॉपी करने पर भरोसा न करें. हालांकि, क्रिएटिव तरीके से फ़ॉन्ट को बदलने की उम्मीद रखें.

• फ़ॉन्ट साइज़: फ़ॉन्ट साइज़ जनरेट करने के लिए, फ़ॉन्ट साइज़ या साइज़ का सामान्य संकेत (उदाहरण के लिए, छोटा, मीडियम, बड़ा) बताएं.

प्रॉम्प्ट के लिए पैरामीटर तय करना

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

इस उदाहरण में, पैरामीटर वाला ऐसा प्रॉम्प्ट बनाया जा सकता है जो यहां दिए गए प्रॉम्प्ट से मिलता-जुलता हो:

A {logo_style} logo for a {company_area} company on a solid color background. Include the text {company_name}.

आपके कस्टम यूज़र इंटरफ़ेस में, ग्राहक किसी मेन्यू का इस्तेमाल करके पैरामीटर डाल सकता है. इसके बाद, ग्राहक की चुनी गई वैल्यू, Imagen को मिलने वाले प्रॉम्प्ट में अपने-आप भर जाती है.

उदाहरण के लिए:

1. प्रॉम्प्ट: A minimalist logo for a health care company on a solid color background. Include the text Journey.

   

2. प्रॉम्प्ट: A modern logo for a software company on a solid color background. Include the text Silo.

   

3. प्रॉम्प्ट: A traditional logo for a baking company on a solid color background. Include the text Seed.

   

प्रॉम्प्ट लिखने की बेहतर तकनीकें

फ़ोटोग्राफ़ी के ब्यौरे, आकार और सामग्री, ऐतिहासिक कला, और इमेज क्वालिटी में बदलाव करने वाले एट्रिब्यूट जैसे एट्रिब्यूट के आधार पर, ज़्यादा सटीक प्रॉम्प्ट बनाने के लिए, यहां दिए गए उदाहरणों का इस्तेमाल करें.

फ़ोटोग्राफ़ी

• प्रॉम्प्ट में ये शामिल हैं: "...की फ़ोटो"

इस स्टाइल का इस्तेमाल करने के लिए, ऐसे कीवर्ड का इस्तेमाल करें जिनसे Imagen को साफ़ तौर पर पता चल सके कि आपको फ़ोटो चाहिए. अपने प्रॉम्प्ट को "इसकी फ़ोटो लें" से शुरू करें. . .". उदाहरण के लिए:

^{इमेज का सोर्स: हर इमेज को, Imagen 3 मॉडल के साथ उसके टेक्स्ट प्रॉम्प्ट का इस्तेमाल करके जनरेट किया गया था.}

फ़ोटोग्राफ़ी मॉडिफ़ायर

यहां दिए गए उदाहरणों में, फ़ोटोग्राफ़ी से जुड़े कई मॉडिफ़ायर और पैरामीटर देखे जा सकते हैं. ज़्यादा सटीक कंट्रोल के लिए, कई मॉडिफ़ायर को जोड़ा जा सकता है.

1. कैमरे की निकटता - दूर से लिया गया क्लोज़-अप

2. कैमरे की स्थिति - नीचे से एरियल

3. लाइटिंग - नैचुरल, ड्रामाटिक, वॉर्म, कोल्ड

4. कैमरे की सेटिंग - मोशन ब्लर, सॉफ़्ट फ़ोकस, बोकेह, पोर्ट्रेट

   वाली फ़ोटो

5. लेंस टाइप - 35 मि॰मी॰, 50 मि॰मी॰, फ़िशआई, वाइड ऐंगल, मैक्रो

6. फ़िल्म के टाइप - ब्लैक ऐंड व्हाइट, पोलराइड

^{इमेज का सोर्स: हर इमेज को, Imagen 3 मॉडल के साथ उसके टेक्स्ट प्रॉम्प्ट का इस्तेमाल करके जनरेट किया गया था.}

इलस्ट्रेशन और आर्ट

• प्रॉम्प्ट में ये शामिल हैं: "... का painting", "... का sketch"

आर्ट स्टाइल अलग-अलग होते हैं. जैसे, पेंसिल स्केच जैसे मोनोक्रोम स्टाइल से लेकर, हाइपर-रियलिस्टिक डिजिटल आर्ट तक. उदाहरण के लिए, नीचे दी गई इमेज में एक ही प्रॉम्प्ट का इस्तेमाल अलग-अलग स्टाइल में किया गया है:

"बैकग्राउंड में गगनचुंबी इमारतों के साथ, ऐंगल वाली स्पोर्टी इलेक्ट्रिक सेडान की [art style or creation technique]"

^{इमेज का सोर्स: हर इमेज को, Imagen 2 मॉडल के साथ उसके टेक्स्ट प्रॉम्प्ट का इस्तेमाल करके जनरेट किया गया था.}

आकार और सामग्री

• प्रॉम्प्ट में ये शामिल हैं: "...made of...", "...इस तरह के..."

इस टेक्नोलॉजी की एक खास बात यह है कि इससे ऐसी इमेज बनाई जा सकती हैं जो आम तौर पर मुश्किल या असंभव होती हैं. उदाहरण के लिए, अपनी कंपनी के लोगो को अलग-अलग मटीरियल और टेक्सचर में फिर से बनाया जा सकता है.

^{इमेज का सोर्स: हर इमेज को, Imagen 3 मॉडल के साथ उसके टेक्स्ट प्रॉम्प्ट का इस्तेमाल करके जनरेट किया गया था.}

ऐतिहासिक कला के रेफ़रंस

• प्रॉम्प्ट में ये शामिल हैं: "...इस स्टाइल में..."

कुछ स्टाइल, सालों से मशहूर हैं. यहां ऐतिहासिक पेंटिंग या कला शैलियों के कुछ आइडिया दिए गए हैं, जिन्हें आज़माया जा सकता है.

"[art period or movement] : विंड फ़ार्म की स्टाइल में इमेज जनरेट करें"

^{इमेज का सोर्स: हर इमेज को, Imagen 3 मॉडल के साथ उसके टेक्स्ट प्रॉम्प्ट का इस्तेमाल करके जनरेट किया गया था.}

इमेज क्वालिटी मॉडिफ़ायर

कुछ कीवर्ड की मदद से, मॉडल को यह पता चल सकता है कि आपको अच्छी क्वालिटी वाली एसेट चाहिए. क्वालिटी मॉडिफ़ायर के उदाहरणों में ये शामिल हैं:

• सामान्य मॉडिफ़ायर - बेहतर क्वालिटी, खूबसूरत, स्टाइलिश
• Photos - 4K, एचडीआर, स्टूडियो फ़ोटो
• आर्ट, इलस्ट्रेशन - पेशेवर की ओर से, ज़्यादा जानकारी

यहां क्वालिटी मॉडिफ़ायर के बिना प्रॉम्प्ट और क्वालिटी मॉडिफ़ायर के साथ प्रॉम्प्ट के कुछ उदाहरण दिए गए हैं.

^{इमेज का सोर्स: हर इमेज को, Imagen 3 मॉडल के साथ उसके टेक्स्ट प्रॉम्प्ट का इस्तेमाल करके जनरेट किया गया था.}

आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात)

इमेज जनरेट करने वाले मॉडल Imagen 3 की मदद से, इमेज के पांच अलग-अलग आसपेक्ट रेशियो सेट किए जा सकते हैं.

1. स्क्वेयर (1:1, डिफ़ॉल्ट) - स्टैंडर्ड स्क्वेयर फ़ोटो. आम तौर पर, इस आसपेक्ट रेशियो का इस्तेमाल सोशल मीडिया पोस्ट के लिए किया जाता है.

2. फ़ुलस्क्रीन (4:3) - आम तौर पर, मीडिया या फ़िल्म में इस आसपेक्ट रेशियो का इस्तेमाल किया जाता है. यह डाइमेंशन, ज़्यादातर पुराने (नॉन-वाइडस्क्रीन) टीवी और मीडियम फ़ॉर्मैट कैमरों का भी होता है. यह 1:1 के मुकाबले, हॉरिज़ॉन्टल तौर पर ज़्यादा सीन कैप्चर करता है. इसलिए, फ़ोटोग्राफ़ी के लिए यह आसपेक्ट रेशियो सबसे ज़्यादा पसंद किया जाता है.

3. पोर्ट्रेट फ़ुल स्क्रीन (3:4) - यह फ़ुल स्क्रीन आसपेक्ट रेशियो है, जिसे 90 डिग्री घुमाया गया है. इससे 1:1 आसपेक्ट रेशियो की तुलना में, वर्टिकल तौर पर ज़्यादा सीन कैप्चर किए जा सकते हैं.

4. वाइडस्क्रीन (16:9) - इस आसपेक्ट रेशियो ने 4:3 की जगह ले ली है. अब यह टीवी, मॉनिटर, और मोबाइल फ़ोन की स्क्रीन (लैंडस्केप) के लिए सबसे सामान्य आसपेक्ट रेशियो है. जब आपको बैकग्राउंड को ज़्यादा कैप्चर करना हो, तब इस आसपेक्ट रेशियो का इस्तेमाल करें. उदाहरण के लिए, शानदार लैंडस्केप.

   

5. पोर्ट्रेट (9:16) - यह वाइडस्क्रीन रेशियो है, लेकिन इसे घुमाया गया है. यह एक अपेक्षाकृत नया आसपेक्ट रेशियो है, जिसे शॉर्ट वीडियो ऐप्लिकेशन (उदाहरण के लिए, YouTube Shorts) ने लोकप्रिय बनाया है. इसका इस्तेमाल, ऊंचे और वर्टिकल ऑरिएंटेशन वाले ऑब्जेक्ट के लिए करें. जैसे, इमारतें, पेड़, झरने या ऐसे ही अन्य ऑब्जेक्ट.

   

असल में खींची गई फ़ोटो जैसी दिखने वाली इमेज

इमेज जनरेट करने वाले मॉडल के अलग-अलग वर्शन, आर्टिस्टिक और फ़ोटोरिएलिस्टिक आउटपुट का एक मिक्स दे सकते हैं. आपको जिस विषय के आधार पर ज़्यादा फ़ोटोरिएलिस्टिक आउटपुट जनरेट करना है उसके आधार पर, प्रॉम्प्ट में नीचे दिए गए शब्दों का इस्तेमाल करें.

पोर्ट्रेट

टेबल में मौजूद कई कीवर्ड का इस्तेमाल करके, Imagen ये पोर्ट्रेट जनरेट कर सकता है:

प्रॉम्प्ट: एक महिला, 35 मि॰मी॰ पोर्ट्रेट, नीले और स्लेटी रंग के ड्यूटोन
मॉडल: imagen-3.0-generate-002

प्रॉम्प्ट: एक महिला, 35 मिमी पोर्ट्रेट, फ़िल्म नोयर
मॉडल: imagen-3.0-generate-002

ऑब्जेक्ट

टेबल में दिए गए कई कीवर्ड का इस्तेमाल करके, Imagen इन ऑब्जेक्ट की इमेज जनरेट कर सकता है:

प्रॉम्प्ट: प्रेयर प्लांट की पत्ती, मैक्रो लेंस, 60 मि॰मी॰
मॉडल: imagen-3.0-generate-002

प्रॉम्प्ट: पास्ता की प्लेट, 100 मि॰मी॰ मैक्रो लेंस
मॉडल: imagen-3.0-generate-002

मोशन

टेबल में दिए गए कई कीवर्ड का इस्तेमाल करके, Imagen ये मोशन इमेज जनरेट कर सकता है:

प्रॉम्प्ट: जीतने वाला टचडाउन, तेज़ शटर स्पीड, मूवमेंट ट्रैकिंग
मॉडल: imagen-3.0-generate-002

प्रॉम्प्ट: जंगल में दौड़ता हुआ हिरण, तेज़ शटर स्पीड, मूवमेंट ट्रैकिंग
मॉडल: imagen-3.0-generate-002

वाइड-एंगल

टेबल में दिए गए कई कीवर्ड का इस्तेमाल करके, Imagen इन वाइड-ऐंगल इमेज को जनरेट कर सकता है:

प्रॉम्प्ट: बड़ी पर्वत श्रृंखला, लैंडस्केप वाइड ऐंगल 10 मि॰मी॰
मॉडल: imagen-3.0-generate-002

प्रॉम्प्ट: चांद की फ़ोटो, ऐस्ट्रो फ़ोटोग्राफ़ी, वाइड ऐंगल 10mm
मॉडल: imagen-3.0-generate-002

आगे क्या करना है

• Gemini API की मदद से वीडियो जनरेट करने का तरीका जानने के लिए, Veo की गाइड देखें.
• Gemini 2.0 मॉडल के बारे में ज़्यादा जानने के लिए, Gemini मॉडल और एक्सपेरिमेंट के तौर पर उपलब्ध मॉडल देखें.