मुख्य सामग्री पर जाएँ

Gemini 2.0 Flash: चरण-दर-चरण ट्यूटोरियल (डेमो प्रोजेक्ट सहित)

जानें कि Google के Gemini 2.0 Flash मॉडल का उपयोग करके Python के साथ एक विज़ुअल असिस्टेंट कैसे विकसित करें, जो ऑन-स्क्रीन सामग्री पढ़ सके और उससे जुड़े प्रश्नों के उत्तर दे सके।
· 12 मि॰ पढ़ें

AI के साथ खोजें

Google ने हाल ही में Gemini 2.0 की घोषणा की है, जिसका केंद्र Gemini 2.0 Flash मॉडल है—एक तेज़, अधिक शक्तिशाली संस्करण जिसे छवि और ध्वनि प्रसंस्करण में सुधार के लिए डिज़ाइन किया गया है।

इस ट्यूटोरियल में, मैं आपको Gemini 2.0 Flash का उपयोग करके एक विज़ुअल असिस्टेंट बनाने के चरणों से परिचित कराऊंगा, जो ऑन-स्क्रीन सामग्री पढ़ सकता है और उसके बारे में प्रश्नों के उत्तर दे सकता है।

यहाँ वह डेमो है जो हम बनाने जा रहे हैं:

स्टेप 1: Google AI Studio के लिए API कुंजी सेट करें

API कुंजी सेट करने के लिए, Google AI Studio पर जाएँ और “Create API Key” बटन पर क्लिक करें। कुंजी कॉपी करना न भूलें और उसे .env नामक फ़ाइल में निम्न प्रारूप में पेस्ट करें:

GOOGLE_API_KEY=replace_this_with_api_key

यदि आपने पहले से ही उसी Google खाते का उपयोग करके Google Cloud Platform के साथ काम किया है, तो Google AI Studio आपसे API सक्रिय करने के लिए आपके किसी प्रोजेक्ट को चुनने के लिए कहेगा।

इस ट्यूटोरियल के साथ चलते समय, Python कोड .env फ़ाइल वाले उसी फ़ोल्डर में होना चाहिए।

स्टेप 2: Python डिपेंडेंसी इंस्टॉल करें

इस प्रोजेक्ट के लिए, हम निम्न पैकेजों का उपयोग करेंगे:

  • google-genai: हमारी एप्लिकेशन में Google के जनरेटिव AI मॉडलों को एकीकृत करने के लिए Python लाइब्रेरी।
  • pyautogui: माउस और कीबोर्ड को प्रोग्रामेटिक रूप से नियंत्रित करने के लिए क्रॉस-प्लेटफ़ॉर्म लाइब्रेरी। हमारे मामले में, हम इसे स्क्रीन सामग्री AI मॉडल को प्रदान करने के लिए उपयोग करते हैं।
  • python-dotenv: एनवायरनमेंट वेरिएबल्स को .env फ़ाइलों से लोड कर हमारी Python एप्लिकेशन में मैनेज करने के लिए लाइब्रेरी।
  • sounddevice: सरल API के साथ ऑडियो इनपुट और आउटपुट के लिए ध्वनि रिकॉर्ड और प्ले करने हेतु Python लाइब्रेरी।
  • numpy: Python में संख्यात्मक कंप्यूटिंग के लिए बुनियादी लाइब्रेरी, जो एरे, मैट्रिस और अनेक गणितीय कार्य प्रदान करती है।

डिपेंडेंसी इंस्टॉल करने के लिए, हम pip का उपयोग कर सकते हैं:

pip install google-genai pyautogui python-dotenv sounddevice numpy

requirements.txt फ़ाइल हम GitHub रिपॉजिटरी से भी डाउनलोड कर सकते हैं, जो मैंने इस प्रोजेक्ट के लिए सेटअप की है, और इसका उपयोग Conda एनवायरनमेंट बनाने के लिए कर सकते हैं:

conda create --name gemini python=3.11
conda activate gemini
pip install -r requirements.txt

स्टेप 3: Google GenAI API के साथ एक टेक्स्ट चैटबोट बनाएं

