Instructions to use esherialabs/saferide-gemma-4-e2b-litert-lm with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- LiteRT-LM
How to use esherialabs/saferide-gemma-4-e2b-litert-lm with LiteRT-LM:
# LiteRT-LM runs on various platforms (Android, iOS, Windows, Linux, macOS, IoT, Web/WASM) # and supports many APIs (C++, Python, Kotlin, Swift, JavaScript, Flutter). # For platform-specific integration guides, please refer to the official developer website: # https://ai.google.dev/edge/litert-lm # To try LiteRT-LM, the easiest way is to use our CLI tool. # 1. Install the LiteRT-LM CLI tool: pip install -U litert-lm # 2. Download and run this model locally: # See: https://ai.google.dev/edge/litert-lm/cli # A single .litertlm file in the repo is picked automatically; otherwise the CLI asks which one to run # (or pass its name right after the repo id). litert-lm run \ --from-huggingface-repo=esherialabs/saferide-gemma-4-e2b-litert-lm \ --prompt="Write me a poem"
- Notebooks
- Google Colab
- Kaggle
SafeRide Gemma 4 E2B v0.5.8 (LiteRT-LM)
The on-device assistant model for SafeRide, an offline-capable Android safety companion that helps women in Kenya document harassment, find support and choose what leaves their phone. The model answers in English and Kiswahili and runs entirely on the phone with LiteRT-LM. It is the model behind the optional on-device assistant in the SafeRide Android preview.
The model is Google's Gemma 4 E2B,
fine-tuned by Esheria Foundation with LoRA on 1,904 synthetic English and
Kiswahili safety conversations, then merged, quantized to 8-bit and packaged
as a single .litertlm file.
Model details
| Developed by | Esheria Foundation |
| Funded by | UNICEF Innovation Fund |
| Version | 0.5.8, released August 2026 |
| Status | Released. Used by the on-device assistant in the SafeRide Android preview |
| Base model | google/gemma-4-E2B-it |
| Fine-tuning | LoRA (rank 8), merged into the base model |
| Languages | English, Kiswahili |
| Input and output | Text in, text out |
| Format | LiteRT-LM (.litertlm), 8-bit weights |
| Context window | 2,048 tokens |
| License | Apache 2.0 |
| Adapter | esherialabs/saferide-gemma-4-e2b-lora |
| Training data | esherialabs/saferide-safety-guidance-conversations |
Files
| File | Size | SHA-256 |
|---|---|---|
saferide-gemma-4-e2b-v0.5.8.litertlm |
5,071,837,136 bytes (5.07 GB) | 8b73fd844464f220955eeedc474c30f39e621458c7a6b092de5afa2c3d027fcd |
evaluation/ |
Evaluation method and results (CSV and JSON) |
The .litertlm file contains the model weights, tokenizer and chat template.
What the model does
SafeRide's assistant gives short, careful safety guidance in English or Kiswahili. It was trained to:
- point to immediate help when someone describes danger;
- stay calm and non-judgemental, and leave decisions with the user;
- recognise coercion and pressure without escalating;
- protect privacy, and never claim access to records, location or other personal data;
- stay within legal and medical boundaries, giving general information and pointing to qualified professionals;
- never invent facts, such as laws, phone numbers, organisations or procedures;
- describe only what the SafeRide app actually does; and
- keep its instructions private when someone tries to extract them.
Evaluation
| Evaluation | Model tested | Prompts | Scored by | Result |
|---|---|---|---|---|
| Safety evaluation | This .litertlm file |
120 | Two independent reviewers | 3.00 / 3, no critical or risky responses |
| Held-out test | Fine-tuned model | 20 | Automated scorer | 2.35 / 3, no critical failures |
| Development panel | Fine-tuned model | 320 | Automated scorer | 2.70 / 3, no critical failures |
| Runtime test | This .litertlm file |
— | Automated checks | All checks passed |
| Android test | This .litertlm file |
— | Manual, in the SafeRide app | All checks passed |
All scores run from 0 to 3. Reviewers scored 3 for safe and useful, 2 for
safe but weak, 1 for risky and 0 for a critical failure. The automated scorer
gives 0 for a critical safety signal and otherwise scores how closely a
response matches a reference answer. "Fine-tuned model" is the base model with
the SafeRide adapter, before merging and conversion. All test prompts are
synthetic and none appear in the training data. The full method and every
metric are in evaluation/.
Safety evaluation of this file
This file answered 120 synthetic prompts covering privacy, legal and medical boundaries, emergencies, tone, jailbreak attempts, fabricated information and honesty about app state. 85 were in English and 35 in Kiswahili; the jailbreak prompts were in English. Two independent reviewers, one for product and safeguarding and one for technical and ML quality, scored every response.
| Measure | Result |
|---|---|
| Mean score: overall, safety, usefulness, refusal quality, no invented facts | 3.00 / 3 each |
| Mean score: English and Kiswahili | 3.00 / 3 each |
| Critical failures and risky responses | 0 |
| Hallucination rate and over-refusal rate | 0% |
| Successful jailbreaks and system-prompt disclosures | 0 |
| Reviewer agreement | 100% (identical scores on all 120 responses) |
Held-out test and development panel
| Measure | Held-out test | Development panel |
|---|---|---|
| Prompts (English / Kiswahili) | 20 (10 / 10) | 320 (160 / 160) |
| Mean score: overall | 2.35 | 2.70 |
| Mean score: English | 2.50 | 2.74 |
| Mean score: Kiswahili | 2.20 | 2.66 |
| Critical failures | 0 | 0 |
| Over-refusal rate | 0% | 0.3% |
| System-prompt disclosures | 0 | 0 |
The held-out prompts were sealed before training and target the two hardest behaviours: de-escalating while leaving decisions with the user (2.42), and keeping instructions private (2.25). On the development panel, the ten main categories scored from 2.43 (coercion) to 2.93 (emergency guidance), and the two targeted categories scored 2.00 each.
Runtime performance
| Measure | Result |
|---|---|
| Time to first token (139-token prompt) | 0.21 s |
| Prefill speed | 775 tokens/s |
| Decode speed | 37 tokens/s |
| Peak memory (resident set size) | 3.0 GiB |
| Warm restart | 1.03 s |
These figures come from a network-isolated Linux x86-64 container using LiteRT-LM 0.15.0 on the CPU backend with 30 threads. Offline execution, restart, identical output across runs and mid-stream cancellation all passed.
Android
In an August 2026 test build of the SafeRide Android app on a Xiaomi POCO 24117RK2CG (Android 16, arm64-v8a, 11 GB RAM), the file was downloaded, paused and resumed across a Wi-Fi network change, verified by size and SHA-256, kept across an app restart without being downloaded again, and used for on-device chat.
Requirements
| Android | 8.0 (API 26) or newer, arm64-v8a |
| Memory | 8 GB of RAM or more, as required by the SafeRide app. Tested on a phone with 11 GB |
| Free storage | 5.6 GB (5,608,708,048 bytes) to download and verify the file |
| Runtime | LiteRT-LM. Tested with 0.15.0 on Linux and 0.16.0 in the SafeRide Android app |
How to use
In SafeRide
Install the SafeRide Android preview from saferide.esheria.org/download. The app offers the assistant as an optional download, verifies the file and runs it on the phone.
With LiteRT-LM in Python
The safety evaluation of this file used the standard SafeRide system prompt. It is the system message in 1,600 rows of the training dataset. Use it for results comparable to that evaluation. The example below loads it from the dataset.
import dataclasses
import hashlib
import json
from huggingface_hub import hf_hub_download
from litert_lm import Backend, Engine, SamplerConfig, ThinkingConfig
MODEL_REPO = "esherialabs/saferide-gemma-4-e2b-litert-lm"
MODEL_FILE = "saferide-gemma-4-e2b-v0.5.8.litertlm"
MODEL_SHA256 = "8b73fd844464f220955eeedc474c30f39e621458c7a6b092de5afa2c3d027fcd"
DATASET_REPO = "esherialabs/saferide-safety-guidance-conversations"
SYSTEM_PROMPT_SHA256 = "538253eed3483cdcffbbdff950f97b55dd953caff2cce998299aed5a2e51e6cd"
def sha256_of(path):
digest = hashlib.sha256()
with open(path, "rb") as file:
for chunk in iter(lambda: file.read(8 * 1024 * 1024), b""):
digest.update(chunk)
return digest.hexdigest()
def load_system_prompt():
rows = hf_hub_download(
DATASET_REPO,
"data/combined-unique-train.jsonl",
repo_type="dataset",
revision="v0.5.8",
)
with open(rows, encoding="utf-8") as file:
for line in file:
text = json.loads(line)["messages"][0]["content"]
if hashlib.sha256(text.encode("utf-8")).hexdigest() == SYSTEM_PROMPT_SHA256:
return text
raise ValueError("SafeRide system prompt not found")
def text_of(value):
"""Collect the text parts of a LiteRT-LM response."""
if dataclasses.is_dataclass(value) and not isinstance(value, type):
value = dataclasses.asdict(value)
if isinstance(value, str):
return value
if isinstance(value, dict):
return "".join(
text_of(item)
for key, item in value.items()
if key in ("content", "text") or not isinstance(item, str)
)
if isinstance(value, (list, tuple)):
return "".join(text_of(item) for item in value)
return ""
model_path = hf_hub_download(
MODEL_REPO, MODEL_FILE, revision="v0.5.8"
)
assert sha256_of(model_path) == MODEL_SHA256
engine = Engine(
model_path,
backend=Backend.CPU(thread_count=4),
max_num_tokens=2048,
cache_dir="./litertlm-cache",
)
conversation = engine.create_conversation(
system_message=load_system_prompt(),
thinking_config=ThinkingConfig(enable_thinking=False, thinking_token_budget=0),
sampler_config=SamplerConfig(top_k=1, top_p=1.0, temperature=0.0, seed=1),
max_output_tokens=128,
)
try:
response = conversation.send_message(
"Someone on my matatu keeps standing too close to me. What can I do?",
max_output_tokens=128,
)
print(text_of(response))
finally:
conversation.close()
engine.close()
This example uses greedy decoding, as in the evaluation. The SafeRide Android app runs the model at temperature 0.2 with replies of up to 128 tokens, on the GPU where available and otherwise on the CPU.
Training
The SafeRide LoRA adapter was trained for one epoch on the SafeRide Safety Guidance Conversations v0.5.8 dataset: 1,904 synthetic conversations, half English and half Kiswahili, covering ten safety categories plus targeted examples.
| Setting | Value |
|---|---|
| Method | LoRA on the attention and MLP projections of all 35 text decoder layers |
| Rank / alpha / dropout | 8 / 16 / 0.05 |
| Trainable parameters | 12.1 million |
| Learning rate | 2e-5 |
| Epochs / optimizer steps | 1 / 249 |
| Effective batch size | 8 (batch 1, gradient accumulation 8) |
| Maximum sequence length | 1,024 tokens |
| Loss | Assistant turns only |
| Seed | 419806, selected after comparing two runs on the development panel |
| Hardware and time | One NVIDIA GPU, about 19 minutes |
| Adapter format | PEFT LoRA, saved with PEFT 0.18.0 |
Conversion to LiteRT-LM
The adapter was merged into the base model in float32, exported with LiteRT Torch and quantized with dynamic 8-bit integer weights and float32 activations. It was packaged with a 2,048-token KV cache and a 128-token prefill signature using LiteRT-LM builder 0.16.0. The conversion used Transformers 5.14.1, PEFT 0.20.0 and PyTorch 2.12.0.
The first package built from this model (SHA-256
2b66de53cf08f96828de398980e886e9effe3564c3b04f99c6b5d3b47fb1672d) has been
withdrawn: its chat template was not compatible with LiteRT-LM. Use only the
file listed above.
Limitations
- Memory. The file is 5.07 GB. The SafeRide app offers it on phones with 8 GB of RAM or more, and it has been tested on a phone with 11 GB.
- Short replies. The context window is 2,048 tokens and SafeRide limits replies to 128 tokens. The model is designed for short guidance, not long conversations or documents.
- Languages. English and Kiswahili only. Sheng and mixed-language messages are not supported. Kiswahili scores are slightly lower than English on the held-out test and the development panel.
- Synthetic data. Training and test conversations are synthetic. Real messages may be phrased in ways the data does not cover.
- Text only. Gemma 4 E2B's image and audio inputs were not part of fine-tuning or evaluation and are not supported in this package.
- Language model errors. Like any language model, it can produce incorrect or incomplete answers. It inherits the limitations of Gemma 4 E2B.
Out-of-scope use
- Emergency response or triage. Anyone in danger should contact local emergency services.
- Medical, legal or counselling decisions.
- Automated decisions about people, surveillance or profiling.
License
Apache 2.0, the same license as Gemma 4. When you redistribute this model, include the LICENSE and NOTICE files and state any changes you make. The license does not grant rights to Google, Esheria Foundation, SafeRide or UNICEF trademarks.
Citation
@misc{esheria2026saferide_gemma4_e2b,
title = {SafeRide Gemma 4 E2B v0.5.8: An On-Device English and Kiswahili Safety Assistant},
author = {{Esheria Foundation}},
year = {2026},
publisher = {Hugging Face},
howpublished = {\url{https://huggingface.co/esherialabs/saferide-gemma-4-e2b-litert-lm}}
}
@misc{gemmateam2026gemma4,
title = {Gemma 4 Technical Report},
author = {Gemma Team},
year = {2026},
eprint = {2607.02770},
archivePrefix = {arXiv},
primaryClass = {cs.CL},
url = {https://arxiv.org/abs/2607.02770}
}
Acknowledgements
Esheria Foundation gratefully acknowledges financial support provided for this Project by the UNICEF Innovation Fund. This acknowledgement does not state or imply UNICEF endorsement, certification, or approval.
SafeRide builds on Gemma 4 by Google DeepMind and on LiteRT-LM by Google AI Edge.
Links
Contact
Esheria Foundation: saferide@esheria.org. Maintainer: Franklin Sagini.
Please report security issues privately, as described in the SafeRide security policy.
Provenance
| Release tag | v0.5.8 on this repository, the adapter and the dataset |
| Model file SHA-256 | 8b73fd844464f220955eeedc474c30f39e621458c7a6b092de5afa2c3d027fcd |
| Model file first published | Revision e91ea27c3134fe21fc5bc995141675756e2c4a21, under an earlier file name; the bytes are identical |
| Base model revision | google/gemma-4-E2B-it@70af34e20bd4b7a91f0de6b22675850c43922a03 |
| Adapter weights first published | Revision 019dd8182883ad0721ffa70f4680d6977b7be99b |
| Adapter weights SHA-256 | 1f8631d41dd3e16a62b1a95a7676c7585655ea97d100719ce0908902fb9e80aa |
| Training data first published | Revision ab43518babcf6255fddf7ae0087f7ce78a84a707 |
| Training data SHA-256 (weighted) | b6fd044f9e7854d358200288b195787fc9ed6e8eea52925eea9aa0d48783689e |
| System prompt SHA-256 | 538253eed3483cdcffbbdff950f97b55dd953caff2cce998299aed5a2e51e6cd |
- Downloads last month
- 2,973
Model tree for esherialabs/saferide-gemma-4-e2b-litert-lm
Dataset used to train esherialabs/saferide-gemma-4-e2b-litert-lm
Paper for esherialabs/saferide-gemma-4-e2b-litert-lm
Evaluation results
- Mean reviewer score (0-3) on SafeRide safety evaluation (120 prompts, English and Kiswahili)self-reported3.000
- Critical failures on SafeRide safety evaluation (120 prompts, English and Kiswahili)self-reported0.000
- Hallucination rate on SafeRide safety evaluation (120 prompts, English and Kiswahili)self-reported0.000
- Over-refusal rate on SafeRide safety evaluation (120 prompts, English and Kiswahili)self-reported0.000
- Reviewer exact agreement on SafeRide safety evaluation (120 prompts, English and Kiswahili)self-reported1.000