Gemini 4 Argon API Eğitimi: Yavaş Python Kodunu Hızlandıran Bir Aracı Oluşturun

Gemini 4 Argon API Nedir?

Gemini 4 Argon API size gemini-4-argon modelini sunar: karmaşık kodlama ve çok adımlı aracı görevleri için geliştirilmiş bir Google akıl yürütme modeli. 2026 Ekim ortasında genel kullanıma açıldı. Şu model sayfasına göre, girdi, düşünme ve çıktı tek bir 1.048.576 tokenlık pencereyi paylaşır ve eşzamanlı bir yanıt 65.536 çıktı tokenında durur.

Google benzer bir deneyi ADK vaka çalışmasında yaptı: Python Agent Development Kit (ADK) üzerinde /goal ile 11 saatlik bir Antigravity çalıştırması. İnceleyiciler 6 öneriden 2'sini kabul etti; uzun oturumlarda oturum hazırlığını yaklaşık %40, içe aktarmaları %21 azalttı. Bu eğitim bunun yerine küçük bir Python döngüsü kullanıyor.

Dört API özelliği kullanacaksınız:

• Google'ın yeni projeler için önerdiği ve konuşma durumunu sunucuda tutan Etkileşimler API'si

• Modelin bir araç istediği ve kodunuzun bunu çalıştırıp çalıştırmayacağına karar verdiği Fonksiyon çağırma

• thinking_level: low, varsayılan medium veya high

• Girdi, önbellek, çıktı ve düşünme tokenlarını raporlayan usage nesnesi

Argon ister, işi sizin kodunuz yapar.

Proje: Gemini 4 Argon'un Düzelteceği Yavaş Bir Python Uygulaması

Aracıya EventFlow kodu, 8 araç ve yavaşlama hakkında hiçbir ipucu veriliyor. Tam kod GitHub'da. EventFlow ile başlayın.

EventFlow nasıl çalışır

EventFlow, altı küçük modülden oluşan kurgusal bir olay işlemcisidir. Bir olay EventFlow.ingest() içine girer, validate() onu bir Event nesnesine çevirir ve CustomerState bunu müşteri başına zaman damgası sırasıyla saklar. Ardından summarize() her geçmişi oturumlara, gelire, iadelere ve sayfa sayılarına dönüştürür ve build_report() bir CustomerReport üretir.

Tek bir olayın rapora dönüşümü. Görsel: Yazar.

EventFlow'un docstring'leri şu kuralları belirler:

• Oturumlar 30 dakikalık bir boşluktan sonra bölünür

• İadeler, satın alımın kalan tutarıyla sınırlıdır

• Yinelenen bir event_id yok sayılır; ilk kopya geçerlidir

• Olaylar, partiler arasında bile zaman damgasına göre sıralanır

• history() ve report() çağıranın sahip olduğu nesneleri döndürür

Gizli testler bunların hepsini kontrol eder ve sonuncusu daha sonra tekrar karşımıza çıkar.

EventFlow neden yavaşlar

Sabit tohumlardan oluşturulan üç iş yükü, geçmiş uzunluğunun görünümü nasıl değiştirdiğini gösterir:

• short: her birinde 5 olay olan çok sayıda müşteri

• long: her birinde 160 olay olan az sayıda müşteri

• mixed: müşteri başına 1 ila 30 olay; yinelenenler ve sıradışı gelen olaylarla

long, short'tan çok daha az olaya sahip olmasına rağmen yaklaşık 3 kat daha uzun sürer. Grafikte toplam 1.600 olay sabit tutulur ve her müşteriye daha uzun bir geçmiş verilir.

Toplam aynı, geçmişler daha uzun, işlem daha yavaş. Görsel: Yazar.

