7 lựa chọn thay thế Jev mã nguồn mở hàng đầu, được gõ kiểu TypeSafe

Nhiều ứng dụng AI dùng các mô hình ngôn ngữ lớn cho những tác vụ thực ra không cần tạo sinh văn bản. 

Một agent có thể chỉ cần quyết định gọi công cụ nào, một tài liệu có liên quan hay không, mức độ khẩn cấp của một yêu cầu, hoặc một hành động có nên được leo thang hay không.

Jev của TypeSafe AI tiếp cận các tác vụ này theo cách khác. Thay vì tạo câu trả lời theo từng token, nó nhận trạng thái ứng dụng và các câu hỏi có cấu trúc rồi trả về các quyết định được gõ kiểu như lựa chọn, điểm số, đánh giá có/không, và xác suất. Xem sản phẩm hoạt động trong hướng dẫn Jev API của chúng tôi

TypeSafe AI mô tả đây là cách tiếp cận Mô hình Hệ thống Một (System One Model): dùng AI như một lớp ra quyết định nhanh thay vì là trình tạo văn bản đa dụng.

Thách thức là chúng ta vẫn biết tương đối ít về cách Jev hoạt động bên trong. 

TypeSafe AI đã chia sẻ một số chi tiết về phương pháp ra quyết định song song và cách huấn luyện của họ, nhưng kiến trúc đầy đủ, trọng số mô hình, dữ liệu huấn luyện, và công thức huấn luyện hoàn chỉnh chưa được công khai.

Điều này khiến việc kiểm tra, tái tạo, hoặc điều chỉnh chính Jev trở nên khó khăn.

Các dự án mã nguồn mở đang khai phá cùng ý tưởng bằng những kiến trúc mà chúng ta có thể thực sự xem xét và chạy cục bộ. 

Một số dùng các mô hình hai chiều nhỏ, số khác điều chỉnh Qwen với các đầu ra quyết định chuyên biệt, trong khi số khác trích xuất xác suất trực tiếp từ các mô hình ngôn ngữ hiện có. 

Vì bạn kiểm soát toàn bộ ngăn xếp, bạn cũng có thể tối ưu kích thước mô hình, lượng tử hóa, batching, bộ nhớ đệm, phần cứng và phục vụ để xây dựng một lớp ra quyết định nhanh và rẻ hơn cho khối lượng công việc của riêng bạn.

Trong bài viết này, tôi sẽ so sánh bảy lựa chọn thay thế mã nguồn mở cho Jev, gồm Laya, Nimble, Kev, SemIf, Rizzo Flow, Von và NanoJev, xem cách mỗi dự án hoạt động, mức độ bám sát cách tiếp cận của Jev, điểm nổi bật, và cách chạy cục bộ. 

Lưu ý: Các dự án trong hướng dẫn này còn rất mới và đang phát triển nhanh chóng. Ví dụ mã dựa trên tài liệu chính thức và kho mã của họ, nhưng không phải tất cả ví dụ đều đã được kiểm thử độc lập đầu-cuối.

1. Laya: Lựa chọn thay thế Jev đa ngôn ngữ, thiết kế chuyên biệt

Laya là mô hình ra quyết định không tự hồi quy (non-autoregressive) được thiết kế chuyên biệt dựa trên ModernBERT-large, với checkpoint mmBERT riêng cho tác vụ đa ngôn ngữ.

 Thay vì tạo văn bản, nó xử lý trạng thái, câu hỏi và các lựa chọn sẵn có cùng nhau và trực tiếp chấm điểm các câu trả lời khả dĩ trong một lần suy luận (forward pass). Nó hỗ trợ các quyết định kiểu Jev choice, score và noul, với các checkpoint dành riêng cho tiếng Anh, đa ngôn ngữ và khối lượng công việc quyết định được gõ kiểu.

Điều này khiến Laya trở thành một trong những lựa chọn thay thế về kiến trúc gần nhất với Jev vì cả hai đều được thiết kế đặc biệt cho các quyết định xác suất thay vì tạo sinh văn bản. 

Laya nổi bật nhờ kích thước mô hình tương đối nhỏ 322M–421M, hỗ trợ đa ngôn ngữ trên 100+ ngôn ngữ, và khả năng đánh giá nhiều câu hỏi hiệu quả mà không cần chạy mô hình tạo sinh nhiều tỷ tham số.

Cách Laya hoạt động

Laya nhận một trạng thái như email, phiếu hỗ trợ, tài liệu, hoặc đối tượng JSON, cùng với các câu hỏi được gõ kiểu như choice, score, hoặc noul. 

Bộ định tuyến (router) của nó chọn checkpoint phù hợp nhất cho yêu cầu, như ModernBERT-large cho tiếng Anh hoặc mmBERT-base cho đầu vào đa ngôn ngữ. 

Mô hình được chọn xử lý trạng thái và câu hỏi trong một lần forward pass, sau đó một đầu quyết định chấm điểm các lựa chọn sẵn có và chuyển đổi chúng thành xác suất. 

Điều này tạo ra luồng trực tiếp từ đầu vào, qua định tuyến và mã hóa, đến quyết định được gõ kiểu cuối cùng.

Bắt đầu với Laya

Laya có sẵn dưới dạng gói Python:

pip install layaĐược hỗ trợ bởi

Lệnh này cài đặt thư viện Laya và các phụ thuộc, nhưng không đóng gói trọng số mô hình bên trong gói.

Các mô hình được lưu trữ trên Hugging Face. 

Khi bạn tạo router với preload=True, Laya tải xuống và nạp sẵn các checkpoint sẵn có để sẵn sàng trước yêu cầu đầu tiên. 

Trọng số đã tải được lưu đệm cục bộ, nên không cần tải lại mỗi lần chạy ứng dụng.

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"])Được hỗ trợ bởi

Ở đây, Router(preload=True) là phần quan trọng. 

Ở lần chạy đầu, Laya tải các tệp mô hình cần thiết từ kho Hugging Face của mình và nạp vào bộ nhớ. Những lần sau có thể tái sử dụng bản sao đã lưu đệm cục bộ.

Nếu thay vào đó bạn dùng:

router = Router()Được hỗ trợ bởi

Laya dùng tải lười (lazy loading). Nó đợi đến khi cần một checkpoint cụ thể mới tải/xây dựng nó ở lần dùng đầu tiên.

2. Nimble: Lựa chọn thay thế Jev dựa trên Qwen

Bespoke Nimble dùng Qwen3.5-9B làm xương sống và tinh chỉnh bằng LoRA hạng-16 chuyên cho quyết định được gõ kiểu.

Bạn cung cấp một đoạn văn bản cùng với schema phẳng chứa các câu hỏi boolean hoặc enum, và Nimble trả về câu trả lời được chọn cùng xác suất cho mọi lựa chọn hợp lệ. 

Thay vì giải mã câu trả lời theo từng token, quá trình huấn luyện và suy luận vận hành trực tiếp trên các logits ứng viên.

Giống Jev, Nimble xây dựng quanh ý tưởng nhập trạng thái, xuất quyết định xác suất được gõ kiểu, nhưng cách triển khai cho thấy hành vi đó có thể được bổ sung vào một LLM mở sẵn có thay vì cần kiến trúc quyết định độc quyền. 

Thế mạnh chính của nó là tính mở ở toàn bộ quy trình: Bespoke Labs đã phát hành mô hình, công thức huấn luyện, thiết lập đánh giá và quy trình tuyển chọn dữ liệu, khiến Nimble đặc biệt hữu ích cho nhà phát triển muốn huấn luyện hoặc nghiên cứu các mô hình kiểu Jev của riêng mình.

Cách Nimble hoạt động

Nimble bắt đầu với một ngữ cảnh và schema quyết định định nghĩa các đầu ra cho phép, như boolean hoặc một giá trị từ enum. 

Nó dùng Qwen3.5-9B với LoRA để xử lý ngữ cảnh và schema, rồi đọc logits cho các token ứng viên được phép thay vì tạo toàn bộ phản hồi. 

Các logits này được đưa qua softmax để tạo xác suất, sau đó trả về dưới dạng đầu ra có cấu trúc, được gõ kiểu.

Bắt đầu với Nimble

Nimble yêu cầu Python 3.12 và dùng checkpoint Bespoke-Nimble-9B. Bắt đầu bằng cách nhân bản kho mã và cài đặt phụ thuộc:

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.txtĐược hỗ trợ bởi

Tiếp theo, tải và chuẩn bị mô hình. Bước chuẩn bị chính thức sẽ tải bespokelabs/Bespoke-Nimble-9B từ Hugging Face và, khi cần, gộp adapter LoRA của nó với mô hình nền Qwen3.5 đã cố định phiên bản. Sau đó tạo .cache/nimble-model.json.

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)
)Được hỗ trợ bởi

Nếu bản phát hành đã tải xuống là một adapter LoRA, hãy dùng khối chuẩn bị đầy đủ của Nimble từ phần khởi động nhanh chính thức để nó có thể gộp adapter với mô hình nền đã cố định trước khi suy luận.

Trên GPU NVIDIA, nạp mô hình đã chuẩn bị:

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"])Được hỗ trợ bởi

Nimble trả về các giá trị đã chọn cùng xác suất gán cho mỗi ứng viên thay vì tạo một phản hồi văn bản.

3. Kev: Bản sao kiến trúc gần Jev nhất

Kev là một họ mô hình quyết định lấy cảm hứng từ Jev, xây dựng trên Qwen3.5, với các biến thể 0.8B, 4B và 9B. 

Nó bổ sung adapter LoRA hạng-16 và một đầu trỏ (pointer head) nhỏ so sánh mỗi biểu diễn lựa chọn với biểu diễn quyết định của câu hỏi. 

Nhiều câu hỏi có thể chia sẻ cùng trạng thái, trong khi Kev giữ các câu hỏi tách biệt và trả về các phân phối xác suất của chúng mà không tạo văn bản.

Kev đặc biệt gần với Jev vì kiến trúc của nó được dựa rõ ràng trên một bản tái dựng công khai của Jev, và máy chủ của nó triển khai hợp đồng API /v1/systemone của TypeSafe. 

Nó hỗ trợ cùng các kiểu câu hỏi noul, choice và score, nên mã SDK TypeSafe hiện có có thể được chuyển hướng đến máy chủ Kev cục bộ. 

Ưu điểm chính của nó là sự kết hợp giữa hành vi giống Jev, trọng số mở, nhiều kích thước mô hình và quy trình huấn luyện mở.

Cách Kev hoạt động

Kev dùng mô hình nền Qwen với adapter LoRA và một đầu trỏ nhỏ. 

Trạng thái dùng chung được xử lý một lần và tái sử dụng cho nhiều câu hỏi, nên mô hình không cần xử lý lại cùng ngữ cảnh nhiều lần. 

Với mỗi câu hỏi, Kev tạo các biểu diễn ẩn cho các lựa chọn và token quyết định, sau đó đầu trỏ so sánh chúng và tạo điểm số cho các lựa chọn. 

Softmax chuyển các điểm số thành xác suất cho choice, noul hoặc score cuối cùng.

Bắt đầu với Kev

Kev chạy như một máy chủ System One cục bộ.

Bắt đầu bằng cách nhân bản dự án và cài đặt các phụ thuộc phục vụ:

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

uv sync --extra serveĐược hỗ trợ bởi

Điều này cài đặt Kev, nhưng không nhất thiết tải tất cả trọng số mô hình.

Khởi động Kev-4B với:

KEV_DTYPE=bf16 \
uv run --extra serve python -m kev.serve \
    --run jaredpalmer/kev-4b \
    --port 8009Được hỗ trợ bởi

Ở lần chạy đầu, Kev tự động tải xuống cả adapter/checkpoint của Kev và mô hình nền Qwen từ Hugging Face. 

Những lần khởi động sau tái sử dụng các tệp mô hình đã lưu đệm thay vì tải lại.

Khi máy chủ đã chạy, bạn có thể dùng TypeSafe SDK với nó:

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)Được hỗ trợ bởi

Với Kev, lệnh khởi chạy máy chủ đồng thời là bước tải mô hình: lần chạy đầu sẽ tự động tải trọng số cần thiết.

4. SemIf: Lựa chọn thay thế Jev đọc trực tiếp logits, không cần tinh chỉnh

SemIf chọn cách đơn giản hơn: nó không huấn luyện mô hình quyết định mới nào cả. 

Thay vào đó, nó dùng các mô hình mở sẵn có như Qwen3.5-4B và đọc trực tiếp các logits gán cho các câu trả lời được phép. 

Trạng thái, tiêu chí và các lựa chọn được gõ kiểu được truyền vào mô hình, và SemIf chuyển các logits của lựa chọn gốc thành xác suất mà không cần lấy mẫu hay tạo câu trả lời.

Điều này tái hiện một trong những thuộc tính thực tiễn quan trọng nhất của Jev, đưa ra quyết định mà không cần đầu ra tự hồi quy, đồng thời tránh nhu cầu về checkpoint chuyên biệt. 

SemIf nổi bật nhờ tính linh hoạt: bạn có thể dùng các mô hình mở khác nhau bên dưới, tái sử dụng một trạng thái dài cho nhiều câu hỏi, và thử nghiệm chấm điểm trực tiếp trên CUDA, Apple Silicon, hoặc mô hình lượng tử hóa trong trình duyệt.

Nó đặc biệt hữu ích khi bạn muốn thử nghiệm ý tưởng Hệ thống Một mà không cần huấn luyện mô hình chuyên biệt trước.

Cách SemIf hoạt động

SemIf nhận một trạng thái không cấu trúc, tiêu chí thời gian chạy và một tập lựa chọn cho phép rồi truyền qua một mô hình mở sẵn có. 

Thay vì yêu cầu mô hình tạo câu trả lời, nó đọc trực tiếp các logits gán cho những lựa chọn được định sẵn đó. 

Các logits này được chuyển thành phân phối xác suất, cho phép ứng dụng đưa ra quyết định được gõ kiểu mà không cần tạo văn bản hay phân tích phản hồi sau đó.

Bắt đầu với SemIf

SemIf không có checkpoint mô hình nền riêng. Thay vào đó, nó chạy chấm điểm quyết định trên một mô hình mở sẵn có.

Nhân bản và cài đặt:

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

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

pip install -e '.[test]'Được hỗ trợ bởi

Lệnh này cài đặt SemIf, nhưng chưa tải Qwen.

Chạy trình chấm điểm:

CUDA_VISIBLE_DEVICES=0 semif-score \
    --mode direct \
    --model Qwen/Qwen3.5-4B \
    --revision 851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a \
    --input examples/decisions.jsonl \
    --output results.jsonlĐược hỗ trợ bởi

Ở lần chạy đầu, mô hình Qwen đã chọn sẽ được tải từ Hugging Face và lưu trong bộ đệm Hugging Face. Tài liệu của SemIf thậm chí khuyến nghị đặt HF_HOME trỏ tới ổ đĩa lớn vì các tệp mô hình có thể chiếm dung lượng đáng kể.

Ví dụ:

export HF_HOME=/path/to/large-drive/huggingfaceĐược hỗ trợ bởi

Sau khi mô hình đã được lưu đệm, các lần chạy sau có thể tái sử dụng bản sao cục bộ.

Vì vậy bản thân SemIf tương đối nhỏ. Phần lớn dung lượng tải xuống đến từ mô hình mở mà bạn chọn chạy bên dưới nó.

5. Rizzo Flow: Lựa chọn thay thế Jev ưu tiên cục bộ cho tính linh hoạt phần cứng

Rizzo Flow là hệ thống suy luận kiểu Jev ưu tiên cục bộ, xây dựng quanh các mô hình Spark-X2.5 mở và nền tảng phục vụ dựa trên llama.cpp. 

Thay vì tạo một câu trả lời JSON, nó chuyển mỗi quyết định thành một tập hữu hạn các token câu trả lời khả dĩ, đọc các logits gán cho các token đó và chuyển chúng thành xác suất. 

Trạng thái có thể được xử lý một lần và tái sử dụng cho nhiều câu hỏi, giảm tính toán lặp lại.

Giống Jev, Rizzo Flow chấp nhận trạng thái không cấu trúc và trả về các quyết định được gõ kiểu như đánh giá có/không, lựa chọn, điểm số và đầu ra số. 

Nó cũng phản chiếu giao diện HTTP của TypeSafe, giúp tương đối dễ dàng thay thế một cuộc gọi được lưu trữ bằng một endpoint cục bộ. 

Rizzo Flow đặc biệt nổi bật về triển khai cục bộ và linh hoạt phần cứng, kết hợp mô hình mở, lượng tử hóa và API quen thuộc thay vì cố tái hiện kiến trúc huấn luyện độc quyền của Jev.

Cách Rizzo Flow hoạt động

Rizzo Flow xử lý trạng thái một lần và lưu kết quả trong bộ nhớ đệm KV của mô hình. 

Nhiều câu hỏi sau đó có thể tái sử dụng trạng thái đã lưu đệm thay vì xử lý lại toàn bộ ngữ cảnh. Mỗi câu hỏi được chuyển thành một bài toán trắc nghiệm, với các câu trả lời ứng viên được biểu diễn bởi các chữ cái như A, B hoặc C. 

Rizzo Flow chỉ đọc logits cho các chữ cái trả lời đó, áp dụng softmax, rồi chuyển các xác suất thu được thành đầu ra được gõ kiểu như boolean, lựa chọn, điểm số hoặc số.

Bắt đầu với Rizzo Flow

Rizzo Flow yêu cầu Python 3.11+, Git và uv. 

Khi cài đặt, hãy chọn backend tính toán phù hợp với máy của bạn. Ví dụ, trên Linux với GPU NVIDIA:

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

uv sync --locked --extra cuda
source .venv/bin/activateĐược hỗ trợ bởi

Với Apple Silicon, dùng --extra mlx; hệ thống chỉ CPU có thể dùng --extra cpu.

Tiếp theo, tải mô hình Spark-X2.5 mặc định và runtime cục bộ của nó:

rizzo downloadĐược hỗ trợ bởi

Sau đó khởi động máy chủ:

rizzo serveĐược hỗ trợ bởi

Mô hình nay chạy cục bộ tại http://127.0.0.1:8017. 

Bạn có thể thử nghiệm endpoint tương thích Jev bằng một quyết định thực:

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
        }
      }
    }
  }'Được hỗ trợ bởi

Rizzo Flow trả về câu trả lời và phân phối xác suất trực tiếp, không tạo đầu ra theo từng token.

6. Von: Lựa chọn System One gọn nhẹ thay thế Jev

Von là mô hình System One được thiết kế chuyên biệt dựa trên kiến trúc ModernBERT hai chiều với 395M tham số. 

Thay vì giải mã văn bản, nó đánh giá trạng thái và tiêu chí ứng viên cùng nhau bằng các biểu diễn OptionMarker, rồi trực tiếp tạo logits cho quyết định Choice, Noul và Score. 

Nó cũng áp dụng hiệu chuẩn sau huấn luyện để các phân phối xác suất thu được có thể được ứng dụng sử dụng trực tiếp.

Von rất giống Jev ở cấp giao diện: không tự hồi quy, hỗ trợ ba nguyên thủy quyết định cốt lõi giống nhau, đánh giá nhiều câu hỏi trong một forward pass, và triển khai giao thức /v1/systemone. 

Thế mạnh chính của nó là dung lượng nhỏ và thiết kế suy luận cục bộ: mô hình chỉ có hàng trăm triệu thay vì hàng tỷ tham số và hỗ trợ CUDA, ROCm, Apple Silicon và CPU.

Cách Von hoạt động

von dùng mô hình nhỏ gọn dựa trên ModernBERT hai chiều để xử lý trạng thái, câu hỏi và tiêu chí ứng viên cùng nhau. 

Cơ chế Option-Marker của nó tạo các biểu diễn cho các câu trả lời khả dĩ, rồi chuyển thành logits ứng viên. 

Sau đó áp dụng hiệu chỉnh nhiệt độ để cải thiện phân phối xác suất trước khi von trả về choice, noul hoặc score cuối cùng. 

Cùng kiến trúc này cũng có thể đánh giá nhiều câu hỏi trong một forward pass.

Bắt đầu với Von

Von có một trong những giao diện đơn giản nhất.

Cài đặt SDK Python:

pip install von-sdkĐược hỗ trợ bởi

Lệnh này cài đặt phần mềm Von. Mô hình thực tế được phát hành riêng là wfzyx/von-1.0 trên Hugging Face.

Khi mô hình được nạp lần đầu, checkpoint ModernBERT của nó sẽ được tải xuống và lưu đệm cục bộ thông qua hệ thống nạp mô hình Hugging Face/Transformers. 

Khi đã lưu đệm, suy luận sau đó có thể dùng bản sao cục bộ thay vì tải lại trọng số.

Bạn có thể đưa ra quyết định với:

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)Được hỗ trợ bởi

Vì vậy, lần gọi đầu có thể lâu hơn vì mô hình cần tải và khởi tạo. Sau đó, suy luận diễn ra cục bộ.

7. NanoJev: Bản sao Jev nhẹ, có thể huấn luyện

NanoJev là bản sao Jev 0.6B xây dựng trên Qwen3-0.6B với các đầu quyết định dành riêng cho đầu ra có cấu trúc. 

Mỗi yêu cầu chứa một trạng thái, câu hỏi và tập ứng viên, được truyền qua backbone trước khi các đầu chia sẻ tạo ra phân phối xác suất đầy đủ. 

Choice dùng set attention và đầu vô hướng, quyết định Boolean dùng sigmoid, và Score đánh giá các mức có thứ tự và tạo cả phân phối lẫn điểm kỳ vọng.

NanoJev bám sát thiết kế của Jev một cách đặc biệt: nó hỗ trợ các quyết định song song, tập ứng viên động, phân phối xác suất đầy đủ và không giải mã đầu ra. 

Điểm nổi bật của nó là backbone rất nhỏ và quy trình huấn luyện đầu-cuối rõ ràng.

Nó có thể batch nhiều trạng thái, câu hỏi và nhánh ứng viên vào một forward pass của backbone, khiến đây là lựa chọn thú vị cho nhà phát triển muốn thử nghiệm một kiến trúc kiểu Jev nhỏ gọn, có thể huấn luyện thay vì điều chỉnh một LLM đa dụng lớn hơn.

Cách NanoJev hoạt động

NanoJev nhận một trạng thái, một câu hỏi và các câu trả lời ứng viên mà mô hình được phép chọn. 

Mỗi ứng viên được kết hợp với đầu vào liên quan và truyền qua backbone Qwen3-0.6B dùng chung. 

NanoJev sau đó dùng các đầu quyết định chuyên dụng để chấm điểm trực tiếp các ứng viên: Choice dùng set attention và softmax, Boolean dùng sigmoid, và Score tạo một phân phối xác suất trên các mức có thứ tự. 

Bởi vì nó đọc các xác suất này trực tiếp từ forward pass, nó có thể trả về các phân phối được gõ kiểu đầy đủ mà không cần tạo token đầu ra.

Bắt đầu với NanoJev

NanoJev tách riêng việc tải mô hình khỏi việc cài đặt kho mã.

Bắt đầu bằng cách cài đặt dự án:

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

python -m pip install \
    -r requirements-toy.txt \
    huggingface_hubĐược hỗ trợ bởi

Sau đó tải checkpoint công khai đã cố định:

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/*",
    ],
)Được hỗ trợ bởi

Khởi động máy chủ suy luận cục bộ:

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 bf16Được hỗ trợ bởi

Tạo một yêu cầu:

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."
      }
    }
  }]
}
JSONĐược hỗ trợ bởi

Sau đó gửi tới NanoJev:

curl http://127.0.0.1:8765/api/evaluate \
  -H 'Content-Type: application/json' \
  --data-binary @data/request.jsonĐược hỗ trợ bởi

Máy chủ giữ checkpoint được nạp và trả về phân phối xác suất cho mỗi câu hỏi. NanoJev cũng có thể batch nhiều trạng thái và câu hỏi trong cùng một yêu cầu.

So sánh 7 lựa chọn thay thế Jev hàng đầu

Khác biệt chính là mỗi dự án tạo ra quyết định như thế nào.

Laya và Von dùng các encoder hai chiều nhỏ được xây dựng đặc biệt để chấm điểm lựa chọn. 

Kev, Nimble và NanoJev điều chỉnh các mô hình Qwen với huấn luyện chuyên biệt hoặc đầu quyết định. 

SemIf và Rizzo Flow chọn cách nhẹ hơn bằng cách trích xuất xác suất trực tiếp từ các mô hình tạo sinh hiện có.

Trên thực tế, các encoder chuyên dụng ưu tiên tốc độ và hiệu quả, các mô hình Qwen được điều chỉnh giữ lại nhiều năng lực ngôn ngữ tổng quát hơn, và phương pháp trực tiếp logits thì dễ thử nghiệm vì cần ít huấn luyện chuyên biệt hơn.

Bạn nên dùng lựa chọn thay thế Jev nào?

Với các mô hình quyết định nhỏ, chuyên biệt, Laya, Von và NanoJev là những lựa chọn thú vị nhất, dao động khoảng 322M đến 600M tham số.

Nếu bạn cần ra quyết định đa ngôn ngữ, Laya nổi bật với checkpoint dựa trên mmBERT dành riêng, bao phủ 100+ ngôn ngữ.

Với các ứng dụng xây dựng quanh API TypeSafe System One, Kev và Von cung cấp các đường tích hợp đặc biệt gần gũi, trong khi Rizzo Flow phản chiếu cùng giao diện HTTP cho phục vụ cục bộ.

Với mục tiêu huấn luyện và thử nghiệm, Nimble công bố quy trình tuyển chọn dữ liệu và công thức tinh chỉnh LoRA, còn NanoJev cung cấp pipeline đầy đủ bao gồm tạo dữ liệu, huấn luyện, đánh giá và phục vụ.

Nếu bạn muốn thử nghiệm mà không cần huấn luyện mô hình quyết định chuyên biệt, SemIf là một đường cơ sở hữu ích: nó đọc xác suất lựa chọn trực tiếp từ các mô hình mở sẵn có như Qwen thay vì tạo câu trả lời.

Lời kết

Kiến trúc chính xác của Jev có thể mới, nhưng ý tưởng nền tảng thì không. 

Các bộ phân loại NLI zero-shot đã chấm điểm các nhãn ứng viên tùy ý từ logits của mô hình trong nhiều năm, từ lâu trước Jev. 

Điều TypeSafe AI bổ sung là kiến trúc được thiết kế chuyên biệt, đầu ra song song, xác suất hiệu chuẩn và một API gọn gàng để biến ý tưởng đó thành một lớp ra quyết định có thể lập trình.

Hệ sinh thái mã nguồn mở cho thấy bạn không cần dịch vụ đóng để xây dựng thứ tương tự. 

Các dự án như Kev, Von và Rizzo Flow có thể chạy cục bộ và phơi bày giao diện kiểu Jev, trong khi các dự án khác cho phép bạn tải trọng số, lượng tử hóa chúng, hoặc dùng các runtime như llama.cpp.

Điều rút ra thực sự không phải là Jev phát minh ra ra quyết định bằng AI, mà là nó đã đưa sự chú ý trở lại một ý tưởng quan trọng: nếu ứng dụng của bạn chỉ cần một quyết định, bạn có thể không cần tạo sinh văn bản.