En İyi 7 Açık Kaynak TypeSafe Jev Alternatifi

Birçok yapay zekâ uygulaması, aslında metin üretimi gerektirmeyen görevler için büyük dil modellerini kullanıyor. 

Bir aracının yalnızca hangi aracın çağrılacağına, bir belgenin ilgili olup olmadığına, bir talebin ne kadar acil olduğuna veya bir eylemin tırmandırılması gerekip gerekmediğine karar vermesi yeterli olabilir.

TypeSafe AI’nin Jev’i bu görevleri farklı ele alıyor. Yanıtı token token üretmek yerine, uygulama durumunu ve yapılandırılmış soruları alıp seçimler, puanlar, evet/hayır yargıları ve olasılıklar gibi tiplenmiş kararlar döndürüyor. Bunu uygulamada görmek için Jev API eğitimimize bakın

TypeSafe AI bunu Sistem Bir Modeli yaklaşımı olarak tanımlıyor: yapay zekâyı genel amaçlı metin üreticisi yerine hızlı bir karar katmanı olarak kullanmak.

Zorluk şu ki, Jev’in içten içe nasıl çalıştığı hakkında hâlâ nispeten az şey biliyoruz. 

TypeSafe AI paralel karar verme yaklaşımı ve eğitim yöntemi hakkında bazı ayrıntılar paylaştı, ancak tam mimari, model ağırlıkları, eğitim verileri ve eksiksiz eğitim tarifi kamuya açık değil.

Bu da Jev’in kendisini incelemeyi, çoğaltmayı veya uyarlamayı zorlaştırıyor.

Açık kaynak projeler, gerçekten inceleyebileceğimiz ve yerelde çalıştırabileceğimiz mimarilerle aynı fikri araştırıyor. 

Bazıları küçük çift yönlü modeller kullanıyor, bazıları Qwen’i özel karar başlarıyla uyarlıyor, diğerleri ise olasılıkları doğrudan mevcut dil modellerinden çıkarıyor. 

Tüm yığını kontrol ettiğiniz için, kendi iş yükünüz için daha hızlı ve daha ucuz bir karar katmanı oluşturmak üzere model boyutu, quantization, batching, caching, donanım ve servis sunumunu da optimize edebilirsiniz.

Bu blogda, Laya, Nimble, Kev, SemIf, Rizzo Flow, Von ve NanoJev dahil yedi açık kaynak Jev alternatifini karşılaştıracağım; her birinin nasıl çalıştığına, Jev yaklaşımına ne kadar yaklaştığına, nerede öne çıktığına ve yerelde nasıl çalıştırılacağına bakacağım. 

Sorumluluk reddi: Bu rehberde ele alınan projeler çok yeni ve hızla gelişiyor. Kod örnekleri resmi dokümantasyonlarına ve depolarına dayanıyor, ancak tüm örnekler uçtan uca bağımsız olarak test edilmemiş olabilir.

1. Laya: Amaca Yönelik, Çok Dilli Bir Jev Alternatifi

Laya, ModernBERT-large tabanlı, amaca yönelik, oto-regresif olmayan bir karar modeli olup çok dilli iş yükleri için ayrı bir mmBERT kontrol noktasına sahiptir.

 Metin üretmek yerine, durumu, soruyu ve mevcut seçenekleri birlikte işler ve tek bir ileri geçişte olası yanıtları doğrudan puanlar. Jev tarzı choice, score ve noul kararlarını destekler; İngilizce, çok dilli ve tiplenmiş karar iş yükleri için özel kontrol noktaları sunar.

Bu, Laya’yı mimari olarak Jev’e en yakın alternatiflerden biri yapar; çünkü her ikisi de metin üretimi yerine olasılıksal kararlar için özel olarak tasarlanmıştır. 

Laya, nispeten küçük 322M–421M modelleri, 100+ dilde çok dilli desteği ve çok milyar parametreli bir üretim modelini çalıştırmadan birden fazla soruyu verimli biçimde değerlendirme yeteneğiyle öne çıkıyor.

