Example scripts
The examples/ folder holds complete programs, one file each. The descriptions below are generated from the scripts’ docstrings. Every script but one has a command-line interface, and --help lists its options. train_supervised.py is a Python experiment, which dew train runs.
The first group trains one kind of model on one dataset. The second group runs a full job, from data to scored or exported weights. Each script in the second group takes --smoke, which replaces the real settings with the repository’s tiny fixtures, a few steps and one CPU device; the test suite runs them that way. End-to-end runs gives both command lines for each.
Train one model
Section titled “Train one model”readme_demo.py
Section titled “readme_demo.py”Train a toy language model, resume it, learn preferences, and generate images.
Run from an installed Dew checkout, without downloads: JAX_PLATFORMS=cpu python examples/readme_demo.py —out runs/readme-demo
Use a new output directory for each invocation. The generated data demonstrates mechanics, not language ability, preference quality, or useful image generation.
train_lm.py
Section titled “train_lm.py”Train a byte-level language model on a token store, then generate.
The text is split into lines to train on and lines held out, and each is tokenized into a store of its own by dew data export: training reads every token of its store, and the held-out store is what examples/evaluate_and_serve.py scores.
curl -o data/shakespeare.txt --create-dirs \ https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txthead -n 36000 data/shakespeare.txt > data/shakespeare-train.txttail -n +36001 data/shakespeare.txt > data/shakespeare-val.txtdew data export data/shakespeare-train.txt data/shakespeare --tokenizer byte --eos --read memorydew data export data/shakespeare-val.txt data/shakespeare-val --tokenizer byte --eos --read memorypython examples/train_lm.py --tokens data/shakespeare --epochs 4python examples/train_lm.py --tokens data/shakespeare --steps 20 --sequence-length 32 # smoke runtrain_masked_lm.py
Section titled “train_masked_lm.py”Train MDLM on TinyStories, score its held-out perplexity bound and unmask stories.
python examples/train_masked_lm.py --out runs/mdlm-tinystoriespython examples/train_masked_lm.py --dataset Salesforce/wikitext \ --config wikitext-103-raw-v1 --prompts "The game" --out runs/mdlm-wikitextJAX_PLATFORMS=cpu python examples/train_masked_lm.py --smoke --out /tmp/mdlm-smokeThe first run reads the dataset’s train split with datasets and tokenizes it once into Dew’s cache, each row a document ended by the tokenizer’s eos id. Later runs read the cached ids offline. The head 1% of that stream is held out, and training never reads it. A bidirectional CausalTransformer learns MDLM’s negative ELBO (MaskedDiffusionObjective). The mask is one id past the tokenizer’s vocabulary, so no text can contain it. Every --eval-every steps the trainer scores the held-out windows, and val/perplexity is the exponential of the NELBO per token, the bound MDLM reports.
At the end the script loads the run back with dew.pipeline, which returns a MaskedGeneration task over the saved weights. It scores the whole held-out split with those weights, unmasks a continuation of each of --prompts, and writes result.json and samples.txt beside the run. --smoke writes a few lines of text as JSON, byte-tokenizes them and trains a tiny model for four steps on one CPU device. It needs no network.
train_flowers.py
Section titled “train_flowers.py”Train a pixel-space diffusion model on prepared Oxford Flowers ArrayRecords.
CUDA_VISIBLE_DEVICES=0 JAX_PLATFORMS=cuda python examples/train_flowers.py \--data ~/.cache/dew/datasets/oxford_flowers102/2.1.1 --steps 1000It trains on every record: no split is held out, and nothing is scored. With --profile N it is a profiling run, which traces N steps into <output>/profile after two warm-up steps and draws no samples:
CUDA_VISIBLE_DEVICES=0 JAX_PLATFORMS=cuda python examples/train_flowers.py \--data ~/.cache/dew/datasets/oxford_flowers102/2.1.1 --steps 50 --profile 20train_diffusion.py
Section titled “train_diffusion.py”Train a text-to-image diffusion model on Oxford Flowers, sample from it, export the weights.
python examples/train_diffusion.py --data-path /data/oxford_flowers102/2.1.1 --epochs 200python examples/train_diffusion.py --data-path /data/oxford_flowers102/2.1.1 --steps 20 --image-size 32train_jepa.py
Section titled “train_jepa.py”Train an I-JEPA encoder on Oxford Flowers, probe it, save the encoder.
python examples/train_jepa.py --data-path /data/oxford_flowers102/2.1.1 --epochs 300python examples/train_jepa.py --data-path /data/oxford_flowers102/2.1.1 \ --steps 20 --image-size 32 --patch-size 4banking77_decisions.py
Section titled “banking77_decisions.py”Fine-tune a decision model on BANKING77, then answer and score it.
The script scores Laya’s released checkpoint on BANKING77’s 77 intents zero-shot, fine-tunes it on the training split, fits its temperatures on held-out rows, and scores the test split again. --backbone qwen instead trains a LoRA adapter on Qwen3-0.6B under a fresh decision head.
python examples/banking77_decisions.py --backbone laya --epochs 3 --run runs/laya-banking77python examples/banking77_decisions.py --backbone qwen --epochs 3 --learning-rate 1e-4 \ --run runs/qwen-banking77Each score is one JSON line, on stdout and appended to --out: accuracy, expected calibration error, the area under the risk-coverage curve and the log loss. The run checkpoints into --run every ten minutes and resumes from it when started again.
train_supervised.py
Section titled “train_supervised.py”A classifier written as a Python experiment and trained with dew train.
dew train examples/train_supervised.py --set trainer.steps=600 --set model.hidden=64This file builds the run in plain Python: its own Flax model and loss, two interleaved spirals it writes once as JSON lines, and Supervised, which trains any model on a loss over its outputs, with no subclass of Objective. run is the RunConfig; each --set changes one field of it, read as that field’s own type reads it. dew train imports the file as the module train_supervised, so run.json names the model and the loss by import path (train_supervised:MLP), and a new process rebuilds the same run from that record alone:
PYTHONPATH=examples dew train checkpoints/train_supervised/run.json \ --trust train_supervised --set trainer.checkpoint_dir=againWithout --set, the record continues the run from its own checkpoints.
pinn_burgers.py
Section titled “pinn_burgers.py”A physics-informed network to float64 precision: the self-similar blowup profile of 1D Burgers.
python examples/pinn_burgers.py --out runs/burgerspython examples/pinn_burgers.py --model mlp --out runs/burgers-mlpJAX_PLATFORMS=cpu python examples/pinn_burgers.py --smoke --out /tmp/burgers-smokeThe inviscid Burgers equation u_t + u u_x = 0 blows up in finite time along the self-similar profile u = tau^lambda U(x tau^-(1 + lambda)), whose profile solves
F(y) = -lambda U + ((1 + lambda) y + U) U_y = 0, lambda = 0.5,on y in [0, inf). As Zhao et al. (arXiv 2605.24278, Appendix J, after Wang et al. 2026) set it up, the network learns U~ over eta in [-c, c], c = 30, y = sinh(eta), and the profile is odd with the known tail built in:
U(eta) = U~(eta) - U~(-eta) - (y / (1 + y))^15 y^(lambda / (1 + lambda)).Each step draws a batch of eta uniform in [0, c) from its key and minimizes the mean of F^2 + (dF/deta)^2 in float64, with Adam at 1e-4 decayed to zero by a cosine over the run (epsilon 1e-15). --model pyramid (the default) reads U~ through a 12-level Fourier feature pyramid, grids of 2 to 4096 points of 4 channels, at the coordinate (eta + c) / (2c), into a tanh MLP of width 20 and four layers; --model mlp is that MLP alone, on eta. --damping steps by Gauss-Newton instead of Adam (dew.gauss_newton.gauss_newton, the residuals’ system its objective states), damped as Levenberg-Marquardt’s.
The run writes metrics.json to --out: on the grid eta_i = c (i + 1/2) / 1000, the mean of F^2 and log10 of the largest |F|, which the paper reports (its Table 2) as 6.29e-19 and -8.46 for the pyramid after 20,000 steps of 4096 points, and 6.21e-7 and -2.41 for the MLP alone. On one H100 this example’s default run reaches 2.26e-18 and -7.91 in 26 minutes, and --model mlp 5.68e-8 and -2.95 in 15.
forward_only_lm.py
Section titled “forward_only_lm.py”A language model trained without backpropagation, against the same model trained with it.
python tools/noise_fineweb.py data/noisepython examples/forward_only_lm.py --data data/noise --method perturbation --out runs/forwardpython examples/forward_only_lm.py --data data/noise --method backprop --out runs/backpropJAX_PLATFORMS=cpu python examples/forward_only_lm.py --smoke --out /tmp/forward-smoketools/noise_fineweb.py prepares Noise’s fixed FineWeb data (qlabs-eng/noise): rows of 2,049 ids of its BPE-4096 tokenizer, checked against its pinned hashes. This trains Dew’s decoder at the shape of Dust’s 37.7M-parameter GPT (8 layers of width 512, 8 heads of 64, 4,096 ids, rows of 2,048 predictions, windows of half a row on three layers in four and the last layer whole, logits capped at 15, an untied head) on the first --tokens of it, one epoch of 8 rows a step, and scores Noise’s validation rows every --eval-every steps. Four of Dust’s block features are not Dew’s (ledger 1852): its value embeddings, its residual mix with the first layer’s input, its parameter-free norms and its ungated ReLU^2 MLP, which a gated SwiGLU of the same parameter count stands in for. So the model is Dust’s shape, not Dust’s model, and the comparison is of the two learning rules on one model.
--method perturbation trains it by node perturbation (dew.objectives.perturbation.NodePerturbation), Dust’s estimator in Dew’s general form: every Dense and Embed output jittered by --draws antithetic pairs a step, each token credited by its own loss, with Adam at 1.5e-3, betas (0.7, 0.95), and a linear warmdown over the last 30% of steps, Dust-with-Adam’s settings in Noise. --method backprop trains it by backpropagation with the same Adam and schedule at --backprop-lr. Each run writes curves.json to --out: the training and validation losses by step, and the wall time of the training.
Run a whole job
Section titled “Run a whole job”train_flowers_tpu.py
Section titled “train_flowers_tpu.py”Text-to-image DiT from scratch on Oxford Flowers, across a TPU slice.
Prepare the TFDS ArrayRecords once:
python -c "import tensorflow_datasets as tfds; tfds.builder('oxford_flowers102', \ data_dir='~/.cache/dew/datasets').download_and_prepare(\ file_format='array_record')"Then launch the same file on every worker of the slice:
python examples/train_flowers_tpu.py \ --data ~/.cache/dew/datasets/oxford_flowers102/2.1.1 --steps 200000--data reads whichever of two layouts it is given: the TFDS version directory, its captions made from the class names, or a directory of captioned ArrayRecords Dew published (its manifest.json). The smoke run writes a handful of synthetic records in that second layout and trains on them on one CPU device:
JAX_PLATFORMS=cpu python examples/train_flowers_tpu.py --smoke --out /tmp/flowers-smokesft_gemma4.py
Section titled “sft_gemma4.py”Full-weight SFT of a Gemma 4 text decoder on a Hub chat dataset.
python examples/sft_gemma4.py --model google/gemma-4-E2B \ --dataset hf://datasets/allenai/tulu-3-sft-mixture --steps 4000 --out runs/gemma4-sftThe run holds the first --held-out conversations out for its validation perplexity, packs the rest into windows, counts the loss on assistant targets alone, shards the weights over the visible devices and accumulates micro-batches into one update. It ends by exporting the trained weights to the Hugging Face layout, so transformers and Pretrained.load both read them, and the run directory itself scores through the harness:
python -m dew.eval --model dew --model_args run=runs/gemma4-sft/checkpoints/gemma4-sft \ --tasks hellaswag --limit 64The sft preset reads the Hub dataset through its hf:// source, so the URL on the command line is what the run trains on: it renders every conversation with the checkpoint’s own chat template and packs them into windows.
JAX_PLATFORMS=cpu python examples/sft_gemma4.py --smoke --out /tmp/gemma4-smokesft_diffusion_gemma.py
Section titled “sft_diffusion_gemma.py”LoRA SFT of DiffusionGemma on chat data, with the base weights host-streamed.
The optimizer updates only the adapter, and Layout(host=("variables",)) keeps the whole train state on the host between steps, with the scanned stack fetching one layer at a time. The 26B-A4B base has not been run through it:
python examples/sft_diffusion_gemma.py \ --model google/diffusiongemma-26B-A4B-it \ --chat data/tulu-3-sft.parquet --steps 2000--chat is an hf:// Hub dataset, a .jsonl file or a parquet file of conversations, which the canvas preset reads and renders with the checkpoint’s own chat template. Each assistant turn becomes one row: the conversation before it is the clean prompt, and the turn alone fills the canvases the denoiser scores. The run writes the PEFT adapter directory Adapter.save produces, which transformers loads, then loads the base again through dew.pipeline, merges the adapter into it and writes the decoded canvases to samples.txt. Image-conditioned training on real Oxford Flowers is examples/sft_diffusion_gemma_images.py; it uses a fresh small model, not the released 26B model’s qualification.
JAX_PLATFORMS=cpu python examples/sft_diffusion_gemma.py --smoke --out /tmp/dg-smokesft_diffusion_gemma_images.py
Section titled “sft_diffusion_gemma_images.py”Image-conditioned DiffusionGemma SFT from scratch on Oxford Flowers, scored by naming held-out flowers.
python examples/sft_diffusion_gemma_images.py --out runs/flowers-captionJAX_PLATFORMS=cpu python examples/sft_diffusion_gemma_images.py --smoke --out /tmp/flowers-caption-smokeThis trains a fresh DiffusionGemma, a byte-vocabulary text stack with a small Gemma 4 vision tower, with BlockDiffusionObjective, the published DiffusionGemma SFT loss. It starts from random weights; it does not load or fine-tune the released 26B-A4B checkpoint. Flowers has class labels rather than human captions, so each target is “a photo of a
The run reads the dataset’s three splits from the Hub at the commit --revision names, prepared once by datasets, and the data chain decodes each image once into memory, shrunk so that its shorter side is --staging-size pixels. Training reads the train and validation splits with random crops and flips. Every --eval-every steps the trainer scores the canvas cross entropy over held-out test images. At the end the script loads the run back with dew.pipeline, which returns a BlockGeneration task. That task captions every test image, and result.json records how many captions name the right flower. --smoke writes a few synthetic images as parquet and trains a tiny model for four steps on one CPU device, on the same path. It needs no network.
train_rlvr.py
Section titled “train_rlvr.py”RLVR: GRPO on programs that must pass their tests, rolled out asynchronously.
python examples/train_rlvr.py --backend native --steps 40 --out runs/rlvr-nativepython examples/train_rlvr.py --backend vllm --steps 40 --out runs/rlvr-vllmpython examples/train_rlvr.py --backend sglang --steps 40 --out runs/rlvr-sglangEvery prompt asks for a Python program that reads two integers from stdin and prints a stated function of them. A completion’s reward is the fraction of three hidden test cases its program passes, run in a SandboxFleet. --runner container runs each program in a network-less python:3.12-slim container. --runner process (the default, and the only choice where Docker is absent, as on Colab) runs it as a process with a wall clock, CPU time and memory cap; that process has your user’s filesystem and network.
Rollouts run on a rollout server while the trainer updates. --backend native serves them from Dew’s own continuous-batching Server in this process, with weights pushed in place. --backend vllm and --backend sglang start that engine’s OpenAI-compatible server on an export of the same checkpoint, sample from it by token ids, and push weights by writing safetensors and asking the engine to reload them (vLLM’s development endpoints, VLLM_SERVER_DEV_MODE=1; SGLang’s /update_weights_from_disk). --vllm and --sglang name the executables, which may live in their own environments. A RolloutScheduler over a PromptSource draws one batch ahead of the update, so each batch is at most one update stale; the GRPO objective’s importance cap corrects for it. A completion that runs out of --new-tokens is still scored and trained on (truncation="score"): a closed code block followed by cut-off prose can pass every test.
--turns N gives each task up to N attempts through an EnvironmentSource, Dew’s in-process multi-turn session source. An attempt that fails a test gets back how many of the three it passed and tries again; the reward is the last attempt’s. A harness would render the report as a user turn with the chat template instead, and tools/audit_template.py tells whether that stays append-only.
The run prints one line per update and writes rewards.json to --out with the per-update reward, policy version and lag, the mean reward of the first and last --window updates, and the seconds each weight push took.
JAX_PLATFORMS=cpu python examples/train_rlvr.py --smoke --out /tmp/rlvr-smokeJAX_PLATFORMS=cpu python examples/train_rlvr.py --smoke --turns 2 --out /tmp/rlvr-smoke-turnstrain_harbor.py
Section titled “train_harbor.py”Agentic GRPO: a harness runs in Harbor sandboxes, a gateway records its
model calls, and Dew trains on them.
python examples/train_harbor.py --tasks path/to/harbor/task ... --gateway http://127.0.0.1:9090 \ --sandbox-gateway http://proxy:9091 --engines http://127.0.0.1:8011 --served runs/harbor/servedJAX_PLATFORMS=cpu python examples/train_harbor.py --smoke --out /tmp/harbor-smokeEach update draws --prompts Harbor tasks and runs --groups trials of each through HarnessSource(Harbor(...)): Harbor starts the task’s sandbox and the harness (mini-swe-agent by default), the harness’s model calls go through rllm-model-gateway to the engines, and the gateway’s traces become the session’s calls. RolloutScheduler admits complete groups at most --max-lag updates stale and packs them; the GRPO objective trains on the sampled ids only. Publication pushes each version to every engine with SafetensorsReload and then stamps the gateway, so every call carries the version it was sampled under.
The example writes the policy to --served and then waits, up to --ready-timeout seconds, for the gateway to route to an engine: launch the engines on --served (vLLM with VLLM_SERVER_DEV_MODE=1) and the gateway in front of them while it waits, as docs/concepts/post_training.md describes (warm each engine, size the gateway’s health interval, keep its admin routes away from the sandboxes).
--smoke needs neither Harbor nor an engine. A stand-in harbor script runs a two-turn harness against an in-process gateway whose engine is Dew’s own server on the committed tiny Qwen2, so the ids and likelihoods it records are the policy’s own draws. The reward is the share of vowels in the replies. Two updates on CPU.
evaluate_and_serve.py
Section titled “evaluate_and_serve.py”Score a finished run four ways, then compare it against a served model.
Perplexity over held-out tokens, an lm-evaluation-harness suite, greedy continuations, and, for a diffusion run, CLIPScore of a sampled grid against its prompts and FID against a reference set. Everything is read through dew.pipeline, so a run directory, a published checkpoint and a Hub repository all work.
python examples/evaluate_and_serve.py --run runs/shakespeare/checkpoints \ --tokens data/shakespeare-val --tasks hellaswag arc_easy --harness-limit 200python examples/evaluate_and_serve.py --run runs/shakespeare/checkpoints \ --image-run runs/flowers-tpu/checkpoints/flowers-256 \ --reference-images data/flowers-heldoutpython examples/evaluate_and_serve.py --image-run runs/flowers-tpu/checkpoints/flowers-256 \ --reference-images data/flowers-heldout--run scores a language run; --image-run alone scores a diffusion run and nothing else.
The same suites run from the command line, which is the harness’s own entry point with Dew’s model registered:
python -m dew.eval --model dew --model_args run=runs/shakespeare/checkpoints \ --tasks hellaswag --limit 200--openai-base-url adds a served comparison: the same prompts through the OpenAI SDK (vLLM serves the same API), or --ollama-host through ollama’s. Each SDK is an optional extra, needed only when its flag is given; with the endpoint unreachable, the report says so and the rest of the run is unaffected. The OpenAI key is OPENAI_API_KEY when set; a vLLM server started without --api-key takes any key, so an unset one sends vLLM’s placeholder.
JAX_PLATFORMS=cpu python examples/evaluate_and_serve.py --smoke --out /tmp/eval-smokeSample and inspect
Section titled “Sample and inspect”sample_text_to_image.py
Section titled “sample_text_to_image.py”Sample the pretrained text-to-image model over prompts, seeds and samplers.
Run from the repository root on a GPU. By default the script downloads the model from the Hugging Face Hub:
python examples/sample_text_to_image.py--model takes another Hub repository, pinned as repo@revision or not, or a Dew run directory, read through TextToImage.from_run:
python examples/sample_text_to_image.py --model RUN_DIRThe default model, dewml/hybrid-dit-176m, is a hybrid DiT of state-space and attention blocks trained with Dew. Its denoiser holds 175.6M parameters, beside a 123.1M-parameter CLIP text encoder and an 83.7M-parameter Stable Diffusion autoencoder, and it samples 256x256 images.
Each sampler draws one batch per seed, holding every prompt. The output directory gets one PNG per image, one grid per sampler (rows are prompts, columns are seeds) and manifest.json, which records each image’s prompt, seed, sampler, steps and guidance, and each batch’s wall time. The first batch of a sampler includes compiling it, or reading it from JAX’s compilation cache.
moe_mesh.py
Section titled “moe_mesh.py”Train a small mixture-of-experts decoder on a device mesh, generate from it, and draw where its tokens go.
On eight CPU devices simulated in one process, as a mesh of data 2, expert 2 and fsdp 2:
XLA_FLAGS=--xla_force_host_platform_device_count=8 JAX_PLATFORMS=cpu python examples/moe_mesh.py --out runs/moe-meshOn one accelerator, where the experts cannot be split, each device computes every expert:
python examples/moe_mesh.py --out runs/moe-mesh-gpu --expert 1 --fsdp 1 --dispatch globalThe training text mixes three kinds of line: short English sentences, sums and assignments. Before every training step the script runs the step’s batch through the step’s parameters once more and reads the experts each token’s router picked. For each MoE layer it counts the slots each device sends to every other device, and predicts, by the exchange’s own rule, the most exchange rounds any expert group needs for them. The drawing reads the placement from the objects the run used: the device grid from the mesh, each device’s experts and kernel slice from the expert kernel’s sharding, each device’s rows from the sharding the layout gives the layer’s input, and the all-to-all operations the compiled training step’s program holds.
After training, dew.inference.serving.Server generates greedy continuations of eight prompts on the same mesh, with the model’s own dispatch. (dew.sampling.generate refuses the exchange dispatch until jax-ml/jax#40907 is fixed.)
Writes OUT/moe-mesh.json with every step’s traffic, and OUT/moe-mesh.svg, an animation with a frame every snapshot_every steps and a last frame that routes the generated text.
route_decisions.py
Section titled “route_decisions.py”Send each request to the Laya checkpoint that can read it.
Laya ships an English checkpoint and a multilingual one in the same Hub repository. A deployment that serves both picks one per request: text in a non-Latin script, or Latin text with many letters English does not use, goes to the multilingual model, and everything else to the English one. This is a simplified version of Laya’s own router (laya/router.py). That router also reads stop words, so it catches Latin text with no accented letters at all, such as most Italian; it keeps the most recently used checkpoints resident; and it accepts a caller’s language code. A service that knows its users’ language should pass that instead of guessing.
python examples/route_decisions.pyserve_decisions.py
Section titled “serve_decisions.py”Serve a decision model over HTTP, in TypeSafe Jev’s wire format.
Dew has no HTTP server of its own. Decide.systemone takes a Jev request body and returns a Jev response body, so serving it is a few lines of any web framework; this uses Starlette, which the serve extra installs with uvicorn:
uv pip install "dewml[serve] @ git+https://github.com/AshishKumar4/dew" \ --extra-index-url https://pypi.dewml.dev/simplepython examples/serve_decisions.py --model convaiinnovations/laya --port 8000python examples/serve_decisions.py --run runs/tickets--model loads a released Laya checkpoint (with --subfolder multilingual for the multilingual one) or a joint-head release, and --run a DecisionObjective run with the calibration saved into it. --dtype chooses the compute dtype (bfloat16 on a GPU), and --max-len, --head-max-len and --option-tokens widen the layout’s budgets. POST /v1/systemone takes what Jev’s endpoint takes and answers as it answers, so a client written for Jev only changes its base URL:
curl -s localhost:8000/v1/systemone -H 'content-type: application/json' -d '{ "state": "I was charged twice for March, fix it today.", "questions": {"urgent": {"type": "noul", "instructions": "Is this urgent?"}}}'A request Jev would refuse gets a 422 with the reason, as Jev’s does. With --api-key (or DEW_API_KEY) set, a request must carry Authorization: Bearer <key>, and gets a 401 without it. --details adds Laya’s extra answer fields (a noul’s confidence, abstention, how much of the state was read); --strict answers exactly as Jev’s endpoint does, dropping the request fields Jev does not know, such as images. --whole refuses, with a 422 naming the maximum context length, a request the layout could answer only by cutting its state, instructions or options, as Decision Index requires of an engine:
python examples/serve_decisions.py --run runs/encoder --whole --dtype bfloat16 \ --max-len 8192 --head-max-len 6144 --option-tokens 512python -m decision_index pipeline --edition 0.2.1 --engine http \ --option base_url=http://127.0.0.1:8000 --out runs/di-encoderThe task is served by Dew’s serving engine (dew.inference.engine.Engine) as a scoring server (dew.inference.scoring.ScoringServer): concurrent requests are answered together, one forward pass a turn over the rows waiting, up to --batch-rows rows and --batch-tokens of their padded tokens a pass (the task’s Budget), each as it would be alone; a request Jev would refuse gets its own 422 and the others their answers. GET /health answers once the model is loaded.