Google, içerikleri tercih ettiğiniz dile çevirmek için yapay zeka teknolojisini kullanır. Yapay zeka çevirilerinde hata olabilir.

Ayırt edici (Jev/DiffusionGemma) modelleri kullanmaya başlama

1. Giriş

TypeSafe AI'ın System One karar modeli olan ayırt edici model ve Google ADK iş akışında Gemini'ın yanına yerleştirilmesi hakkında 90 dakikalık bir atölye çalışması. Bu atölye çalışmasında, dövüş oyunu üzerine kurulu altı adım yer alıyor. Önce ellerinizle devle karşı savaşacak, ardından reflekslerinizi Ayırt Edici modele teslim edecek ve her tikin Ayırt Edici model tarafından belirlendiği ve Gemini'ın büyüleri okumak için büyü kartlarını ekrandan okuduğu bir ADK iş akışının savaşı kazandığını izleyeceksiniz.

Ayırt edici model ile Gemini'ı birleştiren ADK iş akışı

Genel Bakış

Ayırt edici model (jev-1.13, diğer adıyla jev-latest), TypeSafe AI'ın 19 Eylül 2026'da yayınladığı barındırılan bir modeldir. Metin oluşturmaz. Durum (metin, JSON veya liste) ve yazılmış sorular (Choice, Score, Noul) gönderdiğinizde, yazılmış yanıtları yaklaşık 70-500 ms içinde, kalibre edilmiş olasılıklarla döndürür.Giriş jetonlarının milyonu başına 0, 042 ABD doları, çıkış için ise ücret alınmaz. Görevi, dil modellerinin önünde, arasında ve arkasında karar vermektir: yönlendirme, sınıflandırma, sınırlama ve burada, bir dövüşçünün refleksleri.

Örnek olarak bir oyun

Arena oynanışı ve büyü kartı

Hiç dövüş oyunu oynadınız mı? Bir rakiple karşı karşıya gelir ve hamlelerine anında tepki vermeniz gerekir. Tek bir yanlış tahminde HP'niz zarar görür. Oyunlar da büyü yapmayı zorlaştırır. Bizim oyunumuzda, büyü serbest bırakılmadan önce büyü kartının rengini ve şekillerini sırayla seçmeniz gerekiyor. Bu atölye çalışmasında, karakterinizin kazanması için her iki model türünü nasıl birleştireceğiniz gösterilmektedir.

Oyundaki her öğe gerçek bir sisteme karşılık gelir:

Rakibin hamlesi, istek veya işlem gibi gelen bir etkinliktir.
Yanıtta, ayırt edici model tarafından verilen ve kodla kontrol edilen sınırlı bir karar yer alır.
Yazım kartı, okunması için dil modeli gereken yapılandırılmamış bir giriştir.
Maç, iş akışıdır. Hızlı ve yavaş işler kendi hızlarında yürütülür.

Burada odak noktası, dört bileşeni birleştirip hızlı ve akıllı bir sistem oluşturmak için bunları bir araya getirmektir.

Öğrenecekleriniz

Ayırt edici (Sistem Bir) ve üretken (Sistem İki) modellerin nasıl farklılaştığını ve her birinin ne zaman kullanılacağını açıklayın.
Jev ve DiffusionGemma'nın nasıl sunulduğunu açıklayın ve atölye çalışması için birini (Compute Engine GPU VM'sinde DiffusionGemma dahil) kurun.
Write Choice, Score ve Noul sorularını yazın, olasılıkları ve güveni yorumlayın.
Olasılıkları işlemlere dönüştürmek için deterministik kodda eşikler kullanın.
TypeSafe SDK ile bir istek oluşturun, ardından modelin oyundaki her hareketi seçmesine izin verin.
Gemini'ın bir görüntüyü okuduğu yavaş bir dal ve ayırt edici modelin döngü içinde karar verdiği hızlı bir dal oluşturup her birini ayrı ayrı çalıştırın.
Bir etkinlik döngüsünde durumu paylaşan bir ADK grafiği iş akışında her iki dala da katılın. Böylece yavaş çalışma, hızlı kararları asla engellemez.

Mimari

Çalışma tezgahı, Cloud Shell'de(veya makinenizde) bulunur. Yerel dosya sistemine yazar, arena ile ve Gemini ile etkileşim kurar. ② "Ayırt edici model kavgaları"nda karar modelini çağırır; ③ "İş akışı kavgaları"nda her ikisini de çağırır.

Ayırt edici modeller Workbench mimarisi

Kim neyi arıyor? Tarayıcı yalnızca ① ile iletişim kurar. Her iki model de makinede Python'dan çağrılır:

Arayan	Ayırt edici model	Gemini
② arena, "Discriminative model fights" (Ayırt edici model dövüşleri)	her tik, `TypeSafeClient`	hayır
③ iş akışı `tick`	her tik, `AsyncTypeSafeClient`	hayır
③ iş akışı `spellwright`, `bard`	hayır	Büyü kartı resmi; dövüşten sonraki hikaye
`scripts/first_call.py`, `ask.py`, `fight.py` (terminalden çalıştırılır)	evet	hayır

Mod başına bir onay işareti.

Siz savaşırsınız. Sayfa, ② için telgraf istiyor, 2 saniyelik bir zamanlayıcıyla gösteriyor ve bastığınız düğmeyi (veya yazdığınız heceyi) geri gönderiyor. ② çözülür.
Ayırt edici model kavgaları. Sayfa, ② için onay işareti istiyor; ② telgraf çiziyor, modelden tek bir çağrıda üç soru soruyor, choose() komutunu çalıştırıyor ve yanıtlarla sonucu döndürüyor. Sayfa, çubukları çizer.
İş akışı çakışmaları. Start, ② launch ③ komutunu alt işlem olarak çalıştırır (log in runs/arena-workflow.log). ③, mücadeleyi yönetir: Her telegraph için ② komutunu ister, modeli çağırır ve kararı yayınlar. Gemini'ın yazımı hazır olduğunda kendi dalında gelir. Sayfada yalnızca ② numaralı anket ve çizim gösterilir. Pause, her tikten önce ③ tarafından kontrol edilen ② üzerindeki bir işarettir.

Karar modelinin barındırıldığı yer. Her arama aynı typesafe-sdk üzerinden geçer; yalnızca temel URL değişir. scripts/jevauth.py arka ucu adlandırır, anahtarı ve zaman aşımını ayarlar:

Arka uç	`TYPESAFE_BASE_URL`	Anahtar	Ayarları yapan
TypeSafe, barındırılan	unset (api.typesafe.ai)	`TYPESAFE_API_KEY`	`setup_model.sh --model jev`
L4 sanal makinenizde DiffusionGemma	`http://127.0.0.1:8096`, IAP tüneli	yok	`setup_model.sh --model gemma`
Cloud Run'da DiffusionGemma	`https://djev-...run.app`	saatte bir getirilen bir Google kimlik jetonu	`setup_gemma_cloudrun.sh`
Prova	`http://127.0.0.1:4811`, `JEV101_REHEARSAL=1` tarafından belirlendi	yok	`setup_model.sh --model rehearsal`