Laya nasıl çalışır

Laya, e-posta, destek talebi, belge veya JSON nesnesi gibi bir durumu, choice, score veya noul gibi tiplenmiş sorularla birlikte alır. 

Yönlendiricisi, istek için en uygun kontrol noktasını seçer; örneğin İngilizce için ModernBERT-large, çok dilli girdi için mmBERT-base. 

Seçilen model, durumu ve soruları tek bir ileri geçişte işler; ardından bir karar başı mevcut seçenekleri puanlar ve bunları olasılıklara dönüştürür. 

Bu, girdiden yönlendirme ve kodlamaya, oradan da nihai tiplenmiş karara uzanan doğrudan bir akış oluşturur.

Laya ile başlarken

Laya bir Python paketi olarak sunuluyor:

pip install layaAltyapı:

Bu komut Laya kütüphanesini ve bağımlılıklarını kurar, ancak model ağırlıkları paketin içine dâhil edilmez.

Modeller Hugging Face üzerinde barındırılmaktadır. 

Yönlendiriciyi preload=True ile oluşturduğunuzda, Laya kullanılabilir kontrol noktalarını ilk istekten önce hazır olmaları için anında indirip yükler. 

İndirilen ağırlıklar yerelde önbelleğe alınır; böylece uygulamanızı her çalıştırdığınızda yeniden indirilmeleri gerekmez.

from laya import Router

router = Router(preload=True)

state = {
    "subject": "Duplicate charge",
    "body": "I was charged twice. Please refund this today."
}

questions = {
    "department": {
        "type": "choice",
        "instructions": "Which department should handle this?",
        "criteria": {
            "billing": "Payments and refunds",
            "technical": "Errors and outages",
            "sales": "Pricing and purchases"
        }
    }
}

result = router.predict(state, questions)

print(result["answers"]["department"]["choice"])Altyapı:

Burada, Router(preload=True) kritik kısımdır. 

İlk çalıştırmada Laya, gereken model dosyalarını Hugging Face deposundan getirip belleğe yükler. Sonraki çalıştırmalar yerel önbelleğe alınmış kopyaları yeniden kullanabilir.

Bunun yerine şunu kullanırsanız:

router = Router()Altyapı:

Laya tembel yükleme kullanır. Belirli bir kontrol noktası gerekene kadar bekler ve ilk kullanımda indirip derler.

2. Nimble: Jev’e Qwen Tabanlı Bir Alternatif

Bespoke Nimble, omurga olarak Qwen3.5-9B kullanır ve tiplenmiş karar verme için özel olarak rank-16 LoRA ile ince ayar yapar.

Metinle birlikte boolean veya enum soruları içeren düz bir şema sağlarsınız; Nimble, izin verilen her seçenek için olasılıklarla birlikte seçilen yanıtı döndürür. 

Yanıtı token token çözmek yerine, eğitim ve çıkarım doğrudan aday logit’ler üzerinde çalışır.

Jev gibi Nimble da girdi olarak duruma, çıktı olarak tiplenmiş olasılıksal kararlara dayanır; ancak uygulaması, bunun tescilli bir karar mimarisi gerektirmek yerine mevcut açık bir LLM’e nasıl eklenebileceğini gösterir. 

En büyük güçlü yanı sürecin tamamındaki açıklıktır: Bespoke Labs modeli, eğitim tarifini, değerlendirme kurulumunu ve veri kürasyonu hattını yayımlamıştır; bu da Nimble’ı kendi Jev tarzı modellerini eğitmek veya incelemek isteyen geliştiriciler için özellikle yararlı kılar.

Nimble nasıl çalışır

Nimble, boolean veya bir enum’dan tek bir değer gibi izin verilen çıktıları tanımlayan bir bağlam ve karar şemasıyla başlar. 

Bağlamı ve şemayı işlemek için Qwen3.5-9B’yi LoRA ile kullanır; ardından tam bir yanıt üretmek yerine izin verilen aday token’ları için logit’leri okur. 

Bu logit’ler softmax’ten geçirilerek olasılıklar üretilir ve yapılandırılmış tiplenmiş çıktı olarak döndürülür.

Nimble ile başlarken

Nimble, Python 3.12 gerektirir ve Bespoke-Nimble-9B kontrol noktasını kullanır. Depoyu klonlayıp bağımlılıkları kurarak başlayın:

git clone https://github.com/bespokelabsai/nimble.git nimble
cd nimble

python3.12 -m venv .cache/venvs/nimble
source .cache/venvs/nimble/bin/activate

python -m pip install torch==2.8.0 -r requirements/training.txtAltyapı:

Sonra modeli indirin ve hazırlayın. Resmî hazırlık adımı, Hugging Face’ten bespokelabs/Bespoke-Nimble-9B’yi indirir ve gerektiğinde LoRA adaptörünü sabit Qwen3.5 temel modeliyle birleştirir. Ardından .cache/nimble-model.json oluşturur.

import json
from pathlib import Path
from huggingface_hub import snapshot_download

repo = "bespokelabs/Bespoke-Nimble-9B"

snapshot = Path(
    snapshot_download(
        repo,
        cache_dir=".cache/huggingface/hub"
    )
)

config = {
    "model_path": str(snapshot.resolve()),
    "model_id": repo,
    "revision": snapshot.name,
    "max_input_tokens": 2048,
}

Path(".cache/nimble-model.json").write_text(
    json.dumps(config, indent=2)
)Altyapı:

İndirilen sürüm bir LoRA adaptörü ise, çıkarımdan önce adaptörü sabit temel modelle birleştirebilmesi için Nimble’ın resmî hızlı başlangıçtaki tam hazırlık bloğunu kullanın.

Bir NVIDIA GPU’da, hazırlanan modeli yükleyin:

import json
from pathlib import Path
from nimble.scoring.cuda_scorer import CudaCandidateScorer

config = json.loads(
    Path(".cache/nimble-model.json").read_text()
)

scorer = CudaCandidateScorer(**config)
Then make a typed decision:
schema = {
    "priority": {
        "type": "enum",
        "choices": ["HIGH", "LOW"],
        "description": "Urgency based on current business impact."
    },
    "requires_review": {
        "type": "boolean",
        "description": "Whether a human should review this incident."
    }
}

result = scorer.score(
    "The payment service is down for all customers.",
    schema
)

print(result["output"])
print(result["fields"]["priority"]["scores"])Altyapı:

Nimble, metin yanıtı üretmek yerine, seçilen değerleri ve her bir adaya atanan olasılıkları döndürür.

3. Kev: Jev’e Mimari Olarak En Yakın Kopya

Kev, Qwen3.5 üzerine kurulu, 0.8B, 4B ve 9B varyantlarına sahip Jev esinli bir karar modeli ailesidir. 

Rank-16 LoRA adaptörü ve her bir seçenek gösterimini sorunun karar gösterimiyle karşılaştıran küçük bir pointer head ekler. 

Birden fazla soru aynı durumu paylaşabilirken Kev, soruları yalıtır ve metin üretmeden olasılık dağılımlarını döndürür.

Kev, mimarisi açık bir Jev rekonstrüksiyonuna dayandırıldığı ve sunucusu TypeSafe’in /v1/systemone API sözleşmesini uyguladığı için Jev’e özellikle yakındır. 

Aynı noul, choice ve score soru biçimlerini destekler; böylece mevcut TypeSafe SDK kodu yerel bir Kev sunucusuna yönlendirilebilir. 

Başlıca avantajı, Jev benzeri davranış, açık ağırlıklar, birden fazla model boyutu ve açık bir eğitim hattını bir araya getirmesidir.

Kev nasıl çalışır

Kev, bir Qwen temel modeli, LoRA adaptörü ve küçük bir pointer head kullanır. 

Paylaşılan durum bir kez işlenir ve birden fazla soru arasında yeniden kullanılır; böylece model aynı bağlamı tekrar tekrar işlemeye ihtiyaç duymaz. 

Her soru için Kev, seçenekler ve karar token’ı için gizli gösterimler oluşturur; ardından pointer head bunları karşılaştırıp seçenek puanları üretir. 

Softmax bu puanları nihai choice, noul veya score için olasılıklara dönüştürür.

Kev ile başlarken

Kev, yerel bir System One sunucusu olarak çalışır.

Projeyi klonlayıp servis sunumu bağımlılıklarını kurarak başlayın:

git clone https://github.com/jaredpalmer/kev.git
cd kev

uv sync --extra serveAltyapı:

Bu, Kev’i kurar fakat model ağırlıklarının tümünü mutlaka kurmaz.

Kev-4B’yi şu şekilde başlatın:

KEV_DTYPE=bf16 \
uv run --extra serve python -m kev.serve \
    --run jaredpalmer/kev-4b \
    --port 8009Altyapı:

İlk çalıştırmada Kev, Kev adaptörünü/kontrol noktasını ve Qwen temel modelini Hugging Face’ten otomatik olarak indirir. 

Daha sonraki başlatmalarda model dosyaları yeniden indirilmek yerine önbellekten kullanılır.

Sunucu çalışmaya başladıktan sonra, TypeSafe SDK’yı ona karşı kullanabilirsiniz:

from typesafe_sdk import Choice, TypeSafeClient

client = TypeSafeClient(
    api_key="local",
    base_url="http://127.0.0.1:8009",
    model="kev-latest",
)

response = client.system_one(
    state="I was charged twice.",
    questions={
        "team": Choice(
            instructions="Which team owns this?",
            criteria={
                "billing": None,
                "technical": None,
            },
        )
    },
)

print(response.choices["team"].choice)Altyapı:

Dolayısıyla Kev’de sunucu komutu model yükleme adımıyla aynı işi görür: ilk başlatma gerekli ağırlıkları otomatik olarak indirir.

4. SemIf: İnce Ayar Olmadan Doğrudan Logit Kullanan Bir Jev Alternatifi

SemIf daha basit bir yaklaşım benimser: Hiç yeni bir karar modeli eğitmez. 

Bunun yerine, Qwen3.5-4B gibi mevcut açık modelleri kullanır ve izin verilen yanıtlara atanan logit’leri doğrudan okur. 

Durum, ölçütler ve tiplenmiş seçenekler modele iletilir; SemIf, yerel seçenek logit’lerini örnekleme veya yanıt üretmeden olasılıklara dönüştürür.

Bu, özel bir kontrol noktasına ihtiyaç duymadan, oto-regresif çıktı olmadan karar verme gibi Jev’in en önemli pratik özelliklerinden birini yeniden üretir. 

SemIf, esnekliğiyle öne çıkar: Altında farklı açık modeller kullanabilir, uzun bir durumu birçok soru için yeniden kullanabilir ve CUDA’da, Apple Silicon’da veya quantize edilmiş tarayıcı modellerinde doğrudan puanlama ile deney yapabilirsiniz.

Özel bir modeli önce eğitmeden System One fikrini test etmek istediğinizde özellikle kullanışlıdır.

SemIf nasıl çalışır

SemIf, yapılandırılmamış bir durumu, çalışma zamanı ölçütlerini ve izin verilen bir seçenek kümesini alır ve bunları mevcut bir açık modelden geçirir. 

Modelden bir yanıt üretmesini istemek yerine, bu önceden tanımlanmış seçeneklere atanan logit’leri doğrudan okur. 

Bu logit’ler bir olasılık dağılımına dönüştürülür; böylece uygulama, metin üretmeden veya sonradan bir yanıt ayrıştırmadan tiplenmiş bir karar verebilir.

SemIf ile başlarken

SemIf’in kendine ait özel bir temel model kontrol noktası yoktur. Bunun yerine, karar puanlamasını mevcut bir açık model üzerinde çalıştırır.

Klonlayıp kurun:

git clone https://github.com/TheoLeeCJ/SemIf.git
cd SemIf

python -m venv .venv
source .venv/bin/activate

pip install -e '.[test]'Altyapı:

Bu işlem SemIf’i kurar; ancak Qwen’i henüz indirmez.

Puanlayıcıyı çalıştırın:

CUDA_VISIBLE_DEVICES=0 semif-score \
    --mode direct \
    --model Qwen/Qwen3.5-4B \
    --revision 851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a \
    --input examples/decisions.jsonl \
    --output results.jsonlAltyapı:

İlk çalıştırmada, seçilen Qwen modeli Hugging Face’ten indirilip Hugging Face önbelleğine kaydedilir. SemIf dokümantasyonu, model dosyaları önemli yer kaplayabildiği için HF_HOME’un büyük bir sürücüye ayarlanmasını bile önerir.

Örneğin:

export HF_HOME=/path/to/large-drive/huggingfaceAltyapı:

Model önbelleğe alındıktan sonra, sonraki çalıştırmalar yerel kopyayı yeniden kullanabilir.

Dolayısıyla SemIf’in kendisi nispeten küçüktür. İndirme boyutunun çoğu, altında çalıştırmayı seçtiğiniz açık modelden gelir.

5. Rizzo Flow: Donanım Esnekliği İçin Yerel Öncelikli Bir Jev Alternatifi

Rizzo Flow, açık Spark-X2.5 modelleri ve llama.cpp tabanlı servis sunumu etrafında inşa edilmiş, yerel öncelikli bir Jev tarzı çıkarım sistemidir. 

Bir JSON yanıtı üretmek yerine, her kararı kısıtlı bir olası yanıt token’ları kümesine dönüştürür, bu token’lara atanan logit’leri okur ve bunları olasılıklara çevirir. 

Durum bir kez işlenip birden fazla soru için yeniden kullanılabilir; bu da tekrarlı hesaplamayı azaltır.

Jev gibi Rizzo Flow da yapılandırılmamış durumu kabul eder ve evet/hayır yargıları, seçimler, puanlar ve sayısal çıktılar gibi tiplenmiş kararlar döndürür. 

Ayrıca TypeSafe’in HTTP arayüzünü yansıtır; bu da barındırılan bir çağrıyı yerel bir uç noktayla değiştirmeyi nispeten kolaylaştırır. 

Rizzo Flow özellikle yerel dağıtım ve donanım esnekliğiyle öne çıkar; Jev’in tescilli eğitim mimarisini yeniden üretmeye çalışmak yerine açık modelleri, quantization’ı ve tanıdık bir API’yi birleştirir.

Rizzo Flow nasıl çalışır

Rizzo Flow, durumu bir kez işler ve sonucu modelin KV önbelleğinde saklar. 

Böylece birden fazla soru, tam bağlamı tekrar işlemek yerine bu önbelleğe alınmış durumu yeniden kullanabilir. Her soru bir çoktan seçmeli probleme dönüştürülür ve aday yanıtlar A, B veya C gibi harflerle temsil edilir. 

Rizzo Flow yalnızca bu yanıt harflerinin logit’lerini okur, softmax uygular ve ortaya çıkan olasılıkları boolean, choice, score veya number gibi tiplenmiş çıktılara dönüştürür.

Rizzo Flow ile başlarken

Rizzo Flow, Python 3.11+, Git ve uv gerektirir. 

Kurarken, makineniz için hesaplama arka ucunu seçin. Örneğin NVIDIA GPU’lu Linux’ta:

git clone https://github.com/Rizzo-AI-Academy/rizzo-flow
cd rizzo-flow

uv sync --locked --extra cuda
source .venv/bin/activateAltyapı:

Apple Silicon için --extra mlx; yalnızca CPU’lu sistemler için --extra cpu kullanın.

Ardından varsayılan Spark-X2.5 modelini ve yerel çalışma zamanını indirin:

rizzo downloadAltyapı:

Sonra sunucuyu başlatın:

rizzo serveAltyapı:

Model artık yerelde http://127.0.0.1:8017 adresinde çalışıyor. 

Jev uyumlu uç noktayı gerçek bir kararla test edebilirsiniz:

curl http://127.0.0.1:8017/v1/systemone \
  -H 'Content-Type: application/json' \
  -d '{
    "state": "My payouts have been failing for three days.",
    "model": "rizzo-latest",
    "questions": {
      "is_urgent": {
        "type": "noul",
        "instructions": "Does this convey urgency?"
      },
      "department": {
        "type": "choice",
        "instructions": "Which team should handle this?",
        "criteria": {
          "billing": "Payments and refunds",
          "technical": "Bugs and outages",
          "sales": null
        }
      }
    }
  }'Altyapı:

Rizzo Flow, çıktı yanıtını token token üretmeden, yanıtı ve olasılık dağılımını doğrudan döndürür.

6. Von: Jev’e Kompakt Bir System One Alternatifi

Von, 395M parametreli çift yönlü ModernBERT mimarisi tabanlı, amaca yönelik bir System One modelidir. 

Metni çözmek yerine, durumu ve aday ölçütleri birlikte OptionMarker gösterimlerini kullanarak değerlendirir; ardından Choice, Noul ve Score kararları için doğrudan logit’ler üretir. 

Ayrıca, ortaya çıkan olasılık dağılımlarının uygulama mantığı tarafından doğrudan kullanılabilmesi için eğitim sonrası kalibrasyon uygular.

Von arayüz düzeyinde Jev’e çok benzerdir: oto-regresif değildir, aynı üç temel karar ilkelini destekler, tek bir ileri geçişte birden çok soruyu değerlendirir ve /v1/systemone protokolünü uygular. 

Başlıca güçlü yanı küçük ayak izi ve yerel çıkarım tasarımıdır: model milyarlar yerine yüz milyonlarca parametreye sahiptir ve CUDA, ROCm, Apple Silicon ve CPU üzerinde çalışmayı destekler.

Von nasıl çalışır

von, durumu, soruyu ve aday ölçütleri birlikte işlemek için kompakt, çift yönlü ModernBERT tabanlı bir model kullanır. 

Option-Marker mekanizması, olası yanıtlar için gösterimler oluşturur ve bunlar aday logit’lere dönüştürülür. 

Von, nihai choice, noul veya score’dan önce olasılık dağılımını iyileştirmek için sıcaklık ölçeklendirmesi uygular. 

Aynı mimari, tek bir ileri geçiş içinde birden çok soruyu da değerlendirebilir.

Von ile başlarken

Von, en basit arayüzlerden birine sahiptir.

Python SDK’yı kurun:

pip install von-sdkAltyapı:

Bu, Von yazılımını kurar. Asıl model, Hugging Face’te wfzyx/von-1.0 olarak ayrı yayımlanmıştır.

Model ilk kez yüklendiğinde, ModernBERT kontrol noktası Hugging Face/Transformers model yükleme sistemi aracılığıyla indirilip yerelde önbelleğe alınır. 

Önbelleğe alındıktan sonra, sonraki çıkarımlar ağırlıkları yeniden indirmek yerine yerel kopyayı kullanabilir.

Ardından şu şekilde bir karar verebilirsiniz:

import von

result = von.decide(
    state="Database replication lag exceeded 45 seconds.",
    choices={
        "infrastructure": "Database or network failures",
        "billing": "Payments and invoices",
        "feature": "Requests for new functionality",
    },
    instructions="Classify the root cause.",
)

print(result.choice)
print(result.confidence)
For a binary decision:
p_blocking = von.judge(
    state="Requests are timing out.",
    instructions="Is this actively blocking customers?"
)

print(p_blocking)Altyapı:

Dolayısıyla ilk çağrı daha uzun sürebilir; çünkü modelin indirilip başlatılması gerekir. Sonrasında, gerçek çıkarım yerelde gerçekleşir.

7. NanoJev: Eğitilebilir, Hafif Bir Jev Kopyası

NanoJev, Qwen3-0.6B üzerine kurulu 0.6B’lik bir Jev kopyasıdır ve yapılandırılmış çıktılar için özel karar başlarına sahiptir. 

Her istek, omurgadan geçirilmeden önce paylaşılan başların eksiksiz olasılık dağılımları üretmesini sağlayacak şekilde bir durum, bir soru ve aday kümesi içerir. 

Choice set attention ve skaler bir baş kullanır; Boolean kararlar sigmoid kullanır; Score ise sıralı seviyeleri değerlendirip hem bir dağılım hem de beklenen skor üretir.

NanoJev, Jev’in tasarımını özellikle yakından izler: paralel kararları, dinamik aday kümelerini, tam olasılık dağılımlarını ve sıfır çıktı çözmeyi destekler. 

Öne çıktığı yer ise çok küçük bir omurga ve açık, uçtan uca bir eğitim hattı sunmasıdır.

Birden fazla durumu, soruyu ve aday yolu tek bir omurga ileri geçişine batch’leyebilir; bu da daha büyük genel amaçlı bir LLM’i uyarlamak yerine kompakt, eğitilebilir bir Jev tarzı mimariyle deneme yapmak isteyen geliştiriciler için ilginç bir seçenek hâline getirir.

NanoJev nasıl çalışır

NanoJev, modelin seçebileceği aday yanıtlarla birlikte bir durum ve bir soru alır. 

Her aday, ilgili girdilerle birleştirilir ve paylaşılan Qwen3-0.6B omurgasından geçirilir. 

NanoJev daha sonra adayları doğrudan puanlamak için özel karar başlarını kullanır: Choice set attention ve softmax, Boolean sigmoid, Score ise sıralı seviyeler üzerinde bir olasılık dağılımı üretir. 

Bu olasılıkları doğrudan ileri geçişten okuduğu için, çıktı token’ları üretmeden eksiksiz tiplenmiş dağılımlar döndürebilir.

NanoJev ile başlarken

NanoJev, model indirmesini depo kurulumundan ayrı tutar.

Projeyi kurarak başlayın:

git clone https://github.com/TianyuCodings/NanoJev.git
cd NanoJev

python -m pip install \
    -r requirements-toy.txt \
    huggingface_hubAltyapı:

Ardından sabitlenmiş herkese açık kontrol noktasını indirin:

from huggingface_hub import snapshot_download

snapshot_download(
    repo_id="C-Tianyu/NanoJev",
    revision="unified-games-v1",
    local_dir="checkpoints/NanoJev-unified",
    allow_patterns=[
        "best.safetensors",
        "config.json",
        "tokenizer/*",
        "backbone_config/*",
    ],
)Altyapı:

Yerel çıkarım sunucusunu başlatın:

CUDA_VISIBLE_DEVICES=0 python scripts/serve_decisions.py \
    --checkpoint-dir checkpoints/NanoJev-unified \
    --web-root web \
    --host 127.0.0.1 \
    --port 8765 \
    --precision bf16Altyapı:

Bir istek oluşturun:

cat > data/request.json <<'JSON'
{
  "states": [{
    "id": "living_room",
    "state": "The living room is 29 degrees. The target is 24 degrees. The window is closed and someone is home.",
    "questions": {
      "action": {
        "type": "choice",
        "instructions": "Choose the action that most directly lowers the room temperature.",
        "criteria": {
          "cool": "Turn on air conditioning",
          "light": "Turn on the lights",
          "wait": "Keep the current settings"
        }
      },
      "occupied": {
        "type": "boolean",
        "instructions": "Someone is home."
      }
    }
  }]
}
JSONAltyapı:

Ardından bunu NanoJev’e gönderin:

curl http://127.0.0.1:8765/api/evaluate \
  -H 'Content-Type: application/json' \
  --data-binary @data/request.jsonAltyapı:

Sunucu, kontrol noktasını yüklü tutar ve her soru için olasılık dağılımını döndürür. NanoJev aynı istekte birden fazla durum ve soruyu da batch’leyebilir.

En İyi 7 Jev Alternatifinin Karşılaştırması

Temel fark, her projenin kararı nasıl ürettiğidir.

Laya ve Von, özellikle seçenek puanlaması için inşa edilmiş küçük çift yönlü kodlayıcılar kullanır. 

Kev, Nimble ve NanoJev, Qwen modellerini özel eğitim veya karar başlarıyla uyarlar. 

SemIf ve Rizzo Flow ise mevcut üretici modellerden olasılıkları doğrudan çıkararak daha hafif bir yaklaşım benimser.

Pratikte, amaca yönelik kodlayıcılar hız ve verimliliğe öncelik verir; uyarlanmış Qwen modelleri daha fazla genel dil yeteneğini korur; doğrudan logit yöntemleri ise daha az özel eğitim gerektirdiği için denemesi daha kolaydır.

Hangi Jev Alternatifini Kullanmalısınız?

Küçük, uzmanlaşmış karar modelleri için Laya, Von ve NanoJev yaklaşık 322M ile 600M parametre arasında değişen en ilginç seçenekler arasındadır.

Çok dilli karar verme gerekiyorsa, Laya 100+ dili kapsayan mmBERT tabanlı özel bir kontrol noktasıyla öne çıkar.

TypeSafe System One API etrafında kurulu uygulamalar için Kev ve Von özellikle yakın entegrasyon yolları sağlar; Rizzo Flow ise yerel servis sunumu için aynı HTTP arayüzünü yansıtır.

Eğitim ve denemeler için Nimble veri kürasyonu ve LoRA ince ayar tarifini yayımlar; NanoJev ise veri üretimi, eğitim, değerlendirme ve servis sunumunu kapsayan tam bir hat sağlar.

Özel bir karar modeli eğitmeden denemek istiyorsanız, SemIf yararlı bir temel çizgidir: Yanıt üretmek yerine, Qwen gibi mevcut açık modellerden seçenek olasılıklarını doğrudan okur.

Son Düşünceler

Jev’in tam mimarisi yeni olabilir, ancak altta yatan fikir yeni değil. 

Sıfır atışlı NLI sınıflandırıcıları, model logit’lerinden gelişigüzel aday etiketleri yıllardır puanlıyor; Jev’den çok önce. 

TypeSafe AI’nin eklediği, bu fikri programlanabilir bir karar katmanına dönüştürmek için amaca yönelik bir mimari, paralel çıktılar, kalibre edilmiş olasılıklar ve temiz bir API’dir.

Açık kaynak ekosistemi, benzer bir şeyi inşa etmek için kapalı bir hizmete ihtiyacınız olmadığını gösteriyor. 

Kev, Von ve Rizzo Flow gibi projeler yerelde çalıştırılabilir ve Jev tarzı arayüzler sunabilirken, diğerleri ağırlıkları indirmenize, quantize etmenize veya llama.cpp gibi çalışma zamanlarını kullanmanıza izin veriyor.

Asıl çıkarım, Jev’in yapay zekâ ile karar vermeyi icat etmediği; önemli bir fikre dikkati yeniden çektiğidir: uygulamanızın tek ihtiyacı bir kararsa, hiç metin üretimine ihtiyaç duymayabilirsiniz.