आइए google.genai लाइब्रेरी का उपयोग करके Google के Gemini 2 Flash मॉडल के साथ एक सरल कमांड-लाइन AI चैट इंटरफ़ेस बनाकर शुरू करें। मैं सुझाव देता हूँ कि किसी भी अड़चन की स्थिति में Gemini 2.0 के आधिकारिक दस्तावेज़ देखें।

इस उदाहरण का पूरा कोड मेरी GitHub रिपॉजिटरी के text.py फ़ाइल में उपलब्ध है।

Google GenAI क्लाइंट बनाना और उससे जुड़ना

पहला चरण API कुंजी को सुरक्षित रूप से लोड करना और Google GenAI क्लाइंट को इनिशियलाइज़ करना है। स्क्रिप्ट dotenv का उपयोग करके .env फ़ाइल से एनवायरनमेंट वेरिएबल्स लोड करती है।

आवश्यक क्रेडेंशियल्स के साथ क्लाइंट सेट करने का तरीका इस प्रकार है:

from google import genai
from dotenv import load_dotenv
import os

# Load environment variables from a .env file
load_dotenv()
client = genai.Client(
    api_key=os.getenv("GOOGLE_API_KEY"),
    http_options={"api_version": "v1alpha"},
)

print("Connected to the AI model!")

असिंक्रोनस API कॉल करना

Google GenAI जैसी APIs के साथ काम करते समय हमें अक्सर असिंक्रोनस ऑपरेशंस प्रबंधित करने की आवश्यकता होती है। असिंक्रोनस प्रोग्रामिंग नेटवर्क अनुरोधों की प्रतीक्षा करते समय अन्य ऑपरेशनों को जारी रहने देती है, जिससे आपकी एप्लिकेशन अधिक प्रतिक्रियाशील बनती है। यह विशेष रूप से उच्च-विलंबता वाले ऑपरेशनों, जैसे नेटवर्क अनुरोधों, के लिए महत्वपूर्ण है।

Python में, असिंक्रोनस प्रोग्रामिंग asyncio लाइब्रेरी और async/await सिंटैक्स के जरिए संभव होती है।

यहाँ देखें कि हम Google GenAI को असिंक्रोनस अनुरोध कैसे भेज सकते हैं:

from google import genai
from dotenv import load_dotenv
import os
import asyncio

# Load environment variables from a .env file
load_dotenv()
async def main():
    client = genai.Client(
        api_key=os.getenv("GOOGLE_API_KEY"),
        http_options={"api_version": "v1alpha"},
    )    
    # Define the AI model and configuration
    model_id = "gemini-2.0-flash-exp"
    config = {"response_modalities": ["TEXT"]}
    async with client.aio.live.connect(model=model_id, config=config) as session:
        await session.send("Hello", end_of_turn=True)
        # Process responses from the AI
        async for response in session.receive():
            if not response.server_content.turn_complete:
                for part in response.server_content.model_turn.parts:
                    print(part.text, end="", flush=True)

# Run the main function
asyncio.run(main())

यह संस्करण AI मॉडल से कनेक्ट होता है और एकल “Hello” संदेश भेजता है। प्रतिक्रिया को कंसोल में शब्द दर शब्द प्रिंट किया जाता है।

इसे इंटरैक्टिव बनाना

एप्लिकेशन को इंटरैक्टिव बनाने के लिए, जिससे उपयोगकर्ता AI मॉडल के साथ आगे-पीछे बातचीत कर सके, हम एक लूप जोड़ते हैं जो उपयोगकर्ता को कई संदेश भेजने देता है। जब उपयोगकर्ता "exit" टाइप करता है तो लूप रुक जाता है।

from google import genai
from dotenv import load_dotenv
import os
import asyncio