Yazım kartının yanıtı ②: İş akışı yalnızca PNG'yi alır ve ②, geri gönderdiği yazımı değerlendirir. Bu, büyüyü Gemini'ın okuma becerisinin gerçek bir testi, "Savaşıyorsunuz"da oluşturduğunuz büyüyü ise sizin gerçek bir testiniz yapar.

2. Kurulum

Atölye kredilerinizi kullanma

Bu oturum için Google Cloud kredisi aldıysanız önce bu krediyi kullanın. Bu işlem yaklaşık bir dakika sürer ve sizin için faturalandırma hesabı oluşturur.

Cloud Shell'i açın

Google Cloud Shell, tarayıcıdan erişilebilen bir Linux ortamıdır. gcloud, Python, Node.js, uv ve git ile önceden yapılandırılmıştır ve Google Hesabınızla kimliği doğrulanmıştır.

Google Cloud Console'u açın.
Tarayıcınızın alt kısmında bir terminal oturumu açmak için Activate Cloud Shell'i (üst gezinme çubuğundaki terminal simgesi) tıklayın.

Google Cloud Console'da Cloud Shell'i etkinleştirme

Workbench'i başlatma

Cloud Shell'de veya gcloud'nın oturumunun açık olduğu herhangi bir yerde:

git clone https://github.com/gca-americas/discriminative-models-workshop.git
cd discriminative-models-workshop
./setup_project.sh     # a new project with billing, recorded in ~/project_id.txt
./setup_codelab.sh     # everything else, then the workbench on port 4900

setup_project.sh, bir proje (discrim-models-XXXX) oluşturur, faturalandırmayı bu projeye bağlar (varsa etkinlik kredisi hesabını tercih eder) ve projenin yayınlanabilmesini bekler. Yeniden çalıştırmak, projeyi ~/project_id.txt içinde yeniden kullanır. Halihazırda kullandığınız bir projeyi kullanmak için projenin kimliğini bu dosyaya girin ve bu komut dosyasını atlayın.

setup_codelab.sh hiçbir şey istemez. uv ve Python paketlerini yükler, Vertex AI, Compute Engine ve IAP'yi etkinleştirir, .env içindeki projede Gemini'ı Vertex AI'a yönlendirir, proje tarafından çağrılabilen bir modelle gerçek bir Gemini çağrısı yapar, sayfayı oluşturur, Workbench'i arka planda başlatır ve scripts/check_setup.py'ı çalıştırır. Tekrar çalıştırmak egzersiz dosyalarınızı korur, scripts/starter.sh ise sıfırlar. Karar modeli, çalışma tezgahının 2. adımında seçilir.

Cloud Shell'de iş istasyonu kullanıcı arayüzünü açmak için:

./setup_codelab.sh bölümünün sonunda yazdırılan önizleme bağlantısını veya Cloud Shell araç çubuğunun sağ üst köşesindeki Web Önizlemesi'ni tıklayın.
Change port'u (Bağlantı noktasını değiştir) seçin, 4900'ü girin ve Change and Preview'u (Değiştir ve Önizle) tıklayın.

Gemini, projenizdeki Vertex AI'da kendi Google kimlik bilgilerinizle (GOOGLE_GENAI_USE_VERTEXAI=1, GOOGLE_CLOUD_PROJECT ve GOOGLE_CLOUD_LOCATION=global) .env içinde çalışır.

Karar modeli, çalışma tezgahının 2. adımında kendi başına veya scripts/setup_model.sh simgesini içeren bir terminalden seçilir:

Seçenek	Gereksinimler	Kurulum	Maliyet
Ayırt edici model (TypeSafe, barındırılan)	TypeSafe API anahtarı	yok	jeton başına, sentin kesirleri
DiffusionGemma (Google, açık ağırlıklar)	faturalandırma + GPU için Compute Engine kotası	Yaklaşık 15 dakika, otomatik	Sanal makine çalışırken ~0,71 ABD doları/saat
Prova (model yok)	nothing	yok	yok

Compute Engine sanal makinesinde DiffusionGemma

scripts/setup_gemma.sh önce GPU kotasını kontrol eder, ardından NVIDIA sürücüsü 580 ile Google'ın derin öğrenme görüntüsünden bir g2-standard-4 VM (1 × L4 24 GB, 4 vCPU, 16 GB) oluşturur. Sanal makine ilk başlatıldığında Docker'ı yükler, ağırlıkları Hugging Face'ten (nvidia/diffusiongemma-26B-A4B-it-NVFP4, 17,5 GB, herkese açık, jeton yok) indirir ve djev-run: Discriminative model'in tam API'sinin arkasında DiffusionGemma'yı çalıştırır. Modelin bağlantı noktası internete açık değil: Workbench, localhost:8096 üzerinde bir IAP tüneli aracılığıyla modele ulaşıyor. Bu tünel, scripts/start.sh tarafından açılıyor.


Duraklatma / devam ettirme	`scripts/gemma_warm.sh off` / `on` (durduruldu: yalnızca disk, ~10 ABD doları/ay)
Tünel	`scripts/gemma_tunnel.sh start` / `stop` / `status`
Kaldır	`scripts/teardown_gemma.sh`
Komutları prova etme	`scripts/setup_gemma.sh --dry-run`

Depo düzeni

app/                the arena app, as built so far (see "The app, one stage at a time")
  main.py           the server, the "You fight" mode, and the plugin loader
  engine.py         the rules and the ogre's moves, the one copy
  sigil.py          spell cards: a color and three shapes, judged and drawn (a tiny PNG rasteriser)
  static/           the page: HP bars, the telegraph and timer, the spell card; modes/ holds plugins
  static/sounds/    bgm.mp3 plus optional effects: fight, ogre-attack, block, strike, hurt, charge,
                    cast, fizzle, ready, ko, timeup (.mp3). A missing file is silent. Add them in stages/03-you-fight/.
  reflex.py         step 5: the three questions and choose()
  mode_model.py     step 5: the server side of "Discriminative model fights"
  mode_workflow.py  step 6: the server side of "Workflow fights"           
branches/           step 6b's exercises: each branch as a workflow of its own, nothing from the arena
  slow_branch.py    Gemini reads spell_card.png and is checked against spell_card.json
  fast_branch.py    the Discriminative model decides on a list of moves, in a loop
starter/            Reset restores from here
server/             The workbench

3. Özet

Ortamınızı temizleme