Geçmiş uzunluğu her ikiye katlandığında, çalışma süresi de ikiye katlanıyor; oysa toplam olay sayısı hiç değişmiyor. Bu desen genellikle her yeni olayda tüm geçmiş üzerinde işin tekrarlandığı bir adım olduğu anlamına gelir. Aracı nedenleri hiç görmez; ben de bunları Argon işini bitirdikten sonra adlandıracağım.

Başarı ölçütleri ve gizli testler

Bir düzeltme, yalnızca ilk API çağrısından önce belirlenen beş kontrolden geçerse sayılır; modelin kendi raporu puan getirmez. Aracının nihai kodu aşağıdakilerin tümünü yapmalıdır:

• long üzerinde en az 1,5x daha hızlı çalışmak

• short veya mixed üzerinde en fazla %5 daha yavaş çalışmak

• Tüm görünür testlerden geçmek

• Üç iş yükünün hepsinde orijinaliyle aynı rapor çıktısını döndürmek

• Tüm gizli kabul senaryolarından geçmek

Bu eşikler bana ait; dolayısıyla bir örnek olarak görün. Aracının araçları gizli vakalara erişemez; yalnızca kodu dondurulduktan sonra çalışırlar. Yeni veriler, geç gelen partiler, yinelenenler ve sahiplik kuralları üzerinde, kodunu ayrı bir referans uygulamasıyla karşılaştırırlar.

Gizli bir paket yalnızca yanlış düzeltmeleri reddederse işe yarar; bu yüzden bilerek birkaç tane besleyin. Buradaki iki kolay kestirme tüm görünür testlerden geçer: derin kopyayı kaldırmak ve özeti asla yenilemeden önbelleğe almak. Gizli vakalar ikisini de reddeder.

Gizli testler iki yanlış düzeltmeyi yakalıyor. Görsel: Yazar.

Gemini 4 Argon API'yi Python'da Nasıl Kurarsınız

Python 3.10 veya üzeri, bir Gemini API anahtarı ve faturalandırması açık bir Google AI Studio projesine ihtiyacınız var; çünkü fiyatlandırma sayfası Argon için Ücretsiz katmanı listelemiyor. Bu proje google-genai yazılım geliştirme kitini (SDK) 2.33.0'a sabitler; Etkileşimler API'si en az 2.3.0 gerektirir.

git clone https://github.com/KhalidAbdelaty/Gemini-4-Argon-API-Tutorial-.git eventflow-argon
cd eventflow-argon
python -m venv .venv
.venv\Scripts\Activate.ps1
pip install -r requirements.txt
Copy-Item .env.example .envAltyapı:

macOS veya Linux'ta, sanal ortamı source .venv/bin/activate ile etkinleştirin ve cp ile kopyalayın; ardından GEMINI_API_KEY=... değerini .env dosyasına koyun. Kabukta GOOGLE_API_KEY de ayarlıysa, SDK onu kullanır; bu yüzden aşağıdaki kod önce onu kaldırır. Daha önce Etkileşimler API'sini kullandıysanız, bir sonraki alt bölümü atlayın.

İlk Gemini 4 Argon API isteğinizi yapın

İlk isteğiniz Argon'a EventFlow'un profil çıkışının üst kısmını verir ve bunun ne gösterdiğini sorar. load_dotenv() .env'den GEMINI_API_KEY'i yükler, genai.Client() onu okur; model kimliği client.interactions.create()'e girer ve generation_config düşünme düzeyini taşır.

import os

from dotenv import load_dotenv
from google import genai

load_dotenv()
os.environ.pop("GOOGLE_API_KEY", None)
client = genai.Client()  # reads GEMINI_API_KEY from the environment

profile_excerpt = """paste the top rows of your cProfile output here"""
prompt = (
    "This cProfile excerpt comes from a Python app that turns customer events into "
    "reports. It is correct but slow on long customer histories.\n\n"
    f"{profile_excerpt}\n\n"
    "In three short bullets: what the profile shows, what you would read next in the "
    "code, and what this evidence alone does not prove."
)

