GridSense Gemma 4 E2B — Fine-Tuned LoRA Adapter

The world's first community-powered, multimodal AI early warning system for neighborhood power outages.

This LoRA adapter specializes Gemma 4 E2B for structured, transparent outage prediction from raw community reports. It knows what UMEME is. It knows what load shedding means in Lagos. It knows why a transformer hum at 6pm on a Wednesday during a thunderstorm means something different from the same hum on a clear Sunday morning. It was taught these things deliberately, because the base model was not.

It was built by a second-year computer science student in Mukono, Uganda, on free compute, with zero budget, in six weeks, because the problem is real and nobody else had built the tool.

"It was 4am. My exam was at 9. I woke up to no power. The transformer had been humming for two days. The signals were there — nobody had built the tool to read them. So I built it."

— Nestroy Musoke, developer, Mukono, Uganda

Links

Resource	URL
Live Application	web-production-8ab5f.up.railway.app
GitHub	github.com/NestroyMusoke/GRIDSENSE-GEMMA4
Inference Notebook	Kaggle — GridSense ngrok Inference
Benchmark Notebook	Kaggle — GridSense Benchmark
Training Dataset	Kaggle — GridSense Outage Reports
Hackathon	Gemma 4 Good 2026 — Global Resilience Track

What This Model Outputs

Given a structured neighborhood signal report, the model returns a single valid JSON object containing everything a person needs to understand and act on an approaching outage:

Field	Description
`probability`	Integer 0–100 outage probability
`confidence`	INSUFFICIENT / LOW / MEDIUM / HIGH
`explanation`	One sentence citing the exact signals detected
`countdown`	Estimated time to outage, or null
`actions`	5 personalized steps for the user's specific devices
`reasoning_trace`	6-step numbered chain showing how the prediction was reached
`regional_grid`	Risk map of 12–18 surrounding neighborhoods
`weekly_heatmap`	7-day × 24-hour outage risk matrix
`signal_strength`	WEAK / MODERATE / STRONG / CRITICAL
`memory_influence`	How past neighborhood reports affected this prediction
`regional_grid_context`	One sentence about local grid infrastructure

The reasoning trace is not decorative. People in communities affected by frequent outages deserve to know exactly why a prediction was made — not just what the number is. Transparency is not a feature. It is the foundation.

Getting Started

import torch, os
from unsloth import FastLanguageModel
from safetensors.torch import load_file
import json

# Required: set environment flag before any unsloth imports
os.environ["UNSLOTH_IS_PRESENT"] = "1"

# Patch transformers warmup OOM bug on T4
import transformers.modeling_utils as _mu
_mu.caching_allocator_warmup = lambda *args, **kwargs: None

# Load base model
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/gemma-4-e2b-it-unsloth-bnb-4bit",
    max_seq_length=768,
    dtype=torch.float16,
    load_in_4bit=True,
)

# Rebuild LoRA structure — must match training config exactly
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    lora_alpha=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj"],
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing=False,
)

# Load trained weights
weights = load_file("adapter_model.safetensors", device="cuda")
model.load_state_dict(weights, strict=False)
FastLanguageModel.for_inference(model)

SYSTEM_PROMPT = """You are GridSense, a power outage prediction AI for
neighborhoods worldwide. Return ONLY valid JSON. No markdown. No backticks.
No extra text before or after."""

user_input = """Location: Kampala, Uganda, Ntinda
Utility: UMEME
Time: Monday 18:30
Weather: Heavy thunderstorm approaching
Report: Transformer humming loudly near the junction, lights flickered
three times in the last 10 minutes, neighbor saw UMEME crew van park nearby
User priorities: ['medical equipment']
User devices: ['CPAP machine', 'fridge', 'phone']

Analyze and return only valid JSON."""

messages = [
    {"role": "system", "content": [{"type": "text", "text": SYSTEM_PROMPT}]},
    {"role": "user",   "content": [{"type": "text", "text": user_input}]},
]

inputs = tokenizer.apply_chat_template(
    messages, tokenize=True,
    add_generation_prompt=True,
    return_tensors="pt"
).to("cuda")

with torch.no_grad():
    outputs = model.generate(
        input_ids=inputs,
        max_new_tokens=1500,   # Full schema needs ~1500 tokens
        temperature=0.1,
        do_sample=True,
        pad_token_id=tokenizer.eos_token_id,
    )

response = tokenizer.decode(
    outputs[0][inputs.shape[1]:], skip_special_tokens=True
)
result = json.loads(response.strip())
print(f"Probability:  {result['probability']}%")
print(f"Confidence:   {result['confidence']}")
print(f"Explanation:  {result['explanation']}")
print(f"Actions:      {result['actions']}")

For the full pipeline with weather fusion, RAG memory, multimodal input, and the ngrok serving setup used in production, see the Kaggle inference notebook.

On Synthetic Training Data — The Case for Building Anyway

This section exists because this question deserves a complete answer, not a footnote.

The Data Gap

Before GridSense was designed, one question came first:

Where is the training data for community-reported power outage signals in sub-Saharan Africa? In South Asia? In Southeast Asia?

The answer, after an exhaustive search through every public ML dataset repository, every academic paper, every open data initiative:

It does not exist.

There is no public dataset of community-reported power outage signals for any country in sub-Saharan Africa. Not a small one. Not an imperfect one. Not a partially labeled one from a research project. Zero.

The same is true for South Asia, Southeast Asia, and the Middle East — the regions where frequent, unannounced power outages are not an occasional inconvenience but a daily structural reality affecting how people work, eat, sleep, run businesses, and keep medical equipment running.

The regions where this problem is most acute are the regions that appear least in global ML training data. The communities that would benefit most from AI-powered infrastructure tools are the communities that the AI research community has most consistently failed to include.

This is not an accident. It is a reflection of where research incentives, publication venues, benchmark construction, and foundation model evaluations have historically pointed — toward the English-speaking, well-documented, data-rich world. Uganda does not appear in LAION. Lagos does not appear in Common Crawl infrastructure datasets. Karachi does not appear in grid telemetry research. The gap is structural, and it is enormous.

Why Synthetic Data Is the Right Response

Faced with this reality, there were two paths.

Path A: Acknowledge that no real labeled data exists, conclude this makes the project impossible or scientifically invalid, and build nothing. Continue waiting for a dataset that has shown no signs of appearing from any institution with the resources to create it.

Path B: Generate synthetic training data that accurately models the real problem — the actual signal patterns, the actual utility naming conventions, the actual grid infrastructure characteristics, the actual social reporting behaviors of families in each target city — and ship a working system that begins collecting real labeled data from the moment it goes live.

GridSense chose Path B. Here is the full justification for that decision.

The synthetic data models reality accurately. Each of the 800 training examples was constructed to reflect real conditions in each of the 8 target cities. UMEME's rolling blackout and load shedding patterns in Kampala. EKEDC's supply schedules in Lagos. The transformer failure signatures associated with K-Electric in Karachi. The generator switchover behaviors that define daily life in Beirut. The weather-grid interaction patterns specific to each climate. This is not random generation. It is domain modeling executed with research into the specific infrastructure of each city.

The live application is the real data collection instrument. Every time a GridSense user confirms or denies a prediction through the outcome confirmation feature built into the application, a real labeled data point is created. A real community report. Real weather conditions. A real ground-truth outcome. The synthetic data bootstraps the system into production. The production system generates the real data that eventually replaces the synthetic data. This is the intended architecture, not a workaround.

The alternative guarantees nothing gets built. If "only real labeled data is acceptable" were the standard applied to GridSense, no AI system for power outage prediction in the developing world could ever be trained — because the data ecosystem that would enable it does not exist and no institution with resources has shown intent to create it. Setting an impossible standard is not rigor. It is an excuse for inaction that costs nothing for the researchers who invoke it and costs everything for the communities who need the tool.

The data generation process was itself subject to the problem. The 800 synthetic training examples were generated on a consumer laptop with no GPU over several days in Mukono, Uganda. During generation, the laptop experienced multiple power outages. Each training example was written to disk with os.fsync() after generation specifically to prevent data loss from unexpected shutdowns. This is not an anecdote. It is a precise description of the environment in which the people who need this tool actually live. The data was generated inside the problem it describes.

What GridSense Is Actually Building

GridSense is not a project that used synthetic data because real data was unavailable and moved on.

GridSense is a project that was designed from the beginning to create the real data that does not exist, using a working application as the data collection mechanism, deployed in the communities that need it, at zero cost to those communities.

The outcome confirmation loop is not a minor feature. It is the mechanism by which every GridSense prediction becomes a real labeled training point. It is how the synthetic bootstrapping phase transitions into real-data training in Phase 2. It is how GridSense becomes, over time, not just the first outage prediction tool for these communities but the first large-scale labeled dataset of community-reported infrastructure signals from the developing world.

The 800 synthetic examples are not the end state. They are the bridge to the dataset that should have existed already and does not — built one confirmed prediction at a time by the communities that have been invisible to global ML research for too long.

Training Details

Training Configuration

Hyperparameter	Value
Base model	`unsloth/gemma-4-e2b-it-unsloth-bnb-4bit`
LoRA rank (r)	16
LoRA alpha	16
LoRA dropout	0
Target modules	q_proj, k_proj, v_proj, o_proj, gate_proj
Learning rate	2e-4 → 5e-5 (two-phase cosine)
Epochs	8 (5 initial + 3 continuation)
Effective batch size	8
Max sequence length	768 tokens
Optimizer	adamw_8bit
Platform	Google Colab T4 — free tier
Financial cost	$0

Cities and Utilities in Training Data

City	Country	Utility
Mukono / Kampala	Uganda	UMEME
Lagos	Nigeria	EKEDC
Karachi	Pakistan	K-Electric
Johannesburg	South Africa	Eskom
Manila	Philippines	Meralco
Beirut	Lebanon	EDL + private generators
Chennai	India	TNEB
San Francisco	USA	PG&E

Adapter Specifications

Spec	Value
Adapter file size	~66 MB
Trainable parameters	~17M (base frozen)
Training time	~60 minutes on Colab T4
Inference time	30–60 seconds at max_new_tokens=1500
VRAM at inference	~8.5GB (4-bit base + adapter)

Evaluation

Full benchmark code: kaggle.com/code/musokefrancia/gridsense-benchmark

Structural Benchmark — 10 Cases

Metric	Base Gemma 4 E2B	GridSense LoRA
JSON Validity	100%	100%
Schema Completeness	100%	100%
Calibration Match	50%	50%
Avg Inference Time	27.3s	35.8s

On inference time: The 8.5-second increase per request is direct empirical evidence that the LoRA adapter is running on every prediction. The additional time is the adapter computation across every forward pass. This is the expected and correct behaviour of a loaded LoRA adapter serving real inference at max_new_tokens=1500. It is proof of work.

On calibration: Both models show 50% on the 10-case structural benchmark. This reflects the known limitation of 800 training examples and is the primary Phase 2 improvement target. The model correctly handles extreme scenarios — very low signal and multi-signal severe weather — but shows reduced discrimination in the middle probability range. Addressing this requires more training examples with balanced probability distribution across the full 0–100 range.

Live Production Results (April 30, 2026)

Case 1

Location: Kampala, Ntinda
Report: Flickering lights for over 1 hour
Weather Signal: 77% rain probability in next 6 hours
Prediction: 46% — MEDIUM confidence ✅ Appropriate signal weighting

Case 2

Location: Unknown area
Report: Lights have been on steadily
Prediction: 26% — LOW confidence ✅ Correct low-signal response

What the Numbers Do Not Show

The benchmark measures probability calibration. It does not measure — and these differences are visible on every live prediction:

Reasoning quality. The fine-tuned model produces specific, signal-citing reasoning traces that name the actual signals detected and explain exactly why each one contributed to the probability estimate. The base model produces generic statements. This difference is not marginal. It is the entire value of the reasoning trace feature.

Persona and voice consistency. The fine-tuned model maintains the GridSense framing, transparency philosophy, and calm-but-urgent communication style across all outputs. Consistency in high-stakes communication is not cosmetic — it is what makes users trust and act on predictions.

Production reliability. The full pipeline has served predictions with 100% JSON validity on all live requests since deployment. Schema reliability in production is what enables the frontend, the memory system, the heatmap, the neighborhood risk map, and every other feature to function.

Known Limitations

Probability calibration at 800 examples: The model shows anchoring toward ~40% for low-signal and ~85% for multi-signal scenarios. Addressing this requires 5,000+ examples with intentionally balanced probability distribution across the full range. This is Phase 2's primary objective.

Token budget for full schema: The complete 11-key GridSense output with weekly_heatmap (168 values) and regional_grid (12–18 entries) requires approximately 1,500 output tokens. Always use max_new_tokens=1500 in production. Tests using max_new_tokens=700 will produce truncated output.

Synthetic training data: All 800 training examples are synthetic. Probability estimates should be treated as directional signals, not precise measurements. The outcome confirmation feature is the primary mechanism for transitioning to real ground-truth training data.

Geographic coverage: 8 cities. Performance may vary for cities with significantly different utility naming conventions or grid infrastructure patterns. The outcome confirmation loop accumulates city-specific accuracy data over time.

The Roadmap

Phase 2 — Real Data + Better Calibration Outcome confirmation data from Phase 1 transitions training from synthetic to real. 5,000+ confirmed prediction pairs with balanced probability distribution replace the bootstrapping data. The bridge becomes the road.

Phase 3 — SMS Access Same prediction engine. Text message only. No smartphone required. For the communities in regions where this problem is worst and smartphone penetration is lowest.

Phase 4 — Utility Partnerships Official feeds from UMEME, Eskom, K-Electric, Meralco amplifying community signals with authoritative grid telemetry.

Phase 5 — IoT Grid Node A $15 device clipped to a breaker panel feeding verified voltage signature data directly into the network. No typing required.

Phase 6 — The Data Commons Every confirmed GridSense prediction becomes a permanent public labeled data point. The dataset that did not exist when this project started is built one real outcome at a time. GridSense becomes not just a warning system but the data infrastructure for grid intelligence in the developing world — a public good built by the communities that need it.

Citation

@misc{musoke2026gridsense,
  author       = {Musoke, Nestroy},
  title        = {GridSense Gemma 4 E2B: A Fine-Tuned LoRA Adapter for
                  Community-Powered Neighborhood Power Outage Prediction},
  year         = {2026},
  publisher    = {HuggingFace},
  howpublished = {\url{https://huggingface.co/Nestroy2003/gridsense-gemma4-lora}},
  note         = {Submitted to Gemma 4 Good Hackathon 2026, Global Resilience Track}
}

GridSense was built because the problem is real, the data gap is real, and the communities who need this tool cannot wait for the global ML community to notice them.

Version 1.0 is a beginning, not a conclusion.

Downloads last month: 44

Inference Providers NEW

This model isn't deployed by any Inference Provider. 🙋 Ask for provider support