# Load environment variables from a .env file
load_dotenv()
async def main():
    client = genai.Client(
        api_key=os.getenv("GOOGLE_API_KEY"),
        http_options={"api_version": "v1alpha"},
    )
    # Define the AI model and configuration
    model_id = "gemini-2.0-flash-exp"
    config = {"response_modalities": ["TEXT"]}
    async with client.aio.live.connect(model=model_id, config=config) as session:
        while True:
            message = input(">> ")
            print()
            # Exit the loop if the user types "exit"
            if message == "exit":
                print("Exiting...")
                break
            # Send the user's message to the AI model, marking the end of the turn
            await session.send(message, end_of_turn=True)
            # Receive responses asynchronously and process each response
            async for response in session.receive():
                if not response.server_content.turn_complete:
                    for part in response.server_content.model_turn.parts:
                        print(part.text, end="", flush=True)
            print()

# Run the main function
asyncio.run(main())

बस इतना ही! ऊपर दी गई स्क्रिप्ट के साथ, हमने Google GenAI API का उपयोग करके एक कमांड लाइन AI चैटबोट बना लिया है। यह कुछ ऐसा दिखाई देता है:

स्टेप 4: ऑडियो मोड जोड़ें

ऑडियो मोड मॉडल को टेक्स्ट की बजाय आवाज़ में प्रतिक्रिया देने में सक्षम बनाता है। ऑडियो प्रतिक्रियाओं को संभालने के लिए पिछले उदाहरण को समायोजित करने हेतु, हम:

  1. sounddevice को ऑडियो प्लेबैक के लिए और numpy को ऑडियो डेटा प्रोसेस करने के लिए इम्पोर्ट करते हैं।
  2. रिस्पॉन्स मोडैलिटी को TEXT से बदलकर AUDIO करते हैं:
	config = {"response_modalities": ["AUDIO"]}
  1. क्लाइंट से कनेक्ट करने से पहले एक ऑडियो स्ट्रीम इनिशियलाइज़ करते हैं:
	with sd.OutputStream(
	samplerate=24000, 
	channels=1, 
	dtype="int16",
) as audio_stream:
  1. रिस्पॉन्स पार्ट से ऑडियो डेटा एक्सेस करते हैं और उसे प्लेबैक के लिए ऑडियो स्ट्रीम में जोड़ते हैं:
for part in response.server_content.model_turn.parts:
    # Get the audio data from the response part and add it to the steam
    inline_data = part.inline_data
    audio_data = np.frombuffer(inline_data.data, dtype="int16")
    audio_stream.write(audio_data)

audio.py फ़ाइल में रिपॉजिटरी में इन बदलावों के साथ पूरा स्क्रिप्ट उपलब्ध है। स्क्रिप्ट में बदली गई पंक्तियों पर टिप्पणियाँ दी गई हैं।

स्टेप 5: टूल्स के साथ कोड निष्पादन जोड़ें

आधुनिक AI मॉडलों की उत्कृष्ट विशेषताओं में से एक यह है कि वे हमारे कोड में कस्टम फ़ंक्शन्स को स्वतः कॉल कर सकते हैं, और Gemini 2 भी इसका अपवाद नहीं है।

इसका तरीका यह है कि हम फ़ंक्शनों को टूल्स के रूप में रजिस्टर करके मॉडल को बताते हैं कि कौन-कौन से फ़ंक्शन कॉल किए जा सकते हैं। फिर, प्रॉम्प्ट, फ़ंक्शन नामों और विवरणों का विश्लेषण कर, मॉडल निर्णय करेगा कि उसे फ़ंक्शन कॉल करना है या नहीं। जब वह ऐसा करने का फैसला करता है, तो वह उस फ़ंक्शन का नाम और आर्ग्युमेंट्स के साथ एक विशेष प्रतिक्रिया भेजेगा जिसे वह कॉल करना चाहता है।

किसी टूल को परिभाषित करने के लिए, हमें यह करना होगा:

  1. स्कीमा में परिभाषित समान नाम और आर्ग्युमेंट्स के साथ एक Python फ़ंक्शन लिखें।
  2. फ़ंक्शन स्कीमा बनाएं, जो फ़ंक्शन के बारे में मेटाडेटा वाला एक डिक्शनरी है, जैसे नाम, टेक्स्ट विवरण, और आर्ग्युमेंट्स की विशिष्टता।
  3. फ़ंक्शन स्कीमा को AI मॉडल को उपलब्ध कराएँ।
  4. जब मॉडल अनुरोध करे तो फ़ंक्शन निष्पादित करें।