interaction = client.interactions.create(
    model="gemini-4-argon",
    input=prompt,
    generation_config={"thinking_level": "medium"},
    timeout=900,  # seconds; Google recommends at least 15 minutes
)
print(interaction.output_text)
usage = interaction.usage
print(usage.total_input_tokens, usage.total_output_tokens, usage.total_thought_tokens)Altyapı:

Geri gelen şuydu:

İlk Argon isteği profili okuyor. Görsel: Yazar.

Argon doğru tespit etti; zamanın neredeyse tamamı get_history() ve copy.deepcopy altında geçiyordu; muhtemelen olay başına iki kez çağrılıyorlardı. Üçüncü madde, derin kopyayı kaldırmanın, dönen verileri değiştiren çağıranları bozabileceği konusunda uyardı; bu da az önce bahsettiğim ilk kestirmeydi. Bu tür bir soru ucuzdur: 8 saniyenin altında ve yarım sentten az, üstelik düşünme tokenı yok.

medium varsayılandır ve az önce bağlantısını verdiğim en yeni model kılavuzu, onu "karmaşık kod ve aracısal kullanım senaryoları dahil çoğu görev için" öneriyor. Aynı kılavuz, temperature, top_p ve top_k'nin Argon'da yok sayıldığını belirtiyor; bu yüzden eklemeyin.

Gemini 4 Argon'u Kullanmadan Önce Python Kodunu Profilleyin

Model kodu dokunmadan önce orijinal uygulamayı ölçün; böylece sonraki her sayı karşılaştırma yapabileceğiniz bir değere sahip olur. Her biri kendi sürecinde olmak üzere üç tür ölçüm alın; çünkü her araç diğerlerini saptırır:

• time.perf_counter() ile zamanlama; her biri bir ısınma içeren birkaç taze süreçten medyan

• Zamanın nereye gittiğini bulmak için cProfile ile profil çıkarma; long'u yaklaşık 6 kat yavaşlattı, bu yüzden bir profil altında alınmış zamanlamaya asla güvenmeyin

• Toplam işlem belleği yerine, izlenen Python ayırmalarının tepe değerini raporlayan tracemalloc ile bellek

Sabit 1.600 olaylı grafik yerine üç iş yükünde, orijinal uygulama short'ta yaklaşık 0,7 saniye, long'da 2,2, mixed'te 1,0 saniye sürdü. Ayrıca tüm görünür pytest testlerinden geçti.

Yavaş uygulamanın zamanı nerede harcadığı. Görsel: Yazar.

Sürüklenme bekleyin: Aynı kod daha sonra yaklaşık %10 daha hızlı zamanlandı; bu yüzden her sürümü aynı oturumda zamanlayın.

Gemini 4 Argon Fonksiyon Çağırma ile Bir Performans Aracısı Nasıl Kurulur

Daha önce de belirttiğim gibi, Argon yalnızca araçlar ister. Onları çalıştıran Python koduna çerçeve (harness) denir; aracı çerçevesi mühendisliği rehberimiz, kontrollerin istem yerine neden kodda olması gerektiğini açıklar. Önce araçlar gelir; çünkü Argon'un neye dokunabileceğini onlar belirler.

Aracının araçlarını ve izinlerini tanımlayın

Önceden bahsettiğim 8 araç, düz JSON şemaları olarak bildirilen Python fonksiyonlarıdır ve bunlardan yalnızca ikisi kodu değiştirebilir:

• Uygulamanın Python kaynakları, testleri ve sabit verileriyle sınırlı list_files ve read_file

• Adı verilen tek bir iş yükü için run_profiler ve run_benchmark

• Mevcut bir uygulama kaynak dosyasındaki metnin tam olarak bir kez geçen bir örneğini değiştiren apply_patch

• revert_file, run_tests ve show_diff

Beyannameler, az önce bağlantısını verdiğim fonksiyon çağırma kılavuzundaki biçimi izler:

{"type": "function", "name": "apply_patch",
 "description": ("Replace exactly one occurrence of old_text with new_text in a file under eventflow/. "
                 "The file must still compile afterwards."),
 "parameters": {"type": "object", "properties": {
     "path": {"type": "string"},
     "old_text": {"type": "string", "description": "Exact text to replace; must occur once."},
     "new_text": {"type": "string"}},
     "required": ["path", "old_text", "new_text"]}},Altyapı:

Bir şema çağrıyı açıklar ama çağrıyı güvenli kılmaz. Çerçeve Python'da şu kontrolleri ekler:

• Her yol önce çözümlenir; bu sayede kopyalanmış uygulamanın dışına çıkan bir yol başarısız olur
• Uygulamanın kaynak klasörü dışına yazmalar reddedilir
• Yamalı dosya hâlâ derlenebilmelidir; aksi takdirde yama reddedilir
• Testler ve kıyaslamalar, zaman aşımı ve API anahtarı olmadan alt süreçlerde çalışır

Bu bir konteyner değildir ve yamalanmış kod yine de kopyanın dışındaki dosyaları okuyabilir; bu yüzden bunu asgari düzey olarak görün.

Argon ister, Python karar verir ve çalıştırır. Görsel: Yazar.

Aracıya ölçülebilir bir performans hedefi verin

Sistem yönergesi hedefi ve kuralları belirtir; ancak yavaşlamanın nerede olduğunu asla söylemez:

Objective: make EventFlow faster on the supplied workloads without changing its
observable outputs or its public interfaces.
- Measure before you edit. Use run_benchmark and run_profiler to find where the
  time goes, then read the code the evidence points to.
- Behavior must follow the public contract documented in the docstrings, not
  only the visible tests.
- After every change, run run_tests and run_benchmark. If a test fails or
  output_matches_original is false, repair or revert the change.
- Acceptance target: at least 1.5x faster on the long workload, no more than 5%
  slower on short and mixed, all visible tests passing, and
  output_matches_original true on all three workloads.Altyapı:

Aracı, görebildiklerinden yola çıkarak ne zaman duracağına karar verir: görünür testler, profil ve kıyas sonuçları ve döngünün bir sonraki adımda belirlediği sınırlar.

Etkileşimler API araç döngüsünü uygulayın

Aşağıdaki parça döngünün çekirdeğidir; tam sürüm istemciyi, araç dağıtıcısını ve sınırları ekler. Her tur bir client.interactions.create() çağrısıdır ve Argon sık sık bir turda birden fazla araç ister; bu yüzden döndürdüğü her function_call adımını çalıştırın. Her sonucu, eşleşen call_id ile bir function_result olarak geri gönderin:

# requires_action means "run my tools"; incomplete means the output cap cut the turn off
TERMINAL = {"failed", "cancelled", "incomplete"}

request = dict(
    model="gemini-4-argon",
    system_instruction=SYSTEM_INSTRUCTION,  # the goal shown above
    tools=DECLARATIONS,                     # the 8 schemas, like apply_patch above
    generation_config={"thinking_level": level, "max_output_tokens": 65_536,
                       "thinking_summaries": "auto"},
)
interaction = client.interactions.create(input=task, timeout=900, **request)

while True:
    calls = [s for s in interaction.steps if s.type == "function_call"]
    if interaction.status in TERMINAL or not calls:   # failed, cut off, or completed
        break
    results = []
    for call in calls:
        output, is_error, _ = tools.call(call.name, call.arguments)   # validated, run locally
        results.append({"type": "function_result", "name": call.name, "call_id": call.id,
                        "is_error": is_error,
                        "result": [{"type": "text", "text": json.dumps(output)}]})
    # application limits checked here: 40 turns, 45 minutes, $5
    # **request again: tools, instruction, and config don't carry over between turns
    interaction = client.interactions.create(
        input=results, previous_interaction_id=interaction.id, timeout=900, **request)Altyapı:

**request satırı, takip çağrısında insanların en çok atladığı satırdır. previous_interaction_id geçmişi taşır; ancak tools, system_instruction ve generation_config etkileşim kapsamındadır; bu yüzden bunlar olmadan yapılan bir tur araçları kaybeder veya varsayılan düşünme düzeyine geri döner. Bu kuralı unutması kolay; bu nedenle kod üç ayarı tek bir sözlükte tutar.

API'nin görev bütçesi yoktur; bu yüzden başlamadan önce uygulamanızda tur, süre ve harcama sınırları belirleyin. Ben 40 tur, 10 yama, 45 dakika ve 5 $ kullandım; hiçbir deneme yaklaşmadı bile; ancak harcama kontrolü turlar arasında çalışır; bu nedenle tek bir uzun tur bunu aşabilir. Google'ın oran sınırları sayfası, Seviye 1 hesaplarda kendi üst sınırını ekler: kayan 10 dakikada 10 $; bunun aşılmasında 429 RESOURCE_EXHAUSTED döndürür.

Gemini 4 Argon Aracısını Çalıştırın ve Değişikliklerini Doğrulayın

Her deneme uygulamanın taze bir kopyasından başladı, kendi kendine yaklaşık 5 dakika içinde durdu ve herhangi bir gizli kontrol çalışmadan önce kodu donduruldu.

Kanıtlardan yola çıkarak darboğazı bulma

Argon, önce ölçerek darboğazı buldu. İlk medium deneme, tur tur şöyleydi.

Bir medium deneme, tur tur. Görsel: Yazar.

Düşünce özetleri, her adımı değil akıl yürütmenin yoğunlaştırılmış bir sürümünü gösterir; düzeltmeye nasıl ulaşıldığını ortaya koyar. Argon, has_event() ve add()'in her ikisinin de get_history() çağırdığını fark etti. Derin kopyanın "burada gerçekten gerekli olup olmadığını, yoksa gerekliliğin sadece çağıranın verinin sahibi olması olup olmadığını sordu ve bunu, fonksiyonun girdisini değiştirmediğini söyleyen summarize() docstring'iyle netleştirdi.

Her iddia kanıtlara dayanmadı. Aynı özet, testlerde veya gizli kullanımlarda "doğrudan erişim yok" diyor ki Argon bunu bilemezdi. Tahmin tuttu (bu kez), ancak incelemede altı çizilecek türden bir ifade.

Altı denemenin de ulaştığı düzeltme

Her deneme CustomerState üzerinde aynı temel değişikliği yaptı; altı farktan en küçüğü bunu en iyi şekilde gösteriyor:

     def __init__(self, customer_id: str):
         self.customer_id = customer_id
         self._events = []
-        self.summary = summarize([])
+        self._event_ids = set()
+        self._summary = None
+
+    @property
+    def summary(self):
+        if self._summary is None:
+            self._summary = summarize(self._events)
+        return self._summary
 
     def get_history(self):
@@
         return copy.deepcopy(self._events)
 
     def has_event(self, event_id: str) -> bool:
-        return any(e.event_id == event_id for e in self.get_history())
+        return event_id in self._event_ids
 
     def add(self, event) -> None:
-        bisect.insort(self._events, event, key=_order_key)
-        self.summary = summarize(self.get_history())
+        self._event_ids.add(event.event_id)
+        if not self._events or (self._events[-1].ts, self._events[-1].seq) <= (event.ts, event.seq):
+            self._events.append(event)
+        else:
+            bisect.insort(self._events, event, key=_order_key)
+        self._summary = NoneAltyapı:

Şimdi söz verdiğim yerleştirilmiş nedenler: add() her olayda tüm geçmişi yeniden özetliyordu; her olay iki tam derin kopyanın bedelini ödüyordu ve yinelenen kontrolleri listeyi tarıyordu.