Çalıştayı tamamladığınızda, DiffusionGemma GPU kaynaklarını kapatmak, arka plandaki iş istasyonu ve prova işlemlerini durdurmak, çalıştay dosyalarını Cloud Shell'den kaldırmak ve (isteğe bağlı olarak) çalıştay Google Cloud projenizi silmek için aşağıdaki adımları uygulayın.

DiffusionGemma GPU VM'sini ve güvenlik duvarı kuralını (oluşturulduysa) silin: 2. adımda DiffusionGemma'yı bir Compute Engine GPU VM'sinde sağladıysanız devam eden işlem veya disk depolama ücreti alınmaması için VM'yi, diski ve IAP güvenlik duvarı kuralını kaldırın:
```
cd ~/discriminative-models-workshop
./scripts/teardown_gemma.sh
```
Cloud Shell'de iş istasyonu ve prova işlemlerini durdurma: Cloud Shell terminalinizde arka plandaki iş istasyonu sunucusunu ve prova için kullanılan tüm işlemleri durdurun:
```
cd ~/discriminative-models-workshop
./scripts/stop.sh
./scripts/rehearsal.sh stop 2>/dev/null || true
```
Çalıştay klasörünü Cloud Shell'den silin: Ana dizininize dönün ve klonlanmış depo klasörünü ile proje kimliği dosyasını kaldırın:
```
cd ~
rm -rf ~/discriminative-models-workshop ~/project_id.txt
```
Google Cloud projenizi silme: ./setup_project.sh özel bir atölye projesi oluşturduysa (örneğin, discrim-models-XXXX), projeyi kapatmak projenin içinde oluşturulan tüm kaynakları kalıcı olarak silerken Cloud faturalandırma hesabınızı olduğu gibi bırakır:
- Google Cloud Console'da Kaynakları yönet sayfasını açın.
- Kaynak listesinden atölye projenizi (örneğin, discrim-models-...) seçin.
- Üst araç çubuğunda Sil'i tıklayın, onaylamak için proje kimliğinizi girin ve Kapat'ı tıklayın.

Bu atölyeyi tamamladınız.

Laboratuvar özeti

Compute Engine GPU VM'de ayırt edici bir model (Jev veya DiffusionGemma) seçip yanıt verdiğini doğruladıysanız.
Kurallarını öğrenmek için arenayı elle ve zamana karşı oynadım.
Ayırt edici bir modelin Choice, Score ve Noul sorularını olasılıklar ve güvenle nasıl yanıtladığını ve kodunuzun bunlara nasıl eşikler uyguladığını öğrendiniz.
İlk isteğinizi gönderin, ardından modelin choose() ile yanıtlarını eylemlere dönüştürerek arenadaki her hareketi seçmesine izin verin.
Gemini'ın bir büyü kartı resmini okuduğu ve modelin döngü içinde karar verdiği bir ADK iş akışının her dalını ayrı ayrı oluşturun.
Durum paylaşan tek bir iş akışında birleştirildi. Böylece, dövüş için Gemini'ı beklemek gerekmiyor ve büyü açılışta yapılıyor.

Görüşmeden kararlara

Ayırt edici modeller Workbench'teki atölye çalışmasına genel bakış

Üretken yapay zeka, sohbet ve içerik üretimi yoluyla çoğu ekibe ulaştı. Bir sonraki aşama, ürünler ve işlem hatları içinde yapay zekanın kullanıldığı aşamadır. Bu aşamada modelin çıkışı doğrudan bir işlemi tetikler: destek kaydını yönlendirme, işlemi işaretleme, riskli isteği incelemeye alma, bir aracının araç çağrısına izin verme veya bu çağrıyı engelleme, oyunda hamle seçme.

Bu kararlar, sohbetin karşılamadığı üç koşulu karşılar:

Gecikme. Yanıt genellikle kullanıcının istek yolunda veya gerçek zamanlı bir döngüde yer alır. Bu nedenle, saniyeler içinde değil, milisaniyeler içinde gelmesi gerekir.
Yapı Arayan kod olduğundan yanıt, ayrıştırması gereken bir paragraf değil, üzerinde işlem yapabileceği bir değer olmalıdır.
Öngörülebilirlik. Her kararın, kodun kontrol edebileceği bir güvene ve her etkinlikte sorulabilecek kadar düşük bir maliyete ihtiyacı vardır.

Dil modeli, metni her seferinde bir jeton olacak şekilde üretir. Evet veya hayır yanıtı vermeye yönlendirilebilir ancak gerçek zamanlı döngü için yavaştır, çıktısının ayrıştırılması gerekir ve ne kadar emin olduğunu bildirmez.

Karar alma için tasarlanmış modeller

Ayırt edici bir model, yazılan bir soruyu tek geçişte izin verilen her seçenek için bir olasılıkla yanıtlar. Metin oluşturmaz. Bu atölye çalışması iki seçenek sunar:

Model	Sağlayıcı	Bu atölye çalışmasında modelin çalıştığı yer
Jev	TypeSafe AI	API anahtarıyla çağrılan TypeSafe'in barındırılan hizmeti
DiffusionGemma	Google, açık ağırlık	Kendi Google Cloud projenizdeki bir GPU sanal makinesinde kendi bünyesinde barındırılan

Modeller, ihtiyaçlarınıza göre değiştirilebilir. Bunlara bağlanan kodun değiştirilmesi gerekmez.

Bileşenleri birleştirme

Başarılı bir sistem birden fazla bileşenden oluşur:

Bileşen	Rol	Bu atölye çalışmasında
İş akışı	Adımları düzenler, dalları paralel olarak çalıştırır, paylaşılan durumu tutar.	ADK grafik iş akışı
Deterministik kod	Kurallar, eşikler, doğrulama. Anında, ücretsiz ve denetlenebilir	Oyun kuralları, `choose()` ve yazım denetimi
Ayırt edici model (Discriminative model)	Güven puanıyla hızlı ve sınırlı kararlar	Her tikte bir yanıt seçme
Dil modeli	Algılama ve üretme: Görseller ve açık uçlu metinler	Gemini, büyü kartı resmini okur ve büyüyü yazar.

Model yayınlama mimarisi

Ayırt edici modeller Workbench'teki model sunma mimarisi

Tercihinize ve ortamınıza bağlı olarak 2. adımda modeli seçersiniz. DiffusionGemma'yı kullanmayı planlıyorsanız Google Cloud'da GPU'ya erişiminiz olduğundan emin olun.

	Jev	DiffusionGemma
Sağlayıcı	TypeSafe AI, barındırılan API	Google, açık ağırlık
Çalıştığı cihazlar	TypeSafe'in altyapısı	Projenizde GPU'lu bir Compute Engine sanal makinesi
Uç nokta	`https://api.typesafe.ai`	IAP tüneli üzerinden
Kimlik doğrulama	`TYPESAFE_API_KEY`	IAP tarafından kontrol edilen Google Cloud kimliğiniz
Maliyet	Giriş jetonu başına	Google Cloud'un Compute Engine GPU fiyatlandırması (VM çalışırken)
Ayarlar	API anahtarı	Modeli bir sanal makineye veya Cloud Run'a yükleyin

