1.59 GB
8 files
Updated about 2 months ago
Name
Size
assets
.gitattributes1.59 kB
xet
README.md4.84 kB
xet
calibration.json144 Bytes
xet
config.json6.35 kB
xet
model.safetensors1.58 GB
xet
tokenizer.json3.58 MB
xet
tokenizer_config.json599 Bytes
xet
README.md

Von-1.0: Non-Autoregressive System One Decision Model

Von-1.0 is an open-source, high-accuracy, sub-25ms System One decision model trained via RLCD (Reinforcement Learning with Calibration Distribution). It serves as a local, fully private, drop-in alternative to proprietary decision APIs like TypeSafe Jev.

  • Architecture: ModernBERT-Large bidirectional encoder (395M parameters, 8,192 token context, FlashAttention-2 / unpadding).
  • Training Method: RLCD (joint Cross-Entropy and Brier score calibration loss) on 250,000 balanced adversarial multi-hop reasoning pairs (ANLI Rounds 1–3, WANLI, MultiNLI, and SNLI).
  • Benchmark Accuracy: 91.23% on held-out validation (surpassing published TypeSafe Jev at 88.3%).
  • Calibrated Temperature: $T = 1.0367$ (optimal probability sharpness and Brier score).

Benchmark Comparison

Model Accuracy Latency (GPU) Latency (CPU) Cost
Von-1.0 91.23% ~25 ms ~300 ms Free / Local
TypeSafe Jev 88.30% Network Latency N/A (Cloud Only) $0.042 / 1M tokens

Von-1.0 vs TypeSafe Jev Task Breakdown

Task Category Breakdown

Decision Task / Category Evaluation Objective Von-1.0 TypeSafe Jev Margin (Δ)
Adversarial Multi-Hop Reasoning Negation handling & premise-hypothesis deduction (ANLI/WANLI) 91.23% 88.30% +2.93%
Customer Support Intent Triage Multi-class operational queue and ticket routing 94.60% 91.80% +2.80%
Guardrails & Policy Verification Content safety compliance & policy constraint checks 93.10% 89.50% +3.60%
Binary Condition Gating (Noul) Calibrated Yes/No probability verification 92.80% 90.20% +2.60%
Continuous Severity Rating (Score) Ordinal rubric calibration & Brier score alignment 89.40% 86.10% +3.30%
Macro Benchmark Average Comprehensive cross-domain evaluation 92.23% 89.18% +3.05%

Training Methodology & Calibration

Von-1.0 is post-trained using Reinforcement Learning with Calibration Distribution (RLCD) to simultaneously optimize classification accuracy and probabilistic calibration:

  1. Dual Objective Function: Minimizes joint Cross-Entropy and multi-class Brier score loss ($\mathcal{L}{\text{RLCD}} = \mathcal{L}{\text{CE}} + 0.5 \cdot \mathcal{L}_{\text{Brier}}$) to suppress overconfident misclassifications.
  2. Balanced Adversarial Corpus: 250,000 class-balanced examples drawn from ANLI (Rounds 1–3), WANLI, MultiNLI, and SNLI.
  3. Temperature Optimization: Post-hoc empirical temperature scalar optimization minimizing NLL over held-out validation logits, converging at $T = 1.0367$.

Quickstart with Von

pip install von
import von

# Set backend to Von-1.0
von.set_backend("modernbert")

# 1. Multi-Class Choice Routing
result = von.decide(
    "Customer requests a full refund for an unused annual subscription.",
    choices={
        "billing": "Inquiries regarding refunds, payments, invoices, or subscriptions",
        "tech": "Technical bugs, 500 errors, database crashes, or downtime",
        "feature_request": "Requests for new features or capabilities"
    }
)
print(result.choice)         # 'billing'
print(result.confidence)     # 0.7920
print(result.probabilities)  # {'billing': 0.8742, 'tech': 0.0820, 'feature_request': 0.0438}

# 2. Binary Verification (Noul)
is_failing = von.judge(
    "Database connection pool exhausted on port 5432, connection refused.",
    instructions="Is the database infrastructure failing or down?"
)
print(is_failing)  # 0.9412

Usage with Hugging Face Transformers

import torch
from transformers import AutoModelForSequenceClassification, AutoTokenizer

model_id = "wfzyx/von-1.0"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForSequenceClassification.from_pretrained(model_id).to("cuda")

premise = "Database connection pool exhausted on port 5432, connection refused."
hypothesis = "Is the database infrastructure failing or down? Technical failure or outage"

inputs = tokenizer(premise, hypothesis, return_tensors="pt").to("cuda")
with torch.no_grad():
    logits = model(**inputs).logits
    # Entailment score (index 0)
    score = torch.softmax(logits / 1.0367, dim=-1)

License

Apache-2.0

Total size
1.59 GB
Files
8
Last updated
Sep 19
Pre-warmed CDN
US EU US EU

Contributors