Instructions to use cogni-x/wearable-intelli-model with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use cogni-x/wearable-intelli-model with Transformers:

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

pipe = pipeline("text-generation", model="cogni-x/wearable-intelli-model")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("cogni-x/wearable-intelli-model")
model = AutoModelForCausalLM.from_pretrained("cogni-x/wearable-intelli-model", 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

llama.cpp

How to use cogni-x/wearable-intelli-model with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf cogni-x/wearable-intelli-model:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf cogni-x/wearable-intelli-model:Q4_K_M

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf cogni-x/wearable-intelli-model:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf cogni-x/wearable-intelli-model:Q4_K_M

Use pre-built binary

# Download pre-built binary from:
# https://github.com/ggerganov/llama.cpp/releases
# Start a local OpenAI-compatible server with a web UI:
./llama-server -hf cogni-x/wearable-intelli-model:Q4_K_M
# Run inference directly in the terminal:
./llama-cli -hf cogni-x/wearable-intelli-model:Q4_K_M

Build from source code

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-server llama-cli
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama-server -hf cogni-x/wearable-intelli-model:Q4_K_M
# Run inference directly in the terminal:
./build/bin/llama-cli -hf cogni-x/wearable-intelli-model:Q4_K_M

Use Docker

docker model run hf.co/cogni-x/wearable-intelli-model:Q4_K_M

LM Studio
Jan

vLLM

How to use cogni-x/wearable-intelli-model with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/cogni-x/wearable-intelli-model:Q4_K_M

SGLang

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

Ollama
How to use cogni-x/wearable-intelli-model with Ollama:
```
ollama run hf.co/cogni-x/wearable-intelli-model:Q4_K_M
```
Unsloth Desktop
Docker Model Runner
How to use cogni-x/wearable-intelli-model with Docker Model Runner:
```
docker model run hf.co/cogni-x/wearable-intelli-model:Q4_K_M
```

Lemonade

How to use cogni-x/wearable-intelli-model with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull cogni-x/wearable-intelli-model:Q4_K_M

Run and chat with the model

lemonade run user.wearable-intelli-model-Q4_K_M

List all available models

lemonade list

Atomic Chat

Request Access to Wearable Intelligence Model

This model is gated. Please fill out the form below to request access. Access is manually reviewed and approved by Admin. Approved users will receive a notification and can then download the model files.

By requesting access, you agree to use this model only for lawful, non-clinical, and non-diagnostic purposes.

Wearable Intelligence - Gemma 3 270M (QLoRA)

🔒 Gated Model — Access Required This model is access-controlled. To download the weights or GGUF files, you must **[request access] and be manually approved by the Admin team. Unapproved users will not be able to download any files from this repository.

This repository contains the fine-tuned Gemma 3 270M Instruct model, specifically optimized for wearable health, fitness, and wellness applications. It has been trained on a custom synthetic dataset comprising health metrics, user queries, recommendations, and conversational logging scenarios relevant to smartwatches, rings, and other health sensors.

In addition to the raw HuggingFace model files, this repository hosts optimized GGUF quantized variants for local, low-latency, and resource-constrained edge execution (e.g., in mobile apps or local model servers).

Model Details

Base Model: google/gemma-3-270m-it
Parameters: 270M
Fine-Tuning Method: QLoRA (SFT)
Maximum Sequence Length: 2048 tokens
Context Window: 32768 tokens (base capability)
Primary Domain: Wearable Health & Wellness (Activity tracking, sleep analysis, heart rate interpretations, hydration/nutrition advice, and health-related summaries)

GGUF Quantized Variants

The model has been converted and quantized to the GGUF format using the latest llama.cpp tools.

The following variants are available in this repository:

File Name	Quantization Type	Size	Recommended Use Case
`gemma-3-270m-wearable.F16.gguf`	FP16 (Baseline)	526 MB	High-end systems; no loss in precision compared to original weights.
`gemma-3-270m-wearable.Q8_0.gguf`	Q8_0 (8-bit)	286 MB	High fidelity, balanced precision and memory efficiency.
`gemma-3-270m-wearable.Q5_K_M.gguf`	Q5_K_M (5-bit)	256 MB	Recommended general-purpose quantization for mobile devices.
`gemma-3-270m-wearable.Q4_K_M.gguf`	Q4_K_M (4-bit)	250 MB	Ultra low memory footprint; ideal for low-end mobile devices and micro-controllers.

Usage Instructions

1. Using HuggingFace Transformers (Python)

You can run the model directly using HuggingFace's transformers library:

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline

model_id = "cogni-x/wearable-intelli-model"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

messages = [
    {"role": "user", "content": "I only slept 5 hours last night and my resting heart rate is up by 5 bpm. What should I focus on today?"}
]

pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
output = pipe(messages, max_new_tokens=256, return_full_text=False)
print(output[0]['generated_text'])

2. Using `llama.cpp` (CLI)

To run a quantized GGUF variant locally, compile llama.cpp and use the following command:

# Run interactive chat mode using Q5_K_M variant
./llama-cli \
  -m gemma-3-270m-wearable.Q5_K_M.gguf \
  -p "<start_of_turn>user\nI ran 10k today. What recovery meals do you recommend?<end_of_turn>\n<start_of_turn>model\n" \
  -n 256 \
  -co

Fine-Tuning & Training Log

Training Dataset: ~60,000 synthetic clinical, activity, sleep, and nutrition query-response pairs.
Hardware Used: NVIDIA Tesla V100-SXM3-32GB.
Epochs: 5
Optimizer: AdamW (Paged 8-bit)
Learning Rate: 2e-4 (with Cosine annealing scheduler)
LoRA Configurations:
- Rank (R): 32
- Alpha: 64
- Dropout: 0.05
- Target Modules: q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj

Detailed training logs and metrics can be visualized on Weights & Biases:

Intended Use

This model is intended to act as an on-device/local personal health agent assistant. It is optimized to:

Summarize fitness and sensor logs.
Provide conversational advice about hydration, recovery, activity plans, and sleep hygiene.
Classify and map wearable telemetry descriptors to simple human concepts.

Disclaimer: This model is for informational and educational purposes only. It is not a medical diagnostic tool and should not be used to replace professional medical advice.

Downloads last month: 12

Safetensors

Model size

0.3B params

Tensor type

BF16

Model tree for cogni-x/wearable-intelli-model

Base model

google/gemma-3-270m

Finetuned

google/gemma-3-270m-it

Quantized

(347)

this model