Instructions to use netis-ai/smlr-logs-4b with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use netis-ai/smlr-logs-4b with Transformers:

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

pipe = pipeline("text-generation", model="netis-ai/smlr-logs-4b")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, PolicyMultiLane

tokenizer = AutoTokenizer.from_pretrained("netis-ai/smlr-logs-4b")
model = PolicyMultiLane.from_pretrained("netis-ai/smlr-logs-4b", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.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(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use netis-ai/smlr-logs-4b with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/netis-ai/smlr-logs-4b

SGLang

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

Docker Model Runner
How to use netis-ai/smlr-logs-4b with Docker Model Runner:
```
docker model run hf.co/netis-ai/smlr-logs-4b
```

You need to agree to share your contact information to access this model

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

SMLR Logs 4B is a research preview. Please provide basic contact information to help us understand the model's research and operational use cases.

SMLR-Logs-4B — Streaming Multi-Lane Reasoner

A fused event-driven streaming reasoner built on Qwen3-4B. Instead of the usual "full input → one answer", it consumes an event/log stream, keeps state, runs several reasoning lanes in parallel, calls tools, and folds its own structured memory back into the input:

S_t = Model(S_{t-1}, E_t, R_t)     # state = Model(prev state, new event, tool result)

This is the logs tier of SMLR (cross-source log root-cause + alerting). Weights are the m7 adapter merged into Qwen3-4B (self-contained, no separate adapter needed).

What's in the model

A single forward gives a policy decision + every lane's next token in parallel:

policy_head → one of 10 timing actions: WAIT NOTE SUMMARY QUESTION VERIFY QUERY_TOOL WARN ALERT RESOLVE REVISE
6 lane heads (observation reasoning public_output notes state_patch actions) decode their own JSON channel from the same prefill — wall-clock = prefill + max(lane), not the sum.

Core behaviour is discriminate-then-alert: QUERY_TOOL → read the discriminative tool field → ALERT with the root cause.

Intended use

Real-time monitoring of logs / event streams — detect a cross-source incident early, find the root cause, prescribe a remedy. Secondary: metrics streams, dictation/transcript streams (text). Not a chat model.

Evaluation (logs_heldout, hardened evaluator, cascade off)

This merged model, over 3 independent runs (n=12 incidents each):

run	detect	root_cause	alert
1	0.917	0.917	0.917
2	0.833	0.750	0.750
3	0.917	0.917	0.917
band	0.83–0.92	0.75–0.92 (mean ≈0.86)	0.75–0.92

Root-cause sits in the 0.75–0.92 band, mean ≈0.86, consistent with the pre-merge adapter (which was 0.833 stable across 3 runs). The bf16 LoRA merge adds a little run-to-run variance (it nudges some borderline argmax decisions). Zero false alerts in every run. Zero-shot transfer to unseen k8s events is modest with restraint preserved — not a target domain.

Honest limitations. The held-out set is small (n=12): single-run scores carry ~±1 incident (±0.08) of GPU-argmax run-to-run noise — read the band, not a point. This is the cascade-off base reasoner, a research artifact, not a hardened production service (no auth / persistence / ops layer).

How to run

This model is not a vanilla CausalLM — it needs SMLR's lane-parallel decode loop. Use the SMLR runtime:

from runtime.vla_client import VLAClient   # from the SMLR repo

# merged release dir loads directly — no separate base, no PEFT
client = VLAClient(base="path/to/smlr-stream-4b", adapter="path/to/smlr-stream-4b")
upd, meta = client.call(tier=None, system=SYS, user_obj=frame, max_tokens=256, extra={})
# upd carries: public_output {mode, text}, reasoning, hypotheses, actions(tool calls), ...

See example_infer.py and the SMLR repository for the full streaming runtime (event-sourcing player, tool loop, layered memory).

Training

Distilled from a 27B teacher by event-sourcing replay (the teacher's lane/tool/policy behaviour over recorded streams), m7 recipe: ~15.7k frames, 6 lanes incl. an actions lane for the tool loop, QLoRA (r32/α64), then merged to bf16.

License

Apache-2.0, inherited from the Qwen3-4B base. The merged weights are redistributable.

Downloads last month: -

Safetensors

Model size

6B params

Tensor type

BF16

Model tree for netis-ai/smlr-logs-4b

Base model

Qwen/Qwen3-4B-Base

Finetuned

Qwen/Qwen3-4B

Finetuned

(1030)

this model