इसे स्पष्ट करने के लिए, आइए एक ऐसा टूल परिभाषित करें जो किसी फ़ाइल को पढ़ सके, जिससे मॉडल हमारी लोकल मशीन की फ़ाइलों के बारे में प्रश्नों के उत्तर दे सके।

फ़ंक्शन परिभाषित करना

यह भाग सामान्य Python कोड है। यदि फ़ंक्शन सफल रहा तो मॉडल उत्तर को ”result” कुंजी वाले डिक्शनरी के रूप में अपेक्षित करता है, अन्यथा ”error”।

def load_file_content(filename):
    try:
      with open(filename, "rt") as f:
          return {
              "result": f.read()
          }
    except Exception as e:
      return {
          "error": "Could not load file content",
      }

स्कीमा निर्दिष्ट करना

इस फ़ंक्शन के लिए हम स्कीमा इस प्रकार परिभाषित कर सकते हैं:

load_file_content_schema = {
    "name": "load_file_content",
    "description": "Load the content of a file",
    "parameters": {
        "type": "object",
        "properties": {
            "filename": {
                "type": "string",
                "description": "The name of the file",
            },
        },
        "required": ["filename"],
    },
    "output": {
        "type": "string",
        "description": "The text content of the file",
    },
}

हम चार फ़ील्ड प्रदान करते हैं:

  • ”name”: फ़ंक्शन का नाम।
  • ”description”: टेक्स्ट विवरण। मॉडल इसका उपयोग यह तय करने के लिए करता है कि फ़ंक्शन कॉल करना है या नहीं।
  • ”properties”: फ़ंक्शन आर्ग्युमेंट्स का विवरण।
  • ”output”: फ़ंक्शन आउटपुट का विवरण।

फ़ंक्शन स्कीमा पर अधिक जानकारी के लिए आधिकारिक दस्तावेज़ देखें।

मॉडल को फ़ंक्शन उपलब्ध कराना

मॉडल को हमारे फ़ंक्शन के बारे में बताने के लिए, हम मॉडल कॉन्फ़िगरेशन में फ़ंक्शन स्कीमा प्रदान करते हैं:

config = {
       "tools": [{"function_declarations": [load_file_content_schema]}], 
       "response_modalities": ["TEXT"]
}

मॉडल से आने वाले फ़ंक्शन-कॉल अनुरोध को प्रोसेस करना

जब मॉडल फ़ंक्शन कॉल करने का निर्णय लेता है, तो वह response में एक tool_call जोड़ देगा। इसमें फ़ंक्शन का नाम और आर्ग्युमेंट्स होंगे। इसमें कई कॉल अनुरोध हो सकते हैं, इसलिए हमें उन सभी पर इटरेट करना, संबंधित फ़ंक्शनों को कॉल करना और परिणाम मॉडल को वापस भेजना होगा:

# A dictionary mapping the function names to the actual functions
FUNCTIONS = {"load_file_content": load_file_content}
if response.tool_call is not None:
    for fc in tool_call.function_calls:
        f = FUNCTIONS.get(fc.name)
        tool_response = types.LiveClientToolResponse(
            function_responses=[
                types.FunctionResponse(
                    name=fc.name,
                    id=fc.id,
                    response=f(**fc.args),
                )
            ]
        )
    await session.send(tool_response)

tool.py फ़ाइल में इस उदाहरण का पूरा इम्प्लीमेंटेशन रिपॉजिटरी में उपलब्ध है, जिसमें इन बदलावों के साथ पूरा स्क्रिप्ट है। फ़ंक्शन और स्कीमा की परिभाषाएँ tool_spec.py फ़ाइल में हैं।

वेब एक्सेस

टूल्स का उपयोग करके, हम Google सर्च टूल जोड़कर मॉडल को वेब तक पहुँचने की क्षमता भी दे सकते हैं:

search_tool = {"google_search": {}}
config = {
    "tools": [search_tool],
    "response_modalities": ["TEXT"],
}

