Instructions to use build-small-hackathon/slipstream-gemma4-e2b-evm with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use build-small-hackathon/slipstream-gemma4-e2b-evm with Transformers:

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

pipe = pipeline("text-generation", model="build-small-hackathon/slipstream-gemma4-e2b-evm")
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)

# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("build-small-hackathon/slipstream-gemma4-e2b-evm")
model = AutoModelForMultimodalLM.from_pretrained("build-small-hackathon/slipstream-gemma4-e2b-evm")
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=40)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use build-small-hackathon/slipstream-gemma4-e2b-evm with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/build-small-hackathon/slipstream-gemma4-e2b-evm

SGLang

How to use build-small-hackathon/slipstream-gemma4-e2b-evm 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 "build-small-hackathon/slipstream-gemma4-e2b-evm" \
    --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": "build-small-hackathon/slipstream-gemma4-e2b-evm",
		"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 "build-small-hackathon/slipstream-gemma4-e2b-evm" \
        --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": "build-small-hackathon/slipstream-gemma4-e2b-evm",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use build-small-hackathon/slipstream-gemma4-e2b-evm with Docker Model Runner:
```
docker model run hf.co/build-small-hackathon/slipstream-gemma4-e2b-evm
```

slipstream-gemma4-e2b-evm / README.md

ashaibani

Add model card

d78e90a verified 21 days ago

preview code

Raw

History Blame Contribute Delete

3.18 kB

	---
	license: gemma
	base_model: google/gemma-4-E2B-it
	library_name: transformers
	pipeline_tag: text-generation
	language:
	- en
	datasets:
	- build-small-hackathon/slipstream-evm-sft
	tags:
	- project-controls
	- earned-value-management
	- forecasting
	- lora
	- distillation
	- code-action
	- agent
	- slipstream
	---
	# Slipstream - gemma-4-E2B (EVM forecasting agent)

	A small code-action agent that forecasts a project's final cost (EAC) and finish period from a
	mid-flight Earned Value Management snapshot. It is `google/gemma-4-E2B-it` (E2B (~2B effective),
	Gemma-4 (text decoder)) fine-tuned (LoRA, then merged) to run a single-tool reasoning loop: it writes Python
	that calls a curated forecasting toolkit (Earned Schedule, CPI/SPI formulas, a Gompertz growth
	curve, a reference-class ML regressor, and the TimesFM / Chronos time-series foundation models),
	reconciles their disagreeing estimates, and submits one answer.

	It was distilled from a DeepSeek V4 teacher: the teacher's reasoning traces over a diverse
	simulated project corpus were filtered to a 367-trace SFT set
	([`build-small-hackathon/slipstream-evm-sft`](https://huggingface.co/datasets/build-small-hackathon/slipstream-evm-sft)) and the student trained with
	assistant-only loss (reasoning + tool-call tokens only). This makes a sub-5B, edge / air-gapped
	forecaster that matches the classical project-controls baseline and approaches its cloud teacher.

	## Results (held-out real projects, 40% complete, n=107)

	Scored on 107 real completed projects (Batselier/OR-AS DSLIB), apples-to-apples with every
	baseline. `valid` = produced a usable forecast; `EAC error` = median absolute % error on final cost;
	`finish error` = median absolute error in periods.

	\| Method \| valid \| EAC error \| finish error \|
	\| --- \| --- \| --- \| --- \|
	\| gemma-4-E2B (this model, distilled) \| 0.991 \| 2.31% \| 0.63 periods \|
	\| gemma-4-E2B (base, before distillation) \| 0.664 \| 3.21% \| 0.75 periods \|
	\| Earned Schedule (classical baseline) \| 1 \| 2.37% \| 1 periods \|
	\| DeepSeek V4 teacher (cloud) \| 1 \| 2.4% \| 0.6 periods \|

	Distillation lifts a base model that could barely operate the tool-call format into a reliable
	forecaster that rivals the classical canon and its own teacher.

	## Usage

	```python
	from transformers import AutoModelForCausalLM, AutoTokenizer

	repo = "build-small-hackathon/slipstream-gemma4-e2b-evm"
	tok = AutoTokenizer.from_pretrained(repo)
	model = AutoModelForCausalLM.from_pretrained(repo, torch_dtype="bfloat16")
	```

	The model is trained to act through a single `run_python(code=...)` tool call and to call
	`submit(finish, eac)` from inside that code. See the Slipstream project for the agent loop, the
	forecasting toolkit, and the full benchmark.

	## Licence and attribution

	This is a derivative of [`google/gemma-4-E2B-it`](https://huggingface.co/google/gemma-4-E2B-it) and is released
	under the base model's licence (gemma).
	You must comply with the upstream terms.
	Training data: [`build-small-hackathon/slipstream-evm-sft`](https://huggingface.co/datasets/build-small-hackathon/slipstream-evm-sft).

	Built for the Hugging Face Build Small hackathon.