Olay başına iş: düzeltmeden önce ve sonra. Görsel: Yazar.

get_history(), dış çağıranlar için derin kopyasını korur; önceki derin kopya kestirmesinin yanıldığı nokta budur.

Her yama turu görünür testlerden geçti; bu yüzden aracı geri almaya gerek duymadı; ancak denemelerin çoğu, kimsenin çağırmadığı bir summary atayıcı (setter) da ekledi. Kimse istemedi ve yine de birinin incelemesi gerekiyor.

Gizli kabul testi sonuçları

Gizli değerlendirici her deneme için bir kez çalıştı ve her deneme tüm vakalardan geçti. Vakalar, report()'tan sonra ingest() çağırır, iadeleri satın alımlarından önce gönderir ve döndürülen nesneleri değiştirerek motor durumunun yerinde kaldığını doğrular.

Gemini 4 Argon Uygulamayı Gerçekten Hızlandırdı mı?

Evet. Her yeni sürüm çok daha hızlıydı ve orijinaliyle aynı çıktıyı verdi. Daha önce de belirttiğim gibi zamanlamalar sürüklenir; bu yüzden orijinali ve 6 yeni sürümün hepsini, 9 taze süreçle dönüşümlü sırada zamanladım.

Her zamanlama yalnızca ingest ve raporları kapsar; Python başlatma veya içe aktarmaları kapsamaz. Birkaç milisaniyede tek bir zamanlama medyanın çok üzerine çıkabilir; bu yüzden medyanları karşılaştırın. Grafiğin log ölçeği, yeni sürümlerin orijinalin yanında kaybolmasını engeller.

Önce saniyeler, sonra milisaniyeler; çıktılar aynı. Görsel: Yazar.

Grafik, her düzeydeki ilk denemeyi gösteriyor; tablo ise 6'sının tamamını kapsıyor; hızlanma değeri orijinal medyanın yeni medyana bölünmesi olarak hesaplandı:

long en çok kazancı sağladı; çünkü kaldırılan iş, her müşterinin geçmişiyle birlikte büyüyordu. Bellek satırları, düzeltmenin bir maliyetinin göründüğü tek yer. short en çok müşteriye sahip olduğundan yaklaşık %10 daha fazla kullandı; muhtemelen müşteri başına yeni kimlik kümesi için; long ise daha az kullandı; muhtemelen artık kopyalar oluşturmayı bıraktığı için.

700x'i Argon'a özgü bir şey olarak okumayın. Suni veriden bir kuadratik döngüyü kaldırmak genellikle bu tür sayılar üretir; düzeltmeyi kim yazarsa yazsın.

Gemini 4 Argon Düşünme Düzeyleri: Medium vs. High

Bu görevde high, medium'dan biraz daha hızlı kod yazdı; ancak her iki düzey de aynı düzeltmeyi buldu; bu yüzden ekstra düşünme teşhisten çok cilaya gitti.

Karşılaştırmayı adil tutmak

Düşünme düzeyini değiştirin, başka hiçbir şeyi değil. Her deneme aynı kodu, istemi, araçları, sınırları ve değerlendiriciyi kullandı ve hiçbiri diğer denemenin işini görmedi. Düzeyler, tıpkı Claude Opus 5 API eğitimimde kullandığım kurulumda olduğu gibi, 3'er deneme halinde dönüşümlüydü.

Sonuçlar, süre ve maliyet düzeye göre

İki düzey şu şekilde ayrıştı; deneme başına ortalama olarak:

high ilk yamasında aynı düzeltmeyi buldu ve ardından cilalamaya devam etti. Artık ana darboğaz olmayan özetleme, raporlama ve doğrulamanın bazı kısımlarını yeniden yazmaya geçti.

Bu fark makineye göre değişir ve milisaniyelerde biten iş yüklerinde zamanlama gürültüsüne yakındır; bu yüzden yalnızca inceleme süresi açısından bile medium'un daha küçük farkını gönderirdim.

High'ın düşünmesi tur 4'te zirve yaptı; ilk yaması sorunu zaten çözmüştü.

Her denemenin düşünmesini nereye harcadığı. Görsel: Yazar.

Düşünme tokenlarını kalite sinyali olarak da almayın; ilk istekte olduğu gibi, medium denemelerinden biri hiç kullanmadı ve yine de kabul edilen bir düzeltmeyi diğer tüm denemelerden daha hızlı ve ucuza yaptı.

Bir aracının maliyetini hesaplarken, her turun işlediği tam bağlamı raporladığı için usage'ı her tur için toplayın. Her turun girdisinin çoğu önceki turun tekrarından oluşur ve örtük önbellek bunun yaklaşık üçte ikisini önbellek oranından faturalandırdı.

Önbellekleme kılavuzuna göre, önbellek en az 4.096 tokenlık bir isteme ihtiyaç duyar; ve bir tur 2.050'den az yeni token eklerse, bir önceki isteğin son 2.050 tokenı tam orandan faturalandırılır; bu yüzden çok küçük araç sonuçları olan döngüler daha az tasarruf sağlar. Sıkça Sorulanlar'da ele aldığım Standart giriş fiyatlarında, 6 denemenin tamamı toplam 1,16 $ tuttu.

Bir Yapay Zekâ Performans Aracısının Sınırlamaları

Bu tür bir aracı, bir profil aracıyla işaret edilebilecek sorunlarda en iyi çalışır ve bu örnek temiz olacak şekilde tasarlandı:

• Darboğaz, başta belirttiğim gibi, bilerek yerleştirildi. Bir profil aracı, altı küçük dosyada kuadratik bir döngüyü neredeyse doğrudan işaret eder; gerçek yavaşlamalar ise G/Ç, veritabanları ve belgelenmemiş kodda saklanır.

• Docstring'ler çok iş yaptı. Argon, hangi kopyayı atlayabileceğine karar vermek için birine yaslandı; belgesiz bir kod tabanı ise yaslanacak hiçbir şey vermez.

• Testler yalnızca birinin aklına gelenleri kontrol eder. Google'ın ADK vaka çalışmasında, bir içe aktarma değişikliği herkese açık paketten geçti ve yine de dahili test hedeflerinde başarısız oldu.

• Zamanlamalar, yapay iş yüklerinde küçük bir Linux makinesinden geliyor; hızlanmalar sizde farklı olacaktır.

• Aracının okuduğu her dosya Google'a gider; ücretli katmandaki etkileşimler varsayılan olarak 55 gün saklanır; store=false bunu durdurur ama previous_interaction_id'yi de devre dışı bırakır.

Google'ın model kartı ayrıca bilinen sınırlamalar arasında halüsinasyonlar ve zaman zaman yaşanan zaman aşımlarını listeler.

Son Düşünceler

Aracı altı denemenin hepsinde yinelenen özetleri ve derin kopyaları buldu, çağıranların güvendiği kopyayı korudu ve elde tutulan kontrollerden geçti. high düşünme biraz hız ve çok daha büyük bir fark ekledi.

Bunu sizin kod tabanınıza genellemeyeceğim; çünkü darboğazı ben yerleştirdim. Aktarılan şey yöntemdir: önce ölçün, araçları dar tutun, kontrol etmeden önce kodu dondurun ve sonuca gizli testler karar versin.

İlk geliştireceğim uzantı, medium ile başlayıp yalnızca görünür testler başarısız olduğunda high'a geçen bir yönlendirici olurdu; böylece gizli vakalar asla aracıya geri beslenmez. 

Yukarıdaki profil çıktısı sizin için yeniyse, Verimli Python Kodu Yazma kursu, Argon'un koda dokunmasına izin vermeden önce kullandığım aynı zamanlama ve profil araçlarını kapsar.