यह टूल बिल्ट-इन है, और इसी कारण हमें कोई फ़ंक्शन प्रदान करने की आवश्यकता नहीं है।

कोड निष्पादन

एक और बिल्ट-इन फ़ंक्शन कोड निष्पादन है। कोड निष्पादन मॉडल को जटिल प्रश्नों के उत्तर देने के लिए Python कोड लिखने और चलाने की अनुमति देता है, जो आमतौर पर गणित से जुड़े होते हैं। उदाहरण के लिए, इस टूल के साथ यदि हम उससे पहले 10 अभाज्य संख्याओं का योग निकालने को कहें, तो वह पहले इसे गणना करने के लिए Python कोड लिखेगा, उसे चलाएगा और फिर उत्तर देगा।

टूल सक्रिय करने के लिए, हम यह करते हैं:

code_execution_tool = {"code_execution": {}}
config = {
    "tools": [code_execution_tool],
    "response_modalities": ["TEXT"],
}

यहाँ कोड निष्पादन के साथ मॉडल के व्यवहार का एक उदाहरण है:

​​> add the first 10 prime numbers
Okay, I understand. You want me to add the first 10 prime numbers.
Here's my plan:
1. **Identify the first 10 prime numbers:** I will use a python code to find prime numbers.
2. **Sum the prime numbers:** I will also sum them using python.
3. **Report the result**
The first 10 prime numbers are 2, 3, 5, 7, 11, 13, 17, 19, 23, and 29.  Their sum is 129.

स्टेप 6: विज़ुअल असिस्टेंट बनाएं

अंतिम खंड में, हम Gemini 2 की विज़ुअल क्षमताओं का पता लगाते हैं। उद्देश्य एक ऐसा AI असिस्टेंट बनाना है जो हमारी स्क्रीन पर मौजूद सामग्री को समझ सके और उसके बारे में प्रश्नों के उत्तर दे सके। यह, उदाहरण के लिए, तब उपयोगी हो सकता है जब हम उससे टर्मिनल में दिख रही किसी त्रुटि को समझाने या स्क्रीन पर वर्तमान में प्रदर्शित किसी चीज़ के बारे में जानकारी देने को कहें।

पिछले उदाहरणों में, हमने AI मॉडल से कनेक्ट होने और प्रतिक्रियाओं को वास्तविक समय में प्रोसेस करते हुए डेटा का आदान-प्रदान करने के लिए असिंक्रोनस प्रोग्रामिंग का उपयोग किया था। दुर्भाग्यवश, SDK का वर्तमान संस्करण अभी तक छवियों के साथ रियल-टाइम कम्युनिकेशन का समर्थन नहीं करता। इसके बजाय, हम अनुरोध-प्रतिक्रिया वर्कफ़्लो के माध्यम से इमेज डेटा प्रदान करते हैं। ध्यान दें कि यह स्वयं Gemini 2.0 की सीमा नहीं है—बस इतना है कि वर्तमान बीटा API अभी इसे सपोर्ट नहीं करता।

Google GenAI को सिंक्रोनस अनुरोध भेजना

आइए सीखते हैं कि Google GenAI API को इमेज डेटा के साथ अनुरोध कैसे भेजें। हम इस तरह सिंक्रोनस अनुरोध भेज सकते हैं:

from google import genai
from dotenv import load_dotenv
import os

load_dotenv()

client = genai.Client(
    api_key=os.getenv("GOOGLE_API_KEY"),
    http_options={"api_version": "v1alpha"},
)

response = client.models.generate_content(
    model="gemini-2.0-flash-exp",
    contents=["Hello"],
)

print(response.text)

इस उदाहरण में मुख्य अंतर यह है कि हम API को अनुरोध भेजने के लिए client.models.generate_content का उपयोग करते हैं। यह एक सिंक्रोनस अनुरोध है, जिसका अर्थ है कि यह वास्तविक समय की बातचीत का अनुभव प्रदान नहीं करता।

इमेज भेजना

