Instructions to use plantwaterer/haimation with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use plantwaterer/haimation with Transformers:

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

pipe = pipeline("text-generation", model="plantwaterer/haimation")
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("plantwaterer/haimation")
model = AutoModelForMultimodalLM.from_pretrained("plantwaterer/haimation", 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 plantwaterer/haimation with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "plantwaterer/haimation"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "plantwaterer/haimation",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/plantwaterer/haimation

SGLang

How to use plantwaterer/haimation 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 "plantwaterer/haimation" \
    --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": "plantwaterer/haimation",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

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 "plantwaterer/haimation" \
        --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": "plantwaterer/haimation",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use plantwaterer/haimation with Docker Model Runner:
```
docker model run hf.co/plantwaterer/haimation
```

haimation

Decision Index 0.3 public score: 67.44 (self-run).

A continued full fine-tune of plantwaterer/liquamen (google/gemma-4-31B-it) with its own last-layer head.
Engine: haimation:Engine, in-process, from this repository. Engine, head, store and executor files are pinned by MD5 in PINS.json and checked at load.
Kit: apolinario/decision-index @ 9eb2dbe2a358004c8782c66e40a83ac07b953fec.

Usage

REPO=$(python -c "from huggingface_hub import snapshot_download; print(snapshot_download('plantwaterer/haimation'))")
PYTHONPATH="$REPO" python -m decision_index run --engine haimation:Engine --option model="$REPO" --compact --out runs/haimation

Inference

Precision, attention, averaging, head: bf16; packed document attention (full-attention layers bidirectional within a prompt, sliding-window layers causal); for requests under a length limit, the answer is averaged over 4 option orders. Ordinary choices: the letter logits' softmax at one fitted temperature T = 1.2984 (no posterior). Yes / no decisions: a Laplace posterior on binary (yes / no) decisions, integrated.
Knowledge store and executed answers. After that pass, a question can be answered another way when all of these hold:
- it is the request's only question;
- its options are all plain numbers, or all yes / no (true / false) words;
- the first pass gives no option at least 0.925 (numeric options) or 0.75 (yes / no options).
A numeric question first goes to a bundled knowledge store (country-level statistics; see Third-party components). If the store returns a confident value that matches exactly one option, that option is the answer. Otherwise the model writes one short Python function (greedy decoding, at most 320 new tokens), and a bundled exact-arithmetic executor runs it, in-process, as a GPU kernel. Where the kernel cannot load, the executor's interpreter runs instead, with identical results. The answer changes only when the returned value equals exactly one option and the function computed it (a bare constant return does not count).

In both cases the chosen option gets probability 0.99, and the others share 0.01 in proportion to the first pass. In every other case the output is the first pass's, bit for bit.
Hardware: one GPU with at least 75 GB (bf16 weights 62 GB); fits one RTX PRO 6000 (96 GB). The executor's kernel ships prebuilt (sm_75 to sm_120).

Latency (one RTX PRO 6000 Blackwell, 1,000-row board sample)

Median 312 ms, mean 827 ms, p80 964 ms, p95 2,371 ms. Model load and warm-up (about three minutes) are not included.

Third-party components

haimation/xr_runtime/, the executor: derived from LOOM by Mehmet Kerem Turkcan and contributors (https://github.com/mkturkcan/Loom), Apache License 2.0, modified. Its LICENSE and NOTICE are in that directory.
store_table.json, the knowledge store's table: licensed CC BY-SA 4.0. It contains data from Our World in Data (CC BY 4.0), compiled from the producers listed in DATA_NOTICE, including V-Dem (CC BY-SA 4.0). Values are rounded to three significant figures and re-indexed, so the table is a modified version of the original data. Full attribution: DATA_NOTICE.

Training data

Continued from plantwaterer/liquamen, whose card lists that training data, its licences and attributions; they carry over. Added here:

Decontaminated train splits of CLINC150 (CC BY 3.0) and BANKING77 (CC BY 4.0) in the training mixture.
ChessBench training positions from google-deepmind/searchless_chess (CC BY 4.0; portions CC0 from lichess.org), labelled with Stockfish.
LLM Bayesian Teaching Data (https://doi.org/10.5281/zenodo.17677329, CC BY 4.0), MedMCQA (https://github.com/medmcqa/medmcqa, MIT), and synthetic questions generated by the author.

No test split of any benchmark was used.

Capacity limits

Context: max_len 32,768 tokens; nothing truncated.

Downloads last month: 311

Safetensors

Model size

31B params

Tensor type

F32

BF16

Model tree for plantwaterer/haimation

Base model

google/gemma-4-31B

Finetuned

google/gemma-4-31B-it

Finetuned

(348)

this model