Gemini 2.0 Flash: Adım Adım Eğitim ve Demo Projesi

Adım 1: Google AI Studio için API Anahtarını Ayarlayın

API anahtarını ayarlamak için Google AI Studio’ya gidin ve “Create API Key” düğmesine tıklayın. Anahtarı kopyalamayı unutmayın ve aşağıdaki biçimde .env adlı bir dosyaya yapıştırın:

GOOGLE_API_KEY=replace_this_with_api_key

Aynı Google hesabını kullanarak daha önce Google Cloud Platform ile çalıştıysanız, Google AI Studio API’yi etkinleştirmek için projelerinizden birini seçmenizi isteyecektir.

Bu eğitimi takip edebilmek için Python kodunun .env dosyasıyla aynı klasörde olması gerekir.

Adım 2: Python Bağımlılıklarını Yükleyin

Bu projede aşağıdaki paketleri kullanacağız:

• google-genai: Google’ın üretken yapay zekâ modellerini uygulamalarımıza entegre etmek için bir Python kütüphanesi.
• pyautogui: Görevleri otomatikleştirmek için fare ve klavyeyi programlı olarak kontrol eden çapraz platform bir kütüphane. Bizim durumda, ekran içeriğini yapay zekâ modeline sağlamak için kullanıyoruz.
• python-dotenv: ortam değişkenlerini yönetmek için .env dosyalarından Python uygulamamıza yükleyen bir kütüphane.
• sounddevice: Ses giriş ve çıkışı için basit API’ler ile ses kaydetmeye ve oynatmaya yarayan bir Python kütüphanesi.
• numpy: Diziler, matrisler ve çok çeşitli matematiksel işlemler için destek sağlayan, Python’da sayısal hesaplamanın temel kütüphanesi.

Bağımlılıkları yüklemek için pip kullanabiliriz:

pip install google-genai pyautogui python-dotenv sounddevice numpy

requirements.txt dosyasını bu proje için hazırladığım GitHub deposundan indirip bir Conda ortamı oluşturmak için de kullanabiliriz:

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

Adım 3: Google GenAI API ile Metin Sohbet Botu Oluşturun

Hadi, google.genai kütüphanesiyle Google’ın Gemini 2 Flash modelini kullanarak basit bir komut satırı yapay zekâ sohbet arayüzü oluşturarak başlayalım. Yol boyunca bir aksilik olursa Gemini 2.0’ın resmi belgelerini incelemenizi öneririm.

Bu örneğin tamamı GitHub depomdaki text.py dosyasında mevcuttur.

Google GenAI istemcisini oluşturma ve bağlanma

İlk adım, API anahtarını güvenli şekilde yüklemek ve Google GenAI istemcisini başlatmaktır. Betik, ortam değişkenlerini .env dosyasından yüklemek için dotenv kullanır.

İstemciyi gerekli kimlik bilgileriyle şu şekilde ayarlayabiliriz:

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!")

Asenkron API çağrıları yapmak

Google GenAI gibi API’lerle çalışırken sıklıkla asenkron işlemleri yönetmemiz gerekir. Asenkron programlama, ağ isteklerini beklerken diğer işlemlerin devam etmesine izin vererek uygulamanızın daha duyarlı olmasını sağlar. Bu, ağ istekleri gibi gecikmesi yüksek işlemlerle uğraşırken özellikle önemlidir.

Python’da asenkron programlama asyncio kütüphanesi ve async/await sözdizimiyle mümkündür.

Google GenAI’ye asenkron bir istek şu şekilde yapılabilir:

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())

Bu sürüm, yapay zekâ modeline bağlanır ve tek bir “Hello” mesajı gönderir. Yanıt, konsola sözcük sözcük yazdırılır.

Etkileşimli hale getirme

Uygulamayı etkileşimli hale getirip kullanıcının modelle karşılıklı sohbet etmesini sağlamak için kullanıcının birden fazla mesaj göndermesine izin veren bir döngü ekliyoruz. Kullanıcı "exit" yazana kadar döngü devam eder.

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())

Ve hepsi bu! Yukarıdaki betikle Google GenAI API kullanarak bir komut satırı yapay zekâ sohbet botu oluşturduk. İşte nasıl göründüğü:

Adım 4: Ses Modunu Ekleyin

Ses modu, modelin metin yerine sesle yanıt vermesini sağlar. Önceki örneği ses yanıtlarını işleyebilecek şekilde uyarlamak için şunları yaparız:

1. sounddevice’ı ses çalma ve numpy’yi ses verisini işlemek için içe aktarın.
2. Yanıt kipini TEXT’ten AUDIO’ya değiştirin:

	config = {"response_modalities": ["AUDIO"]} 