हम इमेज को लोड करके और उसे contents सूची में जोड़कर भेज सकते हैं। हम PIL पैकेज का उपयोग करके load_and_resize_image() नामक फ़ंक्शन बनाते हैं जो इमेज को लोड और रिसाइज़ करता है।

from PIL import Image

def load_and_resize_image(image_path):
    with Image.open(image_path) as img:
        aspect_ratio = img.height / img.width
        new_height = int(img.width * aspect_ratio)
        return img.resize((img.width, new_height), Image.Resampling.LANCZOS)    

image = load_and_resize_image("example_image.jpeg")

response = client.models.generate_content(
    model="gemini-2.0-flash-exp",
    contents=["Describe the image", image],
)

print(response.text)

AI विज़ुअल असिस्टेंट बनाना

AI विज़ुअल असिस्टेंट हमारी स्क्रीनशॉट के साथ एक टेक्स्टुअल प्रॉम्प्ट प्रोसेस करता है ताकि स्क्रीन पर क्या है, इस बारे में प्रश्नों के उत्तर देने में मदद मिल सके। मैंने इस पर व्यापक रूप से परीक्षण किया है, और मॉडल कई विंडोज़ खुले होने पर भी स्क्रीन सामग्री को समझ सकता है।

मॉडल को स्क्रीन सामग्री प्रदान करने का सबसे सरल तरीका स्क्रीनशॉट लेना है। इसके लिए, हम pyautogui पैकेज का उपयोग करते हैं—माउस और कीबोर्ड को प्रोग्रामेटिक रूप से नियंत्रित करने के लिए एक क्रॉस-प्लेटफ़ॉर्म लाइब्रेरी। हमारे मामले में, हम इसे केवल स्क्रीनशॉट लेने के लिए उपयोग करेंगे, हालांकि हम इसकी कार्यक्षमता का विस्तार कर AI को हमारे कंप्यूटर पर स्वायत्त रूप से कार्य करने देने के लिए कर सकते हैं।

स्क्रीनशॉट लेने के लिए एक फ़ंक्शन यहाँ है:

def capture_screen():
    timestamp = time.strftime("%Y%m%d-%H%M%S")
    filename = f"screenshot_{timestamp}.jpeg"
    screenshot = pyautogui.screenshot()
    screenshot = screenshot.convert("RGB")
    screenshot.save(filename, format="JPEG")
    return filename

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

  1. उपयोगकर्ता से एक प्रॉम्प्ट इनपुट करने के लिए कहें।
  2. स्क्रीनशॉट लें और उसे प्रॉम्प्ट के साथ AI मॉडल को भेजें।
  3. परिणाम उपयोगकर्ता को दिखाएँ।

इस तरीके के साथ एक बात ध्यान में रखनी होगी। एप्लिकेशन टर्मिनल में चलेगी, जो स्क्रीन पर भी प्रदर्शित होती है। इसलिए, मॉडल को टर्मिनल विंडो को नज़रअंदाज़ करने का निर्देश देना बेहतर है। यह कॉन्फ़िगरेशन में system_instruction जोड़कर किया जा सकता है:

client.models.generate_content(
        model="gemini-2.0-flash-exp",
        contents=[prompt, screen],
        config=types.GenerateContentConfig(
            system_instruction="Ignore the terminal window in the image when analyzing the image",
        ),
)

सभी चीज़ों को साथ मिलाकर, हमारा विज़ुअल AI असिस्टेंट इस प्रकार है। पूरा कोड vision.py फ़ाइल के रूप में रिपॉजिटरी में भी उपलब्ध है।

from google import genai
from google.genai import types
from PIL import Image
import pyautogui
import time
import os
from dotenv import load_dotenv
load_dotenv()

# Initialize the GenAI client
client = genai.Client(
    api_key=os.getenv("GOOGLE_API_KEY"),
    http_options={"api_version": "v1alpha"},
)
def capture_screen():
    timestamp = time.strftime("%Y%m%d-%H%M%S")
    filename = f"screenshot_{timestamp}.jpeg"
    screenshot = pyautogui.screenshot()
    screenshot = screenshot.convert("RGB")
    screenshot.save(filename, format="JPEG")
    return filename

