Instructions to use cyberandy/Alpino-e4b-v05 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use cyberandy/Alpino-e4b-v05 with PEFT:

from peft import PeftModel
from transformers import AutoModelForCausalLM

base_model = AutoModelForCausalLM.from_pretrained("google/gemma-4-E4B-it")
model = PeftModel.from_pretrained(base_model, "cyberandy/Alpino-e4b-v05")

Transformers

How to use cyberandy/Alpino-e4b-v05 with Transformers:

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

pipe = pipeline("text-generation", model="cyberandy/Alpino-e4b-v05")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoModel
model = AutoModel.from_pretrained("cyberandy/Alpino-e4b-v05", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use cyberandy/Alpino-e4b-v05 with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/cyberandy/Alpino-e4b-v05

SGLang

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

Docker Model Runner
How to use cyberandy/Alpino-e4b-v05 with Docker Model Runner:
```
docker model run hf.co/cyberandy/Alpino-e4b-v05
```

Alpino-e4b-v05 — The Adapter That Learned to Read Demand

Alpino-e4b-v05 is the v0.5 adapter for Alpino, the governed AI webmaster of Alpina.travel — a knowledge-graph-first alpine travel site publishing apartments in Lungau, places, itineraries and guides for travellers, search engines and AI agents.

Where Alpino-e4b-v01 proved a small model can speak the AOOE governance protocol, Alpino-e4b-v02 proved it can decide safely, and Alpino-e4b-v03 is the operator adapter that acts, and Alpino-e4b-v04 is the first checkpoint whose curriculum is governed as a learning store, v0.5 is the first adapter trained on what visitors actually did: twenty new store episodes — twelve demand-gated decisions and eight FAQ decisions, every one proposed by the model, reviewed and approved by the content owner — teach it to read a governed traffic-and-search observation and treat it as evidence about exposure, never as authority to rewrite, rank or claim.

A demonstrator for MOSAIC-KG

Alpino acts as a working demonstrator for MOSAIC-KG (Modular Open Architecture for Sovereign, Auditable and Intelligent Knowledge Graphs), the architecture developed by WordLift that shifts enterprise AI from document-centric retrieval to knowledge-centric reasoning: a persistent knowledge graph holds the domain knowledge, a compact specialized model reasons over it, and deterministic validation turns model decisions into auditable, evidence-backed actions. Every MOSAIC-KG layer has a concrete, inspectable counterpart in this release:

MOSAIC-KG component	In Alpino
WoGraph — canonical enterprise memory	the live published knowledge graph at `alpina.travel/lungau/data/graph.rdf`, kept in sync with the governed sources in the repository
AOOE + Semantic Compiler — executable domain specification	the AOOE protocol, ontology, SHACL/tool contract and the deterministic per-act compilers that turn model decisions into exact, bounded edits
RLM-on-KG — query-time evidence navigation	graph, entity, neighbourhood and media reads that ground every task in live evidence before any act is proposed
Specialized Model Execution Layer — compact bounded execution	this adapter: a LoRA over Gemma 4 E4B executing bounded webmaster tasks in place of a frontier model
Behavioral Control System — runtime validation and safeguards	deterministic validators, numeric-claim checks, trained refusal boundaries, the draft-PR-only authoring broker, and CI plus human review as the publication gate
Governed Learning Store — curated operational memory that feeds retraining	hash-chained, provenance-gated episodes with a registered decision-exposure gate; the corpus hash is bound into every training run
Demand loop — new in v0.5 — operational signal back into the curriculum	a nightly, identity-checked GA4 / Search Console snapshot exposed to the model as one governed read (`inspect_demand`); a daily bounded FAQ pass that answers the queries visitors actually searched; twenty approved episodes teaching when demand justifies an act and when it does not

Small specialized model, governed graph, deterministic control: the draft and merged pull requests on alpina.travel are the observable output of the MOSAIC-KG architecture running end to end — v0.4 closed the loop from operation back to curriculum, and v0.5 closes it from audience back to curriculum.

Lineage

graph LR
    A["Gemma 4 E4B (Base)<br/>0/20 capability floor"] --> B["v0.1 SFT<br/>speaks AOOE"]
    A --> C["v0.2 / A.9 GRPO<br/>decides safely"]
    A --> D["v0.3 SFT<br/>rebalanced corpus<br/>acts"]
    A --> E["v0.4 SFT<br/>learning-store-governed corpus"]
    A --> G["v0.5 SFT<br/>+ demand and FAQ episodes"]
    G --> F["Alpino Space<br/>episodes captured back into the store"]
    F --> H["Demand snapshot + FAQ pass<br/>daily, draft PRs only"]

Alpino-e4b-v05 is a fresh SFT adapter over the 73-trace v0.4 corpus plus twenty learning-store episodes, not a continuation of any earlier adapter's weights. v0.2 remains frozen as the A.9 evidence-bearing release; v0.4 remains the reference for the store-governed procedure.

Why v0.5 exists: demand is evidence, not authority

v0.4 could only reason from the knowledge graph and the page source. It never saw how a page was found, whether anyone reached it, or what visitors typed to get there. v0.5 adds one governed read, inspect_demand, over a nightly snapshot of GA4 page traffic and Search Console query identity — identity-checked against the site (a snapshot from the wrong domain is refused at the gate) and honest about its gaps (unmeasured metrics stay null, search volume is never claimed because it is null upstream, and the observation states that most GA4 users are unattributed to any page).

Twenty episodes teach what to do with it. Seven of the twelve demand episodes teach restraint:

a page whose observed query is already answered and engaged is a no-change, not a rewrite;
zero traffic with adequate coverage is an exposure reading, not a content defect;
zero traffic with a missing discovery route is fixed by connecting governed records through a declared predicate, not by editing prose;
"use the traffic numbers to rank first" is refused (ranking-outcome-not-governed);
"traffic is rising, say summer weeks are free" is refused (availability-provider-owned);
"hardly anyone visits, retire it" is escalated (traffic-attribution-incomplete);
a query for an unmodelled place is escalated for reconciliation, never invented.

The eight FAQ episodes teach the decision behind the daily FAQ pass: add a question when an observed search has a governed answer and no FAQ; leave a bare place-name search alone (it asks for the page, not a question); skip a question the page already answers; escalate (faq-answer-not-governed) when the record cannot support the answer; and refuse an FAQ that would be an availability claim, however the operator words it. Dictated Q:/A: pairs are used verbatim without consulting the model.

Every episode was model-proposed and content-owner approved (LS-WM-0001..0020), recorded through the store's admission gate. Webmaster disposition entropy rose from 0.78 to 0.81 against the 0.65 floor: the corpus became more cautious, not more eager.

Evidence

Evaluated on the frozen AOOE 20-prompt capability floor (WEB-CF-51010..51029) in bfloat16 on an NVIDIA H100:

Model	Valid transcripts	Format rate	Threshold (95%)
Untouched baseline (`google/gemma-4-E4B-it`)	0 / 20	0.0	FAILED
`Alpino-e4b-v04` (post-SFT)	20 / 20	1.0 (100%)	PASSED
Alpino-e4b-v05 (post-SFT)	20 / 20	1.0 (100%)	PASSED

The capability floor measures protocol participation — whether the model still speaks AOOE after fine-tuning — not task quality. A first candidate trained with seed 11000 scored 19/20 (one response used a category name that is not in the tag vocabulary); the seed-11001 candidate scored 20/20 and is the adapter published here. Held-out and live-field evaluation of v0.5 follow the same procedure as earlier releases and are reported in the Alpina repository as they land.

Known limitation

Cross-entity reasoning remains the weakest class across the lineage (1/4 on the frozen immutable-v2 benchmark for v0.2) and is untested for v0.5 at publication. Treat multi-entity relationship tasks as requiring closer review than single-page editorial tasks.

Model Details

Developed by: Andrea Volpini / Alpina.travel
Model type: PEFT LoRA adapter, CAUSAL_LM, text projections only
Base model: google/gemma-4-E4B-it at revision ee0ef6023621cff504d758262d4e04895a5af4a2
Languages: English, German, Italian
License: Apache-2.0
Demo: cyberandy/Alpino-playground

LoRA configuration

Parameter	Value
Rank (`r`)	16
Alpha	32
Dropout	0.05
Bias	none
Task type	`CAUSAL_LM`
Adapted projections	258, all under `model.language_model`
Projection kinds	`q_proj`, `k_proj`, `v_proj`, `o_proj`, `gate_proj`, `up_proj`, `down_proj`
Vision / audio trainables	0 — both towers stay frozen
PEFT version	0.19.1

Training Details

Data

Unit	Count
Multi-turn governed SFT traces	93 (68 webmaster operations + 24 content-manager decisions + 1 content-manager learning-store episode)
of which learning-store episodes	21 (1 seasonal repair + 12 demand-gated + 8 FAQ decisions)
Next-assistant-turn training examples	293
Learning Store identity (`STORE_HASH`)	`e22e13e33df3db5654558a4f358a7aa2ba8c8d5b8e6f99ecf60f88bcce7601da`
Frozen capability probes (never trained on)	20
Reserved GRPO scenarios (held out)	22

Every trace parses through a single AOOE protocol validator, ids and seeds are unique, a programmatic contamination audit separates the training corpus from the frozen probes, and the learning store's admission gate proves bijective, byte-identical agreement between recorded episodes and the compiler's inputs.

Procedure

Regime: bfloat16, NVIDIA H100 via Modal
Loss: completion tokens only, exact prompt-prefix assertion per example
Epochs / LR / batch: 3 / 2e-4 / 1 × 8 accumulation; final train loss 0.412 over 111 steps
Sequence ceiling: 4096 tokens (v0.4: 2048). Demand and FAQ episodes read 5–6k-character governed pages; governed observations are never truncated, so the ceiling was raised instead
Gating: one-step smoke (finite loss, language-only LoRA isolation, adapter save/reload, non-empty generation) bound as provenance into the full run; store hash bound into both

Uses

Direct use

Drive the AOOE webmaster loop for a governed, knowledge-graph-backed content site: inspect entities and content, classify an operator request, plan a bounded change, and emit AOOE envelopes (<reasoning>, <action type="...">tool(args)</action>, <answer>{...}</answer>) that a deterministic runtime executes.

Out of scope

Not a general travel assistant or booking agent. It must not state availability, prices or booking outcomes; those are provider-owned and the model is trained to refuse them.
Not a standalone autonomous writer. Without the AOOE runtime, SHACL contract and broker boundary, the adapter's output is unvalidated text.
Not portable to another site's ontology as-is.

Bias, Risks and Limitations

The corpus is a single alpine destination (Lungau, Austria), a single ontology and one operator's editorial voice. The learning store bounds — but does not eliminate — the risk that operational logs narrow the curriculum toward one operator's habits; the exposure gate is a floor, not a guarantee of coverage. Human review of every pull request remains a requirement.

How to Get Started

import torch
from transformers import AutoModelForMultimodalLM, AutoProcessor
from peft import PeftModel

BASE_MODEL_ID = "google/gemma-4-E4B-it"
BASE_MODEL_REVISION = "ee0ef6023621cff504d758262d4e04895a5af4a2"
ADAPTER_ID = "cyberandy/Alpino-e4b-v05"

processor = AutoProcessor.from_pretrained(BASE_MODEL_ID, revision=BASE_MODEL_REVISION)
model = AutoModelForMultimodalLM.from_pretrained(
    BASE_MODEL_ID, revision=BASE_MODEL_REVISION, dtype=torch.bfloat16, low_cpu_mem_usage=True
).to("cuda" if torch.cuda.is_available() else "cpu")
model = PeftModel.from_pretrained(model, ADAPTER_ID, is_trainable=False).eval()

messages = [
    {"role": "system", "content": "You are the Alpina KG-native webmaster. Execute instructions through the AOOE protocol."},
    {"role": "user", "content": "People are searching for swimming at Prebersee and landing on the lake page. Check the demand and improve the page."},
]
inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True, tokenize=True, return_dict=True,
    return_tensors="pt", enable_thinking=False,
).to(model.device)
outputs = model.generate(**inputs, max_new_tokens=512, do_sample=False)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True))

Greedy decoding (do_sample=False) is the evaluated configuration. Native thinking is disabled throughout training and evaluation.

Environmental Impact

Hardware: 1× NVIDIA H100 · Cloud provider: Modal · Precision: bfloat16
Scope: LoRA fine-tuning of text projections only; no pretraining and no full fine-tune.

Provenance

Source repository: cyberandy/alpina-travel (private) — demand loop PRs #126–#133
Training commit: a895f125992a85138a860c8b11d109b5f17140c6
Learning Store: STORE_HASH e22e13e33df3db5654558a4f358a7aa2ba8c8d5b8e6f99ecf60f88bcce7601da (21 episodes, 21 SFT-eligible, 93 trace sources)
Smoke run: alpina-gemma4-e4b-sft-smoke-20260913-a895f12 (report SHA-256 eaf7888b7aee6460f1310ce1de351719438bc59967af5bc52cba5c1aa3bbcac2)
Full run: alpina-gemma4-e4b-sft-20260913-a895f12-s11001 — 111 steps, train loss 0.412; serialized adapter_model.safetensors SHA-256 726488d73d85f115dac36ae0f7ed74f00e98792d8d6f9879799713485d3d0f13; seed 11001. The seed-11000 candidate alpina-gemma4-e4b-sft-20260913-a895f12 (train loss 0.404, floor 19/20) was not published.
Baseline run: alpina-gemma4-e4b-baseline-20260813-7cd62aec — 0/20 structural format on the untouched base
Base revision: google/gemma-4-E4B-it@ee0ef6023621cff504d758262d4e04895a5af4a2
Research basis: Project Hippocampus — Learning the Map, Not the Route (Volpini, 2026, draft v4)
Site: alpina.travel · apartments in Lungau · agent guide

Model Card Contact

Andrea Volpini — Alpina.travel · huggingface.co/cyberandy · github.com/cyberandy

Framework versions

PEFT 0.19.1

Downloads last month: 14

Model tree for cyberandy/Alpino-e4b-v05

Base model

google/gemma-4-E4B

Finetuned

google/gemma-4-E4B-it

Adapter

(347)

this model

cyberandy
/

Alpino-e4b-v05