3. İstemciye bağlanmadan önce bir ses akışı başlatın:

	with sd.OutputStream(
	samplerate=24000, 
	channels=1, 
	dtype="int16",
) as audio_stream:

4. Yanıt parçasından ses verisine erişin ve çalmak üzere ses akışına yazın:

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 dosyasında, depoda bu değişikliklerin tamamını içeren betik yer alır. Betikte değişen satırlar üzerinde açıklamalar mevcuttur.

Adım 5: Araçlarla Kod Çalıştırma Ekleyin

Modern yapay zekâ modellerinin harika özelliklerinden biri, kodumuzda tanımladığımız özel işlevleri kendi başlarına çağırabilmeleridir; Gemini 2 de bir istisna değil.

Çalışma şekli şu: Modellerin çağırabileceği işlevleri araçlar olarak kaydederek hangi işlevlerin mevcut olduğunu modele söylüyoruz. Ardından model, istemi, işlev adlarını ve açıklamalarını analiz ederek bir işlev çağrısı yapıp yapmamaya karar veriyor. Karar verirse, çağırmak istediği işlevin adını ve argümanlarını içeren özel bir yanıt gönderiyor.

Bir aracı tanımlamak için şunları yapmamız gerekir:

1. Şemada tanımlananla aynı ada ve argümanlara sahip bir Python işlevi yazın.
2. İşlevin adı, metinsel açıklaması ve argümanların belirtimi gibi üst verileri içeren bir sözlük olan işlev şemasını oluşturun.
3. İşlev şemasını yapay zekâ modeline sağlayın.
4. Model talep ettiğinde işlevi çalıştırın.

Bunu göstermek için, modelin yerel makinemizdeki dosyalar hakkında soruları yanıtlayabilmesi adına bir dosya okuyabilen bir araç tanımlayalım.

İşlevi tanımlama

Bu kısım tamamen normal Python kodu. İşlev başarılı olursa model yanıtı ”result” anahtarı olan bir sözlük bekler; aksi halde ”error” bekler.

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",
      }

Şemayı belirtme

Bu işlev için bir şemayı şu şekilde tanımlayabiliriz:

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",
    },
}

Dört alan sağlıyoruz:

• ”name”: İşlevin adı.
• ”description”: Metinsel açıklama. Model, işlevi çağırıp çağırmayacağına karar vermek için bunu kullanır.
• ”properties”: İşlev argümanlarının açıklaması.
• ”output”: İşlev çıktısının açıklaması.

İşlev şemaları hakkında daha fazla bilgi için resmi belgelere göz atın.

İşlevi modele sağlama

Modelin işlevimizden haberdar olması için işlev şemasını model yapılandırmasına ekliyoruz:

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

Modelden gelen işlev çağrısı isteğini işleme

Model bir işlev çağrısı yapmaya karar verdiğinde, response içine bir tool_call ekler. Bu, işlevin adını ve argümanlarını içerir. Birden fazla çağrı isteği içerebileceğinden hepsini yinelememiz, ilgili işlevleri çağırmamız ve sonucu modele geri göndermemiz gerekir:

# 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 dosyasındaki bu örneğin tam uygulaması, yapılan tüm değişikliklerle birlikte depoda yer almaktadır. İşlev ve şema tanımları ise tool_spec.py dosyasında bulunur.

Web erişimi

Araçlar kullanarak modele Google arama aracını ekleyip web erişimi de sağlayabiliriz:

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

Bu araç yerleşiktir; bu nedenle bir işlev sağlamamız gerekmez.

Kod çalıştırma

Bir diğer yerleşik işlev de kod çalıştırmadır. Kod çalıştırma, modelin genellikle matematik içeren karmaşık soruları yanıtlamak için Python kodu yazmasına ve çalıştırmasına olanak tanır. Örneğin, bu araçla ilk 10 asal sayının toplamını hesaplamasını istersek önce bunu hesaplayacak Python kodunu yazar, çalıştırır ve ardından yanıtı verir.

Aracı etkinleştirmek için şunu yaparız:

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

Kod çalıştırma ile modelin davranışına bir örnek:

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

Adım 6: Görsel Bir Asistan Oluşturun

Bu son bölümde Gemini 2’nin görsel yeteneklerini keşfediyoruz. Amacımız, ekrandaki içeriği anlayıp onunla ilgili soruları yanıtlayabilen bir yapay zekâ asistanı oluşturmak. Bu, örneğin terminalimizde gördüğümüz bir hatayı açıklamasını istediğimizde veya ekranda şu anda görüntülenen bir şey hakkında bilgi almak istediğimizde faydalı olabilir.