def load_and_resize_image(image_path):
    with Image.open(image_path) as img:
        aspect_ratio = img.height / img.width
        new_height = int(img.width * aspect_ratio)
        return img.resize((img.width, new_height), Image.Resampling.LANCZOS)    

def get_genai_response(prompt):
    print("Analyzing screen...")
    screen = load_and_resize_image(capture_screen())
    response = client.models.generate_content(
        model="gemini-2.0-flash-exp",
        contents=[prompt, screen],
        config=types.GenerateContentConfig(
            system_instruction="Ignore the terminal window in the image when analyzing the image",
        ),
    )
    return response.text

def main():
    while True:
        prompt = input(">> ")
        print()
        if prompt == "exit":
            break
        answer = get_genai_response(prompt)
        print(answer)
        print()

if __name__ == "__main__":
    main()

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

निष्कर्ष

हमने Gemini 2.0 Flash मॉडल का उपयोग विभिन्न एप्लिकेशनों के लिए करना सीखा—जैसे टेक्स्ट और वॉयस के साथ रियल-टाइम बातचीत करने वाले चैटबोट विकसित करना, फ़ंक्शन कॉल्स का उपयोग कर AI मॉडल को कार्य करने में सक्षम बनाना, और हमारी कंप्यूटर स्क्रीन की सामग्री का विश्लेषण करने में सक्षम विज़ुअल असिस्टेंट।

यदि आप और गहराई में जाना चाहते हैं, तो Google दो उदाहरण प्रदान करता है जो किसी इमेज में ऑब्जेक्ट्स की पहचान कर उनके बाउंडिंग बॉक्स और लेबल देने की मॉडल की क्षमता दिखाते हैं। यह उदाहरण 2D स्थानिक समझ पर केंद्रित है, जिसमें मॉडल से तस्वीर में कपकेक की पहचान और लेबलिंग कराई जाती है। Gemini किसी इमेज के 3D संदर्भ को भी समझ सकता है, जैसा कि यहाँ प्रदर्शित किया गया है।

कुल मिलाकर, भले ही API का वर्तमान संस्करण हमें इसकी पूरी क्षमता का उपयोग अभी नहीं करने देता, Gemini 2.0 काफ़ी आशाजनक है। मैं निकट भविष्य में मल्टीमोडल रियल-टाइम क्षमताओं का पूर्ण उपयोग करने के लिए उत्साहित हूँ।

François Aubry

लेखक

François Aubry

LinkedIn
Full-stack इंजीनियर एवं संस्थापक, CheapGPT पर। पढ़ाना हमेशा से मेरा जुनून रहा है। विद्यार्थी जीवन से ही मैं उत्साहपूर्वक ट्यूशन देने और अन्य विद्यार्थियों की सहायता करने के अवसर तलाशता रहा हूँ। इसी जुनून ने मुझे पीएचडी करने के लिए प्रेरित किया, जहाँ मैंने अपने शैक्षणिक प्रयासों के साथ शिक्षण सहायक के रूप में भी काम किया। उन वर्षों में पारंपरिक कक्षा-परिवेश में काम करना, संबंध बनाना और सीखने को आसान बनाना मुझे अत्यंत संतोष देता था। लेकिन ऑनलाइन लर्निंग प्लेटफ़ॉर्म के आगमन के साथ, मैंने डिजिटल शिक्षा की रूपांतरकारी क्षमता को पहचाना। वास्तव में, हमारी ही विश्वविद्यालय में ऐसे एक प्लेटफ़ॉर्म के विकास में मैं सक्रिय रूप से शामिल था। मैं पारंपरिक शिक्षण सिद्धांतों को नवोन्मेषी डिजिटल पद्धतियों के साथ जोड़ने के लिए गहराई से प्रतिबद्ध हूँ। मेरा उद्देश्य ऐसे पाठ्यक्रम बनाना है जो न केवल रोचक और सूचनाप्रद हों, बल्कि इस डिजिटल युग के शिक्षार्थियों के लिए सुगम भी हों।

विषय

कृत्रिम बुद्धिमत्ताबड़े भाषा मॉडल