von-sdk 1.0.0__py3-none-any.whl

von/__init__.py

@@ -0,0 +1,48 @@
+"""von - The open-source System One decision model.
+
+Fast, local, non-autoregressive decision primitives.
+Named in homage to John von Neumann and Ludwig von Mises.
+"""
+
+from .types import (
+    Noul,
+    Choice,
+    Score,
+    noul,
+    choice,
+    score,
+    NoulAnswer,
+    ChoiceAnswer,
+    ScoreAnswer,
+    SystemOneResponse,
+    Usage,
+)
+from .client import VonClient, AsyncVonClient
+from .api import system_one, decide, judge, rate, set_backend
+from . import presets
+from . import patterns
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "Noul",
+    "Choice",
+    "Score",
+    "noul",
+    "choice",
+    "score",
+    "NoulAnswer",
+    "ChoiceAnswer",
+    "ScoreAnswer",
+    "SystemOneResponse",
+    "Usage",
+    "VonClient",
+    "AsyncVonClient",
+    "system_one",
+    "decide",
+    "judge",
+    "rate",
+    "set_backend",
+    "presets",
+    "patterns",
+]

von/api.py

@@ -0,0 +1,83 @@
+"""High-level convenience API for Von."""
+
+from typing import Any, Dict, List, Optional, Union
+from .client import VonClient
+from .types import (
+    Choice,
+    ChoiceAnswer,
+    Noul,
+    Question,
+    Score,
+    ScoreAnswer,
+    SystemOneResponse,
+)
+
+_default_client: Optional[VonClient] = None
+
+
+def _get_default_client() -> VonClient:
+    global _default_client
+    if _default_client is None:
+        _default_client = VonClient(local=True)
+    return _default_client
+
+
+def set_backend(backend: str):
+    """Set the underlying decision backend ('needle', 'modernbert', 'qwen0.5b')."""
+    from .engine import VonEngine
+    VonEngine.set_backend(backend)
+
+
+def system_one(
+    state: Any,
+    questions: Dict[str, Union[Question, Dict[str, Any]]],
+    model: str = "von-latest",
+    client: Optional[VonClient] = None,
+) -> SystemOneResponse:
+    """Evaluate state and questions using System One."""
+    cli = client or _get_default_client()
+    return cli.system_one(state=state, questions=questions, model=model)
+
+
+def decide(
+    state: Any,
+    choices: Union[List[str], Dict[str, Optional[str]]],
+    instructions: str = "Which option best describes the state?",
+    model: str = "von-latest",
+) -> ChoiceAnswer:
+    """Make a fast discrete decision among options."""
+    if isinstance(choices, list):
+        if len(choices) != len(set(choices)):
+            raise ValueError(f"Duplicate choices found in options list: {choices}")
+        criteria = {c: None for c in choices}
+    else:
+        criteria = choices
+
+    q = Choice(instructions=instructions, criteria=criteria)
+    resp = system_one(state=state, questions={"decision": q}, model=model)
+    return resp.answers["decision"]  # type: ignore
+
+
+def judge(
+    state: Any,
+    instructions: str,
+    criteria: Optional[Dict[str, str]] = None,
+    model: str = "von-latest",
+) -> float:
+    """Evaluate a yes/no question and return the probability (0.0 to 1.0)."""
+    q = Noul(instructions=instructions, criteria=criteria)
+    resp = system_one(state=state, questions={"judgment": q}, model=model)
+    answer = resp.answers["judgment"]
+    return getattr(answer, "noul", 0.0)
+
+
+def rate(
+    state: Any,
+    criteria: List[Union[str, Dict[str, Any]]],
+    instructions: str = "Rate where the state falls on this scale:",
+    model: str = "von-latest",
+) -> ScoreAnswer:
+    """Evaluate a state on an ordered multi-level scale."""
+    q = Score(instructions=instructions, criteria=criteria)
+    resp = system_one(state=state, questions={"rating": q}, model=model)
+    return resp.answers["rating"]  # type: ignore

von/backends/__init__.py

@@ -0,0 +1,9 @@
+"""Backends package for Von."""
+
+from .base import BaseBackend
+from .berta_backend import BertaBackend
+
+__all__ = [
+    "BaseBackend",
+    "BertaBackend",
+]

von/backends/base.py

@@ -0,0 +1,39 @@
+"""Abstract Base Class for Von Decision Backends."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Union
+from ..types import (
+    Choice,
+    ChoiceAnswer,
+    Noul,
+    NoulAnswer,
+    Question,
+    Score,
+    ScoreAnswer,
+    SystemOneResponse,
+)
+
+
+class BaseBackend(ABC):
+    """Base interface for all Von System One decision backends."""
+
+    @abstractmethod
+    def evaluate_choice(self, q_id: str, state_text: str, q: Choice) -> ChoiceAnswer:
+        pass
+
+    @abstractmethod
+    def evaluate_score(self, q_id: str, state_text: str, q: Score) -> ScoreAnswer:
+        pass
+
+    @abstractmethod
+    def evaluate_noul(self, q_id: str, state_text: str, q: Noul) -> NoulAnswer:
+        pass
+
+    @abstractmethod
+    def evaluate(
+        self,
+        state: Any,
+        questions: Dict[str, Union[Question, Dict[str, Any]]],
+        model: str,
+    ) -> SystemOneResponse:
+        pass

von/backends/berta_backend.py

@@ -0,0 +1,328 @@
+"""Native bidirectional Transformer encoder backend for Von (BERT / DeBERTa family)."""
+
+import json
+import os
+import threading
+from typing import Any, Dict, List, Optional, Union
+
+import torch
+
+from ..types import (
+    Choice,
+    ChoiceAnswer,
+    Noul,
+    NoulAnswer,
+    Question,
+    Score,
+    ScoreAnswer,
+    SystemOneResponse,
+    Usage,
+)
+from .base import BaseBackend
+
+
+MODEL_REGISTRY = {
+    "von-1.0": "checkpoints/von-modernbert-rlcd" if os.path.exists("checkpoints/von-modernbert-rlcd/config.json") else "wfzyx/von-1.0",
+    "modernbert": "checkpoints/von-modernbert-rlcd" if os.path.exists("checkpoints/von-modernbert-rlcd/config.json") else "wfzyx/von-1.0",
+    "deberta-v3": "MoritzLaurer/DeBERTa-v3-large-mnli-fever-anli-ling-wanli",
+    "deberta-xxl": "microsoft/deberta-v2-xxlarge-mnli",
+}
+
+
+def _format_state(state: Any) -> str:
+    if isinstance(state, str):
+        return state
+    try:
+        return json.dumps(state, indent=2, ensure_ascii=False)
+    except Exception:
+        return str(state)
+
+
+def _detect_device(device_str: Optional[str] = None) -> torch.device:
+    d_str = (device_str or os.environ.get("VON_DEVICE", "auto")).lower().strip()
+
+    # Handle AMD ROCm / HIP aliases
+    if d_str in ("rocm", "hip"):
+        if not torch.cuda.is_available():
+            raise RuntimeError(
+                "AMD ROCm requested, but PyTorch CUDA/ROCm is not available. "
+                "Ensure PyTorch was installed with ROCm support."
+            )
+        return torch.device("cuda")
+
+    # Handle DirectML (Windows AMD / Intel)
+    if d_str in ("dml", "directml"):
+        try:
+            import torch_directml
+            return torch_directml.device()
+        except ImportError:
+            raise RuntimeError(
+                "DirectML requested, but 'torch-directml' is not installed. "
+                "Run 'pip install torch-directml'."
+            )
+
+    if d_str != "auto":
+        return torch.device(d_str)
+
+    # Auto-detection: First-party native accelerators only (CUDA/ROCm -> Apple Silicon MPS -> CPU).
+    # DirectML on Windows is supported via explicit opt-in (--device dml) to avoid third-party driver clashing.
+    if torch.cuda.is_available():
+        return torch.device("cuda")
+    if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+        return torch.device("mps")
+    return torch.device("cpu")
+
+
+def get_device_description(device: torch.device) -> str:
+    if device.type == "cuda":
+        dev_name = torch.cuda.get_device_name(device) if torch.cuda.is_available() else "CUDA"
+        if getattr(torch.version, "hip", None) or any(w in dev_name.lower() for w in ["amd", "radeon", "instinct"]):
+            return f"AMD GPU [ROCm: {dev_name}]"
+        return f"NVIDIA GPU [CUDA: {dev_name}]"
+    elif device.type == "mps":
+        return "Apple Silicon [MPS]"
+    elif str(device).startswith("privateuseone"):
+        return "DirectML GPU [AMD/Intel]"
+    return "CPU"
+
+
+class BertaBackend(BaseBackend):
+    """Native non-autoregressive decision engine powered by bidirectional BERT/DeBERTa encoders."""
+
+    def __init__(self, variant: str = "deberta-v3", device: Optional[str] = None):
+        var_clean = variant.lower().strip()
+        self.variant = var_clean
+        self.model_id = MODEL_REGISTRY.get(var_clean, variant)
+        self.device = _detect_device(device)
+        self._model = None
+        self._tokenizer = None
+        self._entail_idx = 0
+        self._lock = threading.Lock()
+
+    def _get_model_and_tok(self):
+        with self._lock:
+            if self._model is None or self._tokenizer is None:
+                from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+                dtype = torch.float32
+                if self.device.type == "cuda":
+                    dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
+                elif self.device.type == "mps":
+                    dtype = torch.float16
+
+                self._tokenizer = AutoTokenizer.from_pretrained(self.model_id)
+                self._model = AutoModelForSequenceClassification.from_pretrained(
+                    self.model_id,
+                    torch_dtype=dtype,
+                ).to(self.device).eval()
+
+                # Check for calibration.json if using local checkpoint
+                calib_path = os.path.join(self.model_id, "calibration.json")
+                if os.path.exists(calib_path):
+                    try:
+                        with open(calib_path, "r", encoding="utf-8") as f:
+                            cdata = json.load(f)
+                            self._default_temp = float(cdata.get("temperature", 1.0))
+                    except Exception:
+                        self._default_temp = 1.0
+                else:
+                    self._default_temp = 1.0
+
+                # Detect entailment class index in id2label
+                id2label = getattr(self._model.config, "id2label", {})
+                for idx, lbl in id2label.items():
+                    if "entail" in lbl.lower():
+                        self._entail_idx = int(idx)
+                        break
+            return self._model, self._tokenizer
+
+    def evaluate_choice(
+        self,
+        q_id: str,
+        state_text: str,
+        q: Choice,
+        temperature: float = 1.0,
+        **kwargs,
+    ) -> ChoiceAnswer:
+        options = list(q.criteria.keys())
+        if not options:
+            return ChoiceAnswer(choice="", probabilities={}, confidence=0.0)
+
+        model, tok = self._get_model_and_tok()
+
+        # Build (premise, hypothesis) pairs
+        hypotheses = []
+        for opt in options:
+            desc = q.criteria.get(opt)
+            text = f"{q.instructions} {desc}" if desc else f"{q.instructions} {opt}"
+            hypotheses.append(text)
+
+        premises = [state_text] * len(options)
+        inputs = tok(
+            premises,
+            hypotheses,
+            padding=True,
+            truncation=True,
+            max_length=512,
+            return_tensors="pt",
+        ).to(self.device)
+
+        with torch.no_grad():
+            logits = model(**inputs).logits
+            entail_scores = logits[:, self._entail_idx]
+            scaled = entail_scores / max(temperature, 1e-4)
+            probs = torch.softmax(scaled, dim=-1).cpu().tolist()
+
+        best_idx = int(torch.argmax(entail_scores).item())
+        best_choice = options[best_idx]
+
+        prob_dict = {opt: round(float(p), 4) for opt, p in zip(options, probs)}
+        sorted_p = sorted(prob_dict.values(), reverse=True)
+        confidence = round(max(0.0, min(1.0, sorted_p[0] - (sorted_p[1] if len(sorted_p) > 1 else 0.0))), 3)
+
+        return ChoiceAnswer(
+            choice=best_choice,
+            probabilities=prob_dict,
+            confidence=confidence,
+        )
+
+    def evaluate_score(
+        self,
+        q_id: str,
+        state_text: str,
+        q: Score,
+        temperature: float = 1.0,
+        **kwargs,
+    ) -> ScoreAnswer:
+        levels = q.criteria
+        if not levels:
+            return ScoreAnswer(score=0.0, confidence=0.0, legend={}, probabilities={})
+
+        model, tok = self._get_model_and_tok()
+
+        legend: Dict[str, str] = {}
+        hypotheses = []
+        for i, item in enumerate(levels):
+            idx_str = str(i)
+            if isinstance(item, dict):
+                what = item.get("what", "")
+                examples = item.get("examples", [])
+                ex_str = f" Examples: {', '.join(examples)}" if examples else ""
+                desc = f"{what}{ex_str}".strip()
+            else:
+                desc = str(item)
+            legend[idx_str] = desc
+            hypotheses.append(f"{q.instructions} Level {i}: {desc}")
+
+        premises = [state_text] * len(levels)
+        inputs = tok(
+            premises,
+            hypotheses,
+            padding=True,
+            truncation=True,
+            max_length=512,
+            return_tensors="pt",
+        ).to(self.device)
+
+        with torch.no_grad():
+            logits = model(**inputs).logits
+            entail_scores = logits[:, self._entail_idx]
+            scaled = entail_scores / max(temperature, 1e-4)
+            probs = torch.softmax(scaled, dim=-1).cpu().tolist()
+
+        prob_dict = {str(i): round(float(p), 4) for i, p in enumerate(probs)}
+        weighted_score = round(sum(i * p for i, p in enumerate(probs)), 2)
+
+        sorted_p = sorted(probs, reverse=True)
+        confidence = round(max(0.0, min(1.0, sorted_p[0] - (sorted_p[1] if len(sorted_p) > 1 else 0.0))), 3)
+
+        return ScoreAnswer(
+            score=weighted_score,
+            confidence=confidence,
+            legend=legend,
+            probabilities=prob_dict,
+        )
+
+    def evaluate_noul(
+        self,
+        q_id: str,
+        state_text: str,
+        q: Noul,
+        temperature: float = 1.0,
+        **kwargs,
+    ) -> NoulAnswer:
+        model, tok = self._get_model_and_tok()
+
+        crit = q.criteria or {}
+        pos_crit = crit.get("true", "")
+        neg_crit = crit.get("false", "")
+
+        pos_hyp = f"{q.instructions} {pos_crit or 'Condition holds true.'}".strip()
+        neg_hyp = f"{q.instructions} {neg_crit or 'Condition is false or not satisfied.'}".strip()
+
+        premises = [state_text, state_text]
+        hypotheses = [pos_hyp, neg_hyp]
+
+        inputs = tok(
+            premises,
+            hypotheses,
+            padding=True,
+            truncation=True,
+            max_length=512,
+            return_tensors="pt",
+        ).to(self.device)
+
+        with torch.no_grad():
+            logits = model(**inputs).logits
+            entail_scores = logits[:, self._entail_idx]
+            scaled = entail_scores / max(temperature, 1e-4)
+            probs = torch.softmax(scaled, dim=-1).cpu().tolist()
+
+        prob_true = round(max(0.0, min(1.0, probs[0])), 4)
+        return NoulAnswer(noul=prob_true)
+
+    def evaluate(
+        self,
+        state: Any,
+        questions: Dict[str, Union[Question, Dict[str, Any]]],
+        model: str = "von-latest",
+    ) -> SystemOneResponse:
+        state_str = _format_state(state)
+        answers: Dict[str, Union[NoulAnswer, ChoiceAnswer, ScoreAnswer]] = {}
+        total_q_chars = 0
+
+        for q_id, q_data in questions.items():
+            if isinstance(q_data, dict):
+                q_type = q_data.get("type")
+                if q_type == "noul":
+                    q = Noul(**q_data)
+                elif q_type == "choice":
+                    q = Choice(**q_data)
+                elif q_type == "score":
+                    q = Score(**q_data)
+                else:
+                    raise ValueError(f"Unknown question type: {q_type} for question '{q_id}'")
+            else:
+                q = q_data
+
+            total_q_chars += len(q.instructions)
+
+            if isinstance(q, Noul):
+                answers[q_id] = self.evaluate_noul(q_id, state_str, q)
+            elif isinstance(q, Choice):
+                answers[q_id] = self.evaluate_choice(q_id, state_str, q)
+            elif isinstance(q, Score):
+                answers[q_id] = self.evaluate_score(q_id, state_str, q)
+
+        input_tokens = max(1, (len(state_str) + total_q_chars) // 4)
+        output_tokens = len(answers) * 8
+        if model in ("von-latest", "von-preview", "von-1.0.0", "von-1.0", "jev-latest", "jev-preview", None):
+            resolved_model = "von-1.0.0"
+        else:
+            resolved_model = model
+
+        return SystemOneResponse(
+            model=resolved_model,
+            answers=answers,
+            usage=Usage(input_tokens=input_tokens, output_tokens=output_tokens),
+        )

von/cli.py

@@ -0,0 +1,190 @@
+"""CLI entrypoint for Von."""
+
+import json
+import os
+import sys
+import click
+import uvicorn
+
+from .api import decide as api_decide
+from .api import judge as api_judge
+from .api import rate as api_rate
+from .api import system_one as api_system_one
+from .backends.berta_backend import _detect_device, get_device_description
+
+
+@click.group()
+@click.version_option(version="1.0.0", prog_name="von")
+def main():
+    """Von - Open Source System One Decision Model."""
+    pass
+
+
+@main.command()
+@click.option("--host", default="0.0.0.0", help="Host interface to bind on.")
+@click.option("--port", default=8000, type=int, help="Port to listen on.")
+@click.option("--backend", default="modernbert", type=click.Choice(["modernbert", "laya", "needle", "berta-v3"]), help="Decision backend to load.")
+@click.option("--device", default="auto", help="Compute device: 'auto', 'cuda', 'rocm', 'mps', 'dml', 'cpu'.")
+@click.option("--reload", is_flag=True, default=False, help="Enable auto-reload.")
+def serve(host: str, port: int, backend: str, device: str, reload: bool):
+    """Start the Von System One HTTP server."""
+    os.environ["VON_BACKEND"] = backend
+    if device and device != "auto":
+        os.environ["VON_DEVICE"] = device
+    dev_obj = _detect_device(device)
+    dev_desc = get_device_description(dev_obj)
+    click.echo(f"Starting Von Decision Server [{backend} on {dev_desc}] on http://{host}:{port}")
+    uvicorn.run("von.server:app", host=host, port=port, reload=reload)
+
+
+@main.command()
+@click.argument("text")
+@click.option(
+    "-c",
+    "--choices",
+    required=True,
+    help="Comma-separated choices (e.g. 'billing,bug_report,feature_request').",
+)
+@click.option(
+    "-i",
+    "--instructions",
+    default="Which option best describes the input?",
+    help="Instructions for classification.",
+)
+@click.option(
+    "--device",
+    default="auto",
+    help="Compute device: 'auto', 'cuda', 'mps', 'cpu'.",
+)
+def decide(text: str, choices: str, instructions: str, device: str):
+    """Classify input text among discrete choices."""
+    if device and device != "auto":
+        os.environ["VON_DEVICE"] = device
+    opts = [c.strip() for c in choices.split(",") if c.strip()]
+    if not opts:
+        click.echo("Error: At least one choice must be provided.", err=True)
+        sys.exit(1)
+
+    ans = api_decide(state=text, choices=opts, instructions=instructions)
+    click.echo(
+        json.dumps(
+            {
+                "choice": ans.choice,
+                "confidence": ans.confidence,
+                "probabilities": ans.probabilities,
+            },
+            indent=2,
+        )
+    )
+
+
+@main.command()
+@click.argument("text")
+@click.option(
+    "-i",
+    "--instructions",
+    required=True,
+    help="Boolean judgment question (e.g. 'Is the server down?').",
+)
+@click.option(
+    "--pos",
+    default="",
+    help="Explicit criteria description for True condition.",
+)
+@click.option(
+    "--neg",
+    default="",
+    help="Explicit criteria description for False condition.",
+)
+@click.option(
+    "--device",
+    default="auto",
+    help="Compute device: 'auto', 'cuda', 'mps', 'cpu'.",
+)
+def judge(text: str, instructions: str, pos: str, neg: str, device: str):
+    """Evaluate a yes/no judgment (Noul) and return the probability."""
+    if device and device != "auto":
+        os.environ["VON_DEVICE"] = device
+    crit = {}
+    if pos:
+        crit["true"] = pos
+    if neg:
+        crit["false"] = neg
+
+    prob = api_judge(state=text, instructions=instructions, criteria=crit or None)
+    click.echo(
+        json.dumps(
+            {
+                "type": "noul",
+                "instructions": instructions,
+                "noul": prob,
+            },
+            indent=2,
+        )
+    )
+
+
+@main.command()
+@click.argument("text")
+@click.option(
+    "-l",
+    "--levels",
+    required=True,
+    help="Comma-separated descriptions of ordered levels from 0 to N-1.",
+)
+@click.option(
+    "-i",
+    "--instructions",
+    default="Rate where the state falls on this scale:",
+    help="Instructions for rating.",
+)
+@click.option(
+    "--device",
+    default="auto",
+    help="Compute device: 'auto', 'cuda', 'mps', 'cpu'.",
+)
+def rate(text: str, levels: str, instructions: str, device: str):
+    """Rate text on an ordered multi-level scale (Score)."""
+    if device and device != "auto":
+        os.environ["VON_DEVICE"] = device
+    lvl_list = [lvl.strip() for lvl in levels.split(",") if lvl.strip()]
+    if len(lvl_list) < 2:
+        click.echo("Error: At least two levels must be provided.", err=True)
+        sys.exit(1)
+
+    ans = api_rate(state=text, criteria=lvl_list, instructions=instructions)
+    click.echo(
+        json.dumps(
+            {
+                "type": "score",
+                "score": ans.score,
+                "confidence": ans.confidence,
+                "legend": ans.legend,
+                "probabilities": ans.probabilities,
+            },
+            indent=2,
+        )
+    )
+
+
+@main.command()
+@click.argument("request_file", type=click.Path(exists=True))
+def eval(request_file: str):
+    """Evaluate a JSON request file containing state and questions."""
+    with open(request_file, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    state = data.get("state")
+    questions = data.get("questions")
+    model = data.get("model", "von-latest")
+
+    if state is None or questions is None:
+        click.echo("Error: JSON must contain 'state' and 'questions' fields.", err=True)
+        sys.exit(1)
+
+    resp = api_system_one(state=state, questions=questions, model=model)
+    click.echo(json.dumps(resp.model_dump(), indent=2))
+
+
+if __name__ == "__main__":
+    main()