Önceki örneklerde, yanıtlara gerçek zamanlı olarak yanıt verirken modele bağlanmak ve veriyi karşılıklı iletmek için asenkron programlama kullandık. Ne yazık ki SDK’nın mevcut sürümü henüz görsellerle gerçek zamanlı iletişimi desteklemiyor. Bunun yerine, görsel veriyi istek-yanıt iş akışıyla sağlıyoruz. Bunun Gemini 2.0’ın kendisinin bir kısıtı olmadığını, sadece mevcut beta API’nin henüz bunu desteklemediğini unutmayın.

Google GenAI’ye senkron bir istek gönderme

Google GenAI API’sine görsel veri içeren bir istek göndermeyi öğrenerek başlayalım. Senkron bir istek şu şekilde gönderilebilir:

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)

Bu örnekteki temel fark, API’ye istek göndermek için client.models.generate_content kullanmamız. Bu, gerçek zamanlı bir sohbet deneyimi sunmayan senkron bir istektir.

Görsel gönderme

Bir görseli yükleyip contents listesine ekleyerek gönderebiliriz. Görseli yükleyip yeniden boyutlandıran load_and_resize_image() adlı bir işlev oluşturmak için PIL paketini kullanıyoruz.

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)

Yapay zekâ görsel asistanı oluşturma

Yapay zekâ görsel asistanı, ekrandaki şeyler hakkında soruları yanıtlamaya yardımcı olmak için metinsel bir istemi ekran görüntüsüyle birlikte işler. Bunu kapsamlı biçimde denedim ve model, birden fazla pencere açık olduğunda bile ekran içeriğini anlayabiliyor.

Modele ekran içeriği sağlamanın en basit yolu ekran görüntüsü almaktır. Bunun için, fare ve klavyeyi programlı olarak kontrol ederek görevleri otomatikleştiren çapraz platform kütüphanesi pyautogui’yi kullanıyoruz. Bizim durumda yalnızca ekran görüntüsü almak için kullanacağız; ancak istenirse yapay zekânın bilgisayarımızda otonom şekilde görevler yürütmesini sağlayacak şekilde de genişletilebilir.

Ekran görüntüsü almak için bir işlev:

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

Etkileşimli hale getirmek için kullanıcı uygulamadan çıkmaya karar verene kadar şu adımları tekrarlarız:

1. Kullanıcıdan bir istem girmesini isteyin.
2. Ekran görüntüsü alın ve istemle birlikte yapay zekâ modeline gönderin.
3. Sonucu kullanıcıya gösterin.

Bu yaklaşımla ilgili akılda tutulması gereken bir nokta var. Uygulama terminalde çalışacak ve terminal de ekranda görüntülenecek. Bu nedenle, modele terminal penceresini yok saymasını söylemek daha iyidir. Bu, yapılandırmaya bir system_instruction eklenerek yapılabilir:

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",
        ),
)

Hepsini bir araya getirdiğimizde görsel yapay zekâ asistanımız şöyle oluyor. Tam kodun yer aldığı dosya ayrıca depoda vision.py olarak da mevcuttur.

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()

Mevcut sürüm biraz hantal; tetiklemek için terminalin mevcut görünümün üstünde açık olması gerekiyor. Doğal bir sonraki adım, arka planda çalıştırıp metin yerine sesli giriş ve çıkış kullanmaktır.

Sonuç

Gerçek zamanlı olarak metin ve sesle sohbet edebilen botlar geliştirmek, yapay zekâ modeline işlev çağrılarıyla eylemler yaptırmak ve bilgisayar ekranımızdaki içeriği analiz edebilen bir görsel asistan oluşturmak gibi çeşitli uygulamalar için Gemini 2.0 Flash modelini nasıl kullanacağımızı öğrendik.

Daha fazla keşfetmek isterseniz, Google modelin bir görseldeki nesneleri sınırlayıcı kutular ve etiketlerle tespit etme yeteneğini gösteren iki örnek sunuyor. Bu örnek, modelden bir resimdeki cupcakeleri tanımlayıp etiketlemesini isteyerek 2B mekânsal anlayışa odaklanıyor. Gemini, burada gösterildiği gibi bir görselin 3B bağlamını da anlayabiliyor.

Genel olarak, API’nin mevcut sürümü henüz tüm potansiyelini kullanmamıza izin vermese de Gemini 2.0 oldukça umut verici. Yakın gelecekte çok modlu gerçek zamanlı yetenekleri tam anlamıyla kullanmayı sabırsızlıkla bekliyorum.