Veri akışı

Arena uygulaması veya ADK iş akışı bir istek oluşturur: durum (rakibin yaptığı) ve üç soru.
TypeSafe SDK, bunu yapılandırılmış temel URL'ye POST /v1/systemone olarak gönderir.
Jev için istek, taşıyıcı jeton olarak API anahtarıyla birlikte HTTPS üzerinden api.typesafe.ai adresine gider.
DiffusionGemma için istek localhost:8096 adresine gider. Arka planda çalışan bir gcloud compute start-iap-tunnel işlem, Google kimliğinizi kontrol eden Identity-Aware Proxy üzerinden sanal makinedeki 8080 numaralı bağlantı noktasına yönlendirir.
Sanal makinede djev-run, isteği alır, GPU'da vLLM aracılığıyla DiffusionGemma'yı çalıştırır ve izin verilen her seçeneğin olasılığını okur.
Her iki arka uç da aynı yanıtı döndürür: Her soru için olasılıklar ve güven puanı içeren bir yanıt. Atölye kodu, eşiklerini uygular ve harekete geçer.

Compute Engine'de DiffusionGemma

scripts/setup_gemma.sh, projenizde şunları oluşturur:

Bölgede GPU kotası olup olmadığını kontrol eder.
Compute Engine ve IAP API'lerini etkinleştirir ve allow-iap-djev güvenlik duvarı kuralını oluşturur. Yalnızca 22 ve 8080 bağlantı noktalarında IAP adres aralığına izin verir.
Sanal makineyi oluşturur djev-l4: makine türü g2-standard-4 (4 vCPU, 16 GB bellek), 24 GB'lık bir GPU, 100 GB'lık bir disk ve NVIDIA sürücüsü 580'i içeren Deep Learning VM görüntüsü. Bir bölgede GPU kapasitesi yoksa sonraki bölge denenir.
İlk başlatmada, VM'nin başlangıç komut dosyası Docker ve NVIDIA Container Toolkit'i yükler, djev-run kapsayıcı görüntüsünü çeker, ağırlıkları Hugging Face'ten indirir (17,5 GB) ve kapsayıcıyı 8080 numaralı bağlantı noktasında GPU erişimiyle başlatır. Bu işlem yaklaşık 15 dakika sürer. Sonraki başlatma işlemleri yaklaşık 2 dakika sürer.
Bağlantı ayarlarını .env hizmetine yazar ve tüneli açar.

Görev	Komut
Sanal makineyi durdurma (diski korur)	`scripts/gemma_warm.sh off`
Tekrar başlatın	`scripts/gemma_warm.sh on`
Tüneli kontrol edin	`scripts/gemma_tunnel.sh status`
Her şeyi silme	`scripts/teardown_gemma.sh`

Modeli ayarlama

Ayırt edici modeller Workbench'inde modeli ayarlama

TypeSafe SDK

İstemci kitaplığı, Python için typesafe-sdk'dır. Bu atölyede zaten var: 6. adım için google-adk ile birlikte tezgahın kendi ortamına yüklenir.

pip install typesafe-sdk        # or: uv add typesafe-sdk

Jev uç noktası

Jev modeli, barındırılan bir API olduğundan başka bir şey indirmeniz gerekmez. Anahtar almak için TypeSafe konsolunda kaydolun. SDK, anahtarı TYPESAFE_API_KEY ortam değişkeninde arar. Bu atölyenin komut dosyaları da kökteki bir .env dosyasını okur. Bu nedenle, tek bir satır yeterlidir:

TYPESAFE_API_KEY=ts-...

DiffusionGemma'yı kullanma

djev-run, Ayırt Edici modelin API'sini yeniden uygular. Google DeepMind'ın açık difüzyon modeli olan DiffusionGemma'dan (toplam 26 milyar parametre, yaklaşık 4 milyar etkin, Apache 2.0) aynı POST /v1/systemone uç noktasına aynı noul, seçim ve puan sorularıyla hizmet verir. Kablolu biçim aynı olduğundan TypeSafe SDK, bu biçimle değişmeden iletişim kurar.

