Instructions to use everettjf/ezjev-4b-s3 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use everettjf/ezjev-4b-s3 with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("image-text-to-text", model="everettjf/ezjev-4b-s3")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("everettjf/ezjev-4b-s3")
model = AutoModelForMultimodalLM.from_pretrained("everettjf/ezjev-4b-s3", device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use everettjf/ezjev-4b-s3 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "everettjf/ezjev-4b-s3"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "everettjf/ezjev-4b-s3",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker

docker model run hf.co/everettjf/ezjev-4b-s3

SGLang

How to use everettjf/ezjev-4b-s3 with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "everettjf/ezjev-4b-s3" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "everettjf/ezjev-4b-s3",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "everettjf/ezjev-4b-s3" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "everettjf/ezjev-4b-s3",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Docker Model Runner
How to use everettjf/ezjev-4b-s3 with Docker Model Runner:
```
docker model run hf.co/everettjf/ezjev-4b-s3
```

ezjev-4b-s3

File size: 3,134 Bytes

---
base_model: everettjf/ezjev-4b-s2
library_name: transformers
tags: [decision-model, jev, typed-decisions, jevbench]
---

# ezjev-4b-s3

**Project page: [xnu.app/ezjev](https://xnu.app/ezjev/)** — overview, downloads and a step-by-step quickstart. Code: [github.com/everettjf/ezjev](https://github.com/everettjf/ezjev) (MIT).

A typed-decision model (Jev-style `/v1/systemone`: `choice`, `noul`, `score` questions answered with a probability
per option from one forward pass, no generated tokens). Full merged weights, BF16.

Lineage: `Qwen/Qwen3.5-4B` → LoRA r=16 (including the DeltaNet linear-attention layers), merged → `ezjev-4b`
→ stage 2 (`ezjev-4b-s2`) → stage 3 (this model, LR 5e-5, 40% replay). Loss: cross-entropy + Brier over the option
letters; one global temperature (1.34) fitted on our own held-out dev split.

## Training data

- Stages 1–2: train (or dev) splits of public datasets only, decontaminated against the Jev Decision Index 0.2.1 suite
  (exact-sentence and 13-gram overlap; overlapping rows removed).
- Stage 3 adds ~20k **programmatically generated** decisions in the style of long business documents: multi-clause
  policies with amendments and definitions, business-day / time-zone / month-end / leap-year deadlines, pro-rated
  refunds, unit conversions, alias → master-record → rule lookups, answer-correctness judging, under-specified cases
  with a "cannot determine" label, and trap / priority-ladder routing. Scenarios, names and numbers are random;
  gold labels are computed by code. **No JevBench item (public or held-out) was used for training**; the public
  JevBench items were used only for the self-test below.

## Serving

Pinned stack: vLLM 0.30.0 + [llm2jev](https://github.com/tic-top/llm2jev) 0.6.1 (commit `2b252d5`), chat prompt, temperature 1.34.

```bash
pip install "vllm==0.30.0" "llm2jev==0.6.1"
vllm serve everettjf/ezjev-4b-s3 --max-logprobs 256 --return-tokens-as-token-ids --port 8000 \
  --max-model-len 32768 --additional-config '{"gdn_prefill_backend": "triton"}'
llm2jev --model everettjf/ezjev-4b-s3 --backend vllm --url http://127.0.0.1:8000 --port 8080 --temperature 1.34
# -> POST http://127.0.0.1:8080/v1/systemone (TypeSafe wire format)
```

`gdn_prefill_backend: triton` is only needed when the image has no `nvcc`; `VLLM_USE_FLASHINFER_SAMPLER=0` likewise.
One GPU with ≥ 24 GB is enough (weights ~9 GB).

## Self-test on the JevBench public items

JevBench revision `bb05a33`, `typesafe` adapter, serial requests, one RTX PRO 6000, raw latency (no ×2 adjustment):

| Tier | Correct | ECE | p50 / p95 latency |
|---|---|---|---|
| easy | 48/48 | 0.008 | 0.033 / 0.035 s |
| original | 71/72 | 0.087 | 0.033 / 0.034 s |
| hard (public) | 68/111 | 0.133 | 0.071 / 0.110 s |
| **all** | **187/231 (0.810)** | **0.044** | 0.034 / 0.099 s |

Mean input ≈ 668 tokens per decision (≈ $0.027 per 1,000 decisions at a $0.04/M input price).

## Licence note

The Qwen base is Apache-2.0. Some training sources are non-commercial (e.g. ANLI, CC BY-NC 4.0) and some have no
stated licence; check them before any commercial use of these weights.