Egzersizde DiffusionGemma'yı seçerseniz bu model, kendi Google Cloud projenizdeki bir VM'de GPU üzerinde çalışır ve sağ üstteki kapsülde gemma on vm (VM'de Gemma) ifadesi yer alır. Çalışma tezgahı, özel bir IAP tüneli üzerinden modele ulaşır ve modelin bağlantı noktası internete açık değildir. 1. adımda tam mimari açıklanmaktadır.

Neden bir dağıtım modeli bunu yapabilir? Bir konum bloğunun tamamını tek seferde doldurur. Her konumda girişin tamamı görüldüğünden, izin verilen her seçeneğin olasılığı tek bir adımda okunabilir. Normal bir dil modeli, her seferinde bir jeton üretir ve tekrar tekrar örneklenmesi gerekir.

Oyunu manuel olarak oynama

Oyunu Ayırt Edici Modeller Workbench'te manuel olarak oynayın

Arena, en küçük dövüş oyunudur ancak bu, kolay olduğu anlamına gelmez: Hızlı ve akıllı olmanız gerekir. Bir dev size doğru geliyor. Çok sayıda saldırı türü vardır ve her birinden önce ince bir hareket (telegraf) yapar: sopayı kaldırır, saldırıya hazırlanır, gardı açık bir şekilde sendeler. Dövüşçü olarak, rakibinizin hareketine beş farklı hareketle yanıt verebilirsiniz: yüksek blok, alçak blok, kaçınma, saldırı, bekleme. Bu oyun, sıranızı beklemez. Dev saldırmadan önce yanıt vermek için iki saniyeniz var. Zamanlayıcı süresi dolarsa hiçbir şey yapmamış olursunuz ve bu durumdan çok pişman olursunuz.

Halkanın sol üst köşesinde hece kartı bulunur: Üç şeklin yer aldığı renkli bir kart. Yalnızca bu büyüyle eşleşen büyüler gerçek hasar verir. Oyunda, dövüşün altındaki düğmeleri kullanarak büyü yapabilirsiniz: Kartın rengini, ardından şekillerini soldan sağa doğru seçin ve BÜYÜ YAP'a basın. Seçim yaparken süre devam eder. Bu nedenle, hem büyüyü oluşturmanız hem de devin saldırılarına aynı anda tepki vermeniz gerekir. 1-5 arasındaki tuşlar her hareketi yanıtlamaya devam eder. Yanlış bir büyü başarısız olur. 6. adımda Gemini, büyü kartını sizin için okur.

Önemli nokta: Dövüş, her birinde son tarih olan küçük kararların akışıdır. Çoğu yazılım otomasyonu, kulüp hariç aslında böyle görünür.

Ayırt edici model kavramları

Ayırt edici Modeller Workbench'teki ayırt edici model kavramları

Yazılımdaki kararlar

Dil modelleri, yıllardır sohbet konusunda başarılıdır. Çoğu yazılım, otomatik işlemler için bunları hâlâ kullanmıyor ve bunun nedeni zeka değil. Hızdır.

Bir dil modeline önünüzdeki devin saldırmak üzere olup olmadığını sorduğunuzda model, yanıtını her seferinde bir jeton yazarak verir. Paragraf geldiğinde kulüp yere inmişti. Bunun iki saniyelik versiyonunu 3. adımda hissettiniz. Bu durumda bile "evet" yanıtı, kodunuzun bulup güvenmesi gereken bir paragrafta yer alır ve modelin ne kadar emin olduğu bilinmez.

Ayırt edici model, durumu ve yazdığınız soruları ve yanıtları tek geçişte milisaniyeler içinde alır. Her yanıtın kalibre edilmiş bir olasılığı vardır: 0,9, on kezden dokuzunda doğru olduğu anlamına gelir. Ayrıştırılacak metin ve bu metinden çıkarılacak JSON yok.

Sistem 1 ve Sistem 2 modelleri

Bu ad, Daniel Kahneman'ın Hızlı ve Yavaş Düşünme adlı kitabından alınmıştır. Sistem 2, yavaş ve kasıtlı bir şekilde, adım adım akıl yürütme yapar. System One hızlıdır ve kalıp eşleştirme yapar.

Dil modeli, Sistem 2 makinesidir. Her seferinde bir jetonla akıl yürütür. Ayırt edici model bir Sistem 1 modelidir: Yüksek sesle akıl yürütmez, hiçbir şey üretmez ve her soruyu tek seferde yanıtlar. Bu nedenle hızlı (yaklaşık 70 ila 500 milisaniye) ve ucuzdur (bin karar için bir sentin kesirleri).

Önemli nokta: Dil modeli yazar. Kararı bir karar modeli verir. Yazılımların yapay zekadan en çok beklediği şey karardır.

Sınırlamalar

Ayırt edici model; metin oluşturmaz, kod yazmaz, sohbet etmez, aritmetik işlemler yapmaz, resim okumaz veya bir dizi adımı takip etmez.

Çalıştayda, ayırt edici modellerden birini seçeceğiz:

Ayırt edici modellerden biri Jev'dir. Bu API, TypeSafe AI tarafından barındırılan ve Eylül 2026'da yayınlanan bir API'dir. İlk model, jev-latest takma adıyla ulaşılan jev-1.13 modelidir. Yayınlanmış ağırlıklar olmadığından indirilmez, çağrılır.
Jev, System One modelini edinmenin tek yolu değildir. Google'ın DiffusionGemma'sı, her seferinde bir jeton yazmak yerine jetonların tamamını paralel olarak yazan ve aynı paralel geçişin, sabit bir seçenek grubu üzerinden olasılıkları okuyabildiği açık ağırlıklı bir modeldir. djev-run gibi açık kaynaklı sunucular, Jev'in tam API'sini önüne koyar. Bu nedenle, bu atölyedeki her şey üzerinde değişiklik yapılmadan bu API'ye karşı çalışır.

Durum ve sorular: `Choice`, `Score` ve `Noul`

Her çağrı, durumu ve soruları gönderir. Durum, değerlendirilmesini istediğiniz metindir. Dize, JSON nesnesi veya liste olabilir. Sorular, metin hakkında ne öğrenmek istediğinizi sorar. Her sorunun bir türü vardır: Seçim, Puan veya Noul. Sorular paralel olarak işlendiği için hızlı yanıt verebilir. Gerekirse birden fazla soru ekleyebilirsiniz.

Seçim, adlandırdığınız bir gruptan 255'e kadar seçenek arasından birini belirler. Yanıt; seçenek, her seçenek için olasılık ve güven düzeyidir. Seçenekler arasında bir sıralama olmadığında kullanın: yüksek blok, alçak blok, kaçınma, vuruş, bekleme.
Puan, durumu iki ila on arasında olmak üzere, tanımladığınız sıralı düzeylere göre değerlendirir. Yanıt; ölçekteki bir konum (ondalık sayı, yani 1, 4 "bir ile iki arasında, bire daha yakın" anlamına gelir), her seviyenin olasılığı ve güven düzeyidir. Bu özelliği, gelen vuruşun ne kadar sert olacağı gibi dereceyle ilgili cevaplarda kullanın.
- Choice ve Score işlevleri, her seçenek için bir olasılık ve güven düzeyi döndürür. Fark, asıl yanıttır. SEÇİM, en olası seçeneği döndürür. Puan, seçenekleri sıralı seviyeler olarak değerlendirir ve olasılık ağırlıklı ortalamalarını döndürür. Bu ortalama iki seviye arasında olabilir. Hiçbiri 0,05, hafif 0,55 ve ağır 0,40 olduğunda, bir Seçim "hafif" yanıtını verir ve bir Puan, hafif ile ağır arasında 1,35 yanıtını verir. Arena bu değeri kullanır: choose(), 1,5 veya daha yüksek tehlike puanını ağır darbe olarak değerlendirir.
Noul, evet/hayır sorusu sorar ve yanıtın evet olma olasılığını döndürür. 1'e yakınlık güçlü bir "evet", 0'a yakınlık güçlü bir "hayır", 0,5'e yakınlık ise "olabilir" anlamına gelir. Olasılık, güven düzeyini ifade ettiğinden ayrı bir güven düzeyi yoktur.

Odaklanmış sorular yazma

Ayırt edici model, soruda belirli ve iyi tanımlanmış bir şey istendiğinde en iyi sonucu verir. "Durum nedir?" sorusuna olası ancak düşük güvenilirlikte bir yanıt veriliyor. "Doğru yanıt nedir?", "Rakip açıkta mı?" ve "Bu vuruş ne kadar sert olacak?" soruları, kodunuzun birleştirdiği üç odaklanmış yanıt döndürür.

Seçenekler ve seviyelerle ilgili açıklamalar ucuzdur ve önemlidir. 3. adımda okuduğunuz kurallar, seçenek açıklamaları haline gelir: block_high: "Raise the shield. Right against an overhead or a high swing." Ayrımcı model, istek sırasında dövüş kurallarını bu şekilde öğrenir. Seçenekler duruma göre değişebilir: Arena, yalnızca bir büyü hazır olduğunda cast seçeneğini sunar.

Olasılıklar ve güven

Seçmeli yanıt, etiket değildir. Bu, etiketler üzerindeki bir dağılımdır ve etiket yalnızca en uzun çubuktur.

Model, numarayı nasıl alır? Bir dil modelinin bir sonraki kelimeyi seçmek için kullandığı adımı kullanır. Bir dönüştürücü, metni okur ve bir konumda, kelime dağarcığındaki her jetona logit adı verilen ham bir puan verir. Logit değeri ne kadar yüksek olursa jeton o konuma o kadar iyi uyar. softmax, logitleri 1'e kadar olan olasılıklara dönüştürür. Ardından bir dil modeli bir jeton seçer, bunu metne ekler ve işlemi tekrarlar. Ayırt edici model, olasılıklardan sonra durur.

Boşluk, yanıt formundaki bir boşluğu ifade eder. Sunucu, formun kendisini (ör. response: ▢) yazar ve her soru için bir boşluk bırakır. Modelin tek görevi, her boşluğa neyin ait olduğunu puanlamaktır.

İstem, durumu ve her soruyu kısa bir etiket olarak tutar. İzin verilen her yanıt için bir etiket kullanılır: block_high için a, block_low için b vb.
Sunucu, soru başına bir boşluk olacak şekilde yanıt formunu ekler.
Model, istemi ve formu tek geçişte okur ve her boşlukta her jetona bir logit verir. Difüzyon modeli, formun tamamını aynı anda görür ve tüm boşlukları birlikte puanlandırır.
Sunucu yalnızca izin verilen etiketlerin logitlerini tutar ve bunlara softmax uygular. Bu nedenle, izin verilen yanıtların toplamı 1 olur.
Okuma işlemi kesin değilse sunucu, başka bir rastgele başlangıçtan tekrar okur ve okumaların ortalamasını alır.

Güven, yanıtın ne kadar doğru olduğundan emin olunduğunu gösteren bir sayıdır. TypeSafe, olasılığın seçeneklere nasıl dağıldığına göre bu değeri hesaplar. Tümünün tek bir seçenekte olması 1, eşit dağılım ise 0 puan verir. Üç seçenek için (3 × en büyük − 1) / 2'dir.

TypeSafe, Jev'i kalibre edilmiş olasılıklar için eğitir. Olasılık, yanıtın ne sıklıkta doğru olduğunu gösterir. Kalibre edilmiş bir modelde, 0,7 güven düzeyinde verilen yanıtlar yaklaşık% 70 oranında doğrudur.Bu nedenle, güven eşiği, yanlış bir yanıtı ne sıklıkta kabul edeceğinizle ilgili bir eşiktir. Bu atölyedeki DiffusionGemma sunucusu, okumaları üzerinden ortalama alınarak en yüksek olasılığı güven olarak bildirir. Okumalar uyuşmadığında ortalama yayılır ve güven düşer.

Önemli nokta: Yanıt, ne olduğunu söyler. Güven düzeyi, işlem yapıp yapmamanız gerektiğini gösterir.

Eşikler

Eşik, kodda işlemi nasıl tanımladığınızı gösterir. Model, güven veya olasılık döndürür. Kodunuz, seçtiğiniz bir sayıyla karşılaştırılır ve sonuç, ne olacağını belirler.

İşlem başına bir eşik. TypeSafe, güveni bantlara bölmeyi önerir. Yüksek güvene sahip işlemler kendi başına yapılır. Orta düzeyde güvenle yapılan işlemler (ör. onay isteme veya durumu incelemeye gönderme) Düşük güven düzeyinde hareket edilmez ve güvenli bir şeye veya kişiye geri dönülür.

TRUST = 0.40        # below this, the answer is a guess
AUTO = 0.80         # at or above this, act without a check

def route(answer):
    if answer.confidence >= AUTO:
        return act(answer.choice)          # high: act on its own
    if answer.confidence >= TRUST:
        return confirm(answer.choice)      # medium: act with a check
    return fall_back()                     # low: do something safe

Arenanın kuralları. Arenanın eşikleri, 5. adımda çalıştırdığınız choose() içinde yer alır.

TRUST_CONFIDENCE = 0.40    # below this, the model is guessing between responses
HEAVY_DANGER = 1.5         # a danger score at or above this is a heavy hit
SPEND_ON_OPENING = 0.60    # exposed at or above this, with a spell ready, cast

def choose(answers, spell_ready):
    response = answers["response"]
    exposed = answers["exposed"].noul
    danger = answers["danger"].score

    action = response.choice
    if response.confidence < TRUST_CONFIDENCE and danger >= HEAVY_DANGER:
        action = "dodge"                   # shaky answer, heavy hit coming
    if spell_ready and action == "strike" and exposed >= SPEND_ON_OPENING:
        action = "cast"                    # a clear opening is worth the spell
    return action

Uyarı: Geçerli bir yanıt her zaman doğru olmayabilir. Ayırt edici model, sunmadığınız bir seçeneği döndüremez. Bu nedenle, hiçbir zaman halüsinasyon görmez ancak bazen yanlış seçeneği yüksek güvenle seçebilir. Bir eşiğe güvenmeden önce sorularınızı daha önce değerlendirdiğiniz durumlarla karşılaştırarak test edin.

Modelle kararları otomatikleştirme

Ayırt Edici Modeller Çalışma Tezgahı'ndaki modelle kararları otomatikleştirme

İstek ve yanıt

İstek. TypeSafe Python SDK, sorular oluşturup bunları modele göndermenize olanak tanır.

from typesafe_sdk import Choice, Noul, TypeSafeClient

with TypeSafeClient() as client:
    response = client.system_one(
        state={"opponent": OPPONENT, "telegraph": telegraph},
        questions={
            "response": Choice(instructions="What is the right response?", criteria=RESPONSES),
            "exposed": Noul(instructions="Is the opponent exposed to a counter-attack right now?"),
        },
    )

response.choices["response"].choice     # "strike"
response.nouls["exposed"].noul          # 0.97

Her işaret için bir istek

Uygulama, her tikte telgrafı durum olarak gönderir ve tek bir aramada üç şey ister:

Beş (veya büyü hazır olduğunda altı) yanıttan hangisi doğru? Bir Seçim.
Şu anda ogre'nin bir sayaçla karşı karşıya olup olmadığı. A Noul.
Üç seviyeli bir puan anahtarında gelen vuruşun ne kadar sert olduğu. Bir skor.

def reflex_questions(spell_ready):
    options = dict(RESPONSES)
    if spell_ready:
        options["cast"] = CAST                # only offered when there is a spell
    return {
        "response": Choice(instructions="The opponent has just done this. What is the right response?",
                           criteria=options),
        "exposed": Noul(instructions="Is the opponent exposed to a counter-attack right now?"),
        "danger": Score(instructions="How much damage is about to land if the fighter does nothing?",
                        criteria=["None: this is not an attack.", "A light hit.", "A heavy hit."]),
    }

`choose()` işlevi

4. adımdaki eşikleri hatırlıyor musunuz? choose(), modelin yanıtlarını sabit sayılarla karşılaştırır. Bu sabit sayılar eşiklerdir.

TRUST_CONFIDENCE = 0.40
HEAVY_DANGER = 1.5
SPEND_ON_OPENING = 0.60

def choose(answers, spell_ready):
    action = answers["response"].choice
    if answers["response"].confidence < TRUST_CONFIDENCE and answers["danger"].score >= HEAVY_DANGER:
        action = "dodge"                      # shaky call, heavy hit coming: play it safe
    if spell_ready and action == "strike" and answers["exposed"].noul >= SPEND_ON_OPENING:
        action = "cast"                       # the Discriminative model saw the opening; the code spends the spell
    ...

choose(), iki kuralı olan, yazılan değerleri okuyan normal bir Python'dur. Ayırt edici model, olasılığını ve analizini sağlar. Kod ise kuralların eşiklerini kullanır. Seçilen işlem, arama motoruna gönderilir ve burada devle savaşmak için kullanılır.

Önemli nokta: Soruları ve eşikleri tek bir yerde tutun. Bunlar, System One entegrasyonunun en çok ayarlayacağınız parçasıdır.

Yanıt süresi, girişe dayalı fiyatlandırma ve karar mantığı

Karar başına yanıt süresi. b bölümündeki her dövüş yaklaşık yüz milisaniyede, bazıları ise iki veya üç milisaniyede geri geldi. Bu hız, oyun döngüsü, istek yolu veya bir kişi ya da dil modeli görmeden önce her mesajın kontrol edilmesi için yeterlidir.
Girişe dayalı fiyatlandırma. Üçer sorudan oluşan altmış kararlık bir dövüşün tamamı bir sentin onda birinden daha az maliyetlidir. Hiçbir şey oluşturulmadığı için çıkış jetonları sıfırdır. Sonuç olarak, ihtiyacınız olandan daha fazlasını isteyebilirsiniz. Arena, yalnızca strike ve cast ilgilenmesine rağmen, sormak neredeyse ücretsiz olduğu ve yanıt kontrol panelinde faydalı olduğu için her tikte devin açığa çıkıp çıkmadığını soruyor. TypeSafe buna speculative fan-out (tahmini dağıtım) adını veriyor.
Kendine güven ve tehlikeyi birleştir. Ayırt edici modelin yanıtına güveni 0,40'ın altında olduğunda ve tehlike puanı büyük bir darbe geleceğini gösterdiğinde choose(), bunu bir kaçınma ile geçersiz kılar. Kaçamak, nadiren en iyi yanıt olsa da nadiren en kötü yanıttır. Eşikleri yuvarlak bir sayıdan değil, her hatanın maliyetinden seçin ve bunları daha önce elle değerlendirdiğiniz telgraflara göre test edin. TypeSafe'in kendi tavsiyesi: Bir karar sürekli olarak yanlış sonuç veriyorsa eşiği değiştirmeden önce soruyu daraltın.

ADK iş akışında modelleri birleştirme

Ayırt Edici Modeller Workbench'teki bir ADK iş akışında modelleri birleştirme

Her tik için karar verme sınırları ve doğru yanıtların neden yeterli olmadığı

5. adımdaki dövüşün son satırında şöyle yazıyor: Dev, neredeyse hiç çizilmeden ağır ağır uzaklaşıyor. Ayırt edici model hasar almadı ve her tikte biraz hasar verdi. 300 can puanı, altmış katından biraz daha fazladır. Ringin köşesindeki büyü kartı başından beri oradaydı. Bunu okumak için görüntüyü görebilen bir model gerekir.

Devin 300 can puanı var. Doğru bir arama 3 kez sayılır. Kalın olduğu için bir açıklığa yapılan vuruş 8 puan kazandırır. Mükemmel bir altmış vuruşluk dövüşte bile dev morluklar içinde ayakta kalıyor ve oyun berabere bitiyor. 5. adımda model iyi savunma yapmasına rağmen kazanamadı.

Yalnızca büyü gerçek hasar verir: Mükemmel bir büyü 45, bir açıklığa isabet eden büyü 67 hasar verir.

Her görevi doğru modele atayın.

Halkanın köşesindeki büyü kartı kazanmanın yoludur ve bu kartı okumak metin sorunu değildir: Renkli ve arka arkaya üç şekil içeren bir resimdir ve büyü, bu şekillere uyacak şekilde söylenmelidir. Bunun için bir resme bakıp birkaç saniye düşünebilen bir model gerekir. Kavgada birkaç saniye on tik eder.

Bu nedenle iş akışında her ikisi de kendi hızında kullanılır:

Ayırt edici model kavga ediyor. Her tik, bir arama, bir karar, yüz milisaniye. Döngü, kendisinden daha yavaş hiçbir şeyi beklemez.
Gemini okur ve şarkı söyler. Kendi dalında, zilin çalmasıyla başlayan bu işlem, arenanın ekranındaki büyü kartını resim olarak alır, renk ve şekilleri adlandırır ve bir büyü sözü söyler. Arena, şarkıyı sunucudan hiç ayrılmayan büyü kartının yanıtına göre değerlendirir.
Her değişimin ardından dövüşçü, yuvanın durumunu kontrol eder. Bir check_spell düğümü duruma bakar. Hazır değil: Gemini'ın ne kadar süredir şarkı söylediği belirtiliyor ve doğrudan bir sonraki tik işaretine yönlendiriliyor. Hiç beklemez. Hazır: cast, Ayırt Edici modelin sunulduğu seçeneklere katılır ve Ayırt Edici model bir açılış bildirdiği anda choose(), büyüyü harcar. Büyü bittiğinde ekranda yeni bir büyü kartı çizilir ve yavaş iplik tekrar başlar. Yanlış okunan şarkı, büyü kartını yakar ve yavaş iplik yenisini okur.
Gemini, kısa bir hikayeyi sonunda bir kez yazar.

Tek bir ADK grafiğinde iki hız

Farklı gecikme sürelerine sahip paralel dallar ve tek bir etkinlik döngüsü

Bu, kenarlarla birleştirilmiş düğümlerden oluşan bir grafik olan ADK iş akışıdır. Düğüm, düz bir Python işlevi veya LLM aracısıdır. Bir düğümden bir düğüm demetine giden kenar, fan-out'tur: Her ikisi de eşzamanlı olarak başlar. Event döndüren bir düğüm, route ile bir sonraki kenarın hangisi olacağını seçer ve kendisiyle yönlendirilen bir düğüm döngü oluşturur.

Bunu iki iş parçacığı olarak düşünebilirsiniz. 1. İplik yavaş: Yazı kartını okuyun, şarkı söyleyin, yazıyı saklayın. 2. iş parçacığı hızlıdır: tik, yuva kontrolü, tekrar tik. 1. iş parçacığı, değerlendirilen yazımı oturum durumuna yazan ve çıkış döndürmeyen bir işlevle sona erer. 2. iş parçacığının check_spell, her değişimden sonra bu durumu okuduğu varsayılır. İş parçacıklarından hiçbiri diğerini çağırmaz veya beklemez, yalnızca durumu paylaşırlar.

Önemli nokta: Kararları koda yerleştirin ve her modele kendi hızında dar bir görev verin.

ADK, her iki dalı da tek bir ileti dizisinde, tek bir etkinlik döngüsündeki görevler olarak çalıştırır. Tek seferde yalnızca bir görev çalıştırılır. Bir görev await'ya ulaştığında yanıtını bekler ve bu sırada döngü diğer dalı çalıştırır. Hızlı dal, modelin yanıt vermesi için yaklaşık 0,1 saniye bekler. Yavaş dal ise Gemini'ın yanıt vermesi için birkaç saniye bekler. Bu nedenle, dallar birbirini engellemez.

Yavaş dal

read_rune(), büyü kartını ekrandan resim olarak kaldırır.

def read_rune(ctx: Context, node_input) -> Event:
    png = _arena(ctx).rune_png()                  # exactly what the screen shows
    return Event(output=types.Content(role="user", parts=[
        types.Part(text="This spell card is on the arena's screen right now. Sing the spell that matches it."),
        types.Part.from_bytes(data=png, mime_type="image/png"),
    ]))

spellwright, Gemini'dır. Resmi okur ve sabit bir şekilde yanıt verir.

class Sung(BaseModel):
    element: str          # fire, frost, earth, storm
    glyphs: list[str]     # three of: circle, ring, square, diamond, triangle, cross, crescent, bar
    incantation: str

spellwright = LlmAgent(name="spellwright", model="gemini-flash-latest",
                       instruction="You are the spellwright ... read the three shapes left to right ...",
                       output_schema=Sung)

spell_ready(), büyünün arenada değerlendirilmesini sağlar, ardından büyüyü saklar veya tekrar dener.

def spell_ready(ctx: Context, node_input: dict) -> Event:
    spell = _arena(ctx).sung(dict(node_input))    # the arena judges it against the spell card
    return Event(state={"spell": spell if spell["damage"] > 0 else None},
                 route="retry" if spell["damage"] <= 0 else "stored")

Bir işlev düğümü, resim bölümü içeren bir Content döndürebilir ve LLM düğümü bunu kullanıcı dönüşü olarak alır. spell_ready, durum farkı içeren ve output içermeyen bir Event döndürür. Bir sonraki tik, durumu okur ve çıkışı olmayan bir dal, grafiğin ikinci sonu değildir: ADK, bir terminal çıkışı gerektirir ve bu da dövüşün çıkışıdır.

Not: Yargılama, arenada, büyü kartının gizli yanıtına karşı kodla yapılır. Mükemmel bir okuma, 45 daha fazla açılış yapar. İki şekil sağa 25 yapar. Yanlış okuma, büyü kartının etkisini söndürür. Gemini'a doğru olup olmadığı sorulmaz.

Fast branch

tick() bir değişim oynatır, ardından bir sonraki kenarı seçer.

async def tick(ctx: Context, node_input) -> Event:
    arena = _arena(ctx)
    spell = ctx.state.get("spell")                # did the slow branch deliver?
    move = await asyncio.to_thread(arena.telegraph)

    async with AsyncTypeSafeClient() as jev:
        answers = await jev.system_one(
            state={"opponent": engine.OPPONENT["description"], "telegraph": move["telegraph"]},
            questions=reflex.reflex_questions(spell_ready=spell is not None),
        )

    decision = reflex.choose(answers.answers, spell_ready=spell is not None)
    entry = await asyncio.to_thread(arena.respond, decision["action"], decision, ...)
    over = entry["you"] <= 0 or entry["foe"] <= 0 or entry["tick"] >= engine.MAX_TICKS

    routes = []                                   # which arrows in the graph to follow next
    if entry["spell_used"] and not over:
        routes.append("recast")                   # a new spell card is on the screen: read it
    routes.append("done" if over else "next")
    return Event(output="fight", route=routes, state={"tick": ..., "spell": None, ...})

check_spell(), her değişimden sonra büyü yuvasına bakar.

def check_spell(ctx: Context, node_input) -> Event:
    spell = ctx.state.get("spell")                # thread 1 writes it; this only reads
    if spell:
        report = {"ready": True}
    else:
        report = {"ready": False, "waited": now - ctx.state["forging_since"]}
    return Event(output="fight", route="again", state={"spell_check": report})

check_spell, her değişimden sonra yuvaya bakar. Hiçbir zaman engellemez: Yazım denetimi hazır değilse bunu bildirir ve devam eder.

Tasarımı üç şey taşıyor. Ayırt edici model çağrısı, eş zamansız istemciyle awaited olduğundan döngü beklerken sonuç verir ve Gemini dalı çalışmaya devam eder. Sorular her tikte yeniden oluşturulur. Bu nedenle cast yalnızca yayınlanacak bir içerik olduğunda görünür. route bir liste olabilir: ["recast", "next"] her iki kenarı da aynı anda alır.

Arenanın kendisi küçük bir istemcinin arkasındadır: varsa HTTP üzerinden çalışan uygulama, böylece sayfa maçı gösterir; yoksa işlem içi motor.

Grafik tanımı

root_agent = Workflow(
    name="arena",
    edges=[
        ("START", enter),
        (enter, (read_rune, tick)),                   # fan-out: slow branch + fast loop
        (read_rune, spellwright, spell_ready),
        (spell_ready, {"retry": read_rune, "stored": rest}),   # misread: read the new spell card; else rest
        (tick, {"next": check_spell, "recast": read_rune, "done": summarise}),
        (check_spell, {"again": tick}),               # not ready? keep fighting
        (summarise, bard, finish),
    ],
)

Hedef olarak kullanılan demet, fan-out'tur. Kenar olarak kullanılan demet bir zincirdir. Bir sözlük, rota adlarını düğümlerle eşler. tick → check_spell → tick hızlı döngüdür. "recast": read_rune, büyü harcandıktan sonra yavaş iş parçacığını tekrar başlatır. "retry", başarısızlık durumunda aynı işlemi yapar. "stored": rest ise büyü yuvaya yerleştirildikten sonra yavaş iş parçacığının sessizce, çıkış olmadan sona ermesine izin verir. ADK, bir döngüde en az bir yönlendirilmiş kenar gerektirir. Bu nedenle, koşulsuz bir döngü sonsuza kadar çalışmadan önce reddedilir.

Not: ADK'nın araçları root_agent ifadesini arar. adk web agents atölyenin kökünden, grafiği ve etkinlikleri terminal yerine tarayıcıda görmek istiyorsanız geliştirici kullanıcı arayüzünü açar.