Configure EuroSAT Field Scout submission

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+weights/simple_net_v1.part00 filter=lfs diff=lfs merge=lfs -text
+weights/simple_net_v1.part01 filter=lfs diff=lfs merge=lfs -text
+weights/simple_net_v1.part02 filter=lfs diff=lfs merge=lfs -text
+weights/simple_net_v1.part03 filter=lfs diff=lfs merge=lfs -text
+weights/simple_net_v1.part04 filter=lfs diff=lfs merge=lfs -text

.hfignore

@@ -0,0 +1,11 @@
+.git/
+.cache/
+.hf-inspect/
+output/
+__pycache__/
+*.ipynb
+full_model.pth
+simple_net_v1.pth
+simple_net_v1.weights
+demo.mp4
+2026-06-13 19-57-34.mp4

FIELD_NOTES.md

@@ -0,0 +1,46 @@
+# EuroSAT Field Scout - Field Notes
+
+## What I Built
+
+EuroSAT Field Scout is a small Gradio app that classifies Sentinel-style land
+tiles into 10 EuroSAT scene classes. The goal is not to replace a GIS workflow.
+It is a quick first-pass helper for students, mapping volunteers, or anyone who
+wants to sort a handful of tiles before deeper review.
+
+## Why It Fits Build Small
+
+The deployed model is a custom PyTorch CNN with 2,492,170 parameters. It is far
+below the 32B parameter cap and runs on CPU inside the Space. There are no cloud
+inference calls and no hidden model API. The repo contains the weights as small
+`weights/simple_net_v1.part*` chunks, and `app.py` reconstructs them at startup.
+
+## Implementation Notes
+
+- `model.py` defines `SimpleNet`, a four-block convolutional classifier.
+- `app.py` handles image upload, preprocessing, softmax inference, and Gradio UI.
+- `examples/` contains small RGB EuroSAT samples from `torchgeo/eurosat`.
+- The LinkedIn social post contains the short demo video for the hackathon submission.
+
+One deployment issue was the original checkpoint format. The model was first
+stored as a full pickled Python object, which is fragile across PyTorch versions.
+For the Space, I converted it to a plain `state_dict`. To avoid Git LFS upload
+issues in the hackathon org, the deployed file stores floating tensors in
+float16 and splits the bytes into small `weights/simple_net_v1.part*` chunks.
+The app joins the chunks in memory and casts tensors back to float32 before
+loading. The app now instantiates the architecture explicitly and loads only
+tensor weights.
+
+## Runtime Path
+
+1. User uploads an image or clicks a sample.
+2. The image is converted to RGB and resized to 64 x 64.
+3. The tensor is normalized with ImageNet-style mean and std values.
+4. `SimpleNet` runs on CPU.
+5. The app returns the top EuroSAT class probabilities.
+
+## Limits
+
+The model was built for EuroSAT-style RGB tiles. It is useful for a quick demo
+or educational triage, but it should not be used for production remote-sensing
+decisions without calibration, validation on the target geography, and a clearer
+uncertainty policy.

README.md

@@ -1,13 +1,120 @@
 ---
-title: EuroSATFieldScout
-emoji: 🌖
-colorFrom: indigo
+title: EuroSAT Field Scout
+emoji: 🛰️
+colorFrom: green
 colorTo: blue
 sdk: gradio
-sdk_version: 6.18.0
-python_version: '3.13'
+sdk_version: 5.34.0
+python_version: 3.11
 app_file: app.py
 pinned: false
+license: mit
+short_description: Local EuroSAT land-use classifier for map triage.
+tags:
+  - gradio
+  - build-small-hackathon
+  - backyard-ai
+  - track:backyard
+  - small-models
+  - tiny-model
+  - computer-vision
+  - satellite-imagery
+  - pytorch
+  - eurosat
+  - local-first
+  - achievement:offgrid
+  - achievement:sharing
+  - achievement:fieldnotes
+datasets:
+  - torchgeo/eurosat
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<div align="center">
+
+# EuroSAT Field Scout
+
+Small local-first land-use triage for satellite tiles.
+
+**Try it:** [Live Space](https://huggingface.co/spaces/build-small-hackathon/EuroSATFieldScout) · [Demo video + social post](https://www.linkedin.com/posts/varfolomiy-yasenoviy-a0209a2a3_gradio-huggingface-hackaton-share-7471607916270080000-W9RZ/) · [Field notes](FIELD_NOTES.md)
+
+</div>
+
+---
+
+## Judges Quick Read
+
+- **Track:** Backyard AI
+- **Model cap:** 2.49M-parameter PyTorch CNN, far below the 32B hackathon cap
+- **Runtime:** Gradio Space on CPU
+- **Off the Grid:** no cloud inference API; the app reconstructs local weights from `weights/simple_net_v1.part*`
+- **Use case:** quick first-pass sorting of Sentinel-style land tiles for students, mapping volunteers, and geo demos
+
+Upload a satellite or aerial land image and the app predicts the closest EuroSAT
+land-use class:
+
+- AnnualCrop
+- Forest
+- HerbaceousVegetation
+- Highway
+- Industrial
+- Pasture
+- PermanentCrop
+- Residential
+- River
+- SeaLake
+
+## Demo
+
+The short demo video is attached to the LinkedIn social post:
+
+https://www.linkedin.com/posts/varfolomiy-yasenoviy-a0209a2a3_gradio-huggingface-hackaton-share-7471607916270080000-W9RZ/
+
+## Model
+
+`SimpleNet` is a lightweight convolutional neural network trained on EuroSAT.
+The Space reconstructs the local weights from `weights/simple_net_v1.part*` and
+runs inference on CPU.
+
+| Component | Details |
+| --- | --- |
+| Architecture | Four Conv-BN-ReLU-Pool blocks plus a dense classifier |
+| Parameters | 2,492,170 |
+| Input | RGB image resized to 64 x 64 |
+| Output | 10 EuroSAT land-use classes |
+| Inference | Local PyTorch CPU inference inside the Space |
+
+## Build Notes
+
+The checkpoint originally existed as a pickled full model object. For a safer Space
+deploy, it was converted to a plain PyTorch `state_dict` in `simple_net_v1.pth`.
+That avoids PyTorch pickle compatibility issues and makes the app startup path
+simple: instantiate `SimpleNet`, load weights, run inference.
+
+For the hackathon Space upload, the state dict is stored as float16 tensors and
+split into small `weights/simple_net_v1.part*` chunks so the submission can be
+reviewed without Git LFS write permissions. The app rebuilds the bytes in memory
+and casts floating tensors back to float32 before loading them into the model.
+
+## Badges
+
+| Badge | Status | Why it fits |
+| --- | --- | --- |
+| Backyard AI | Submitted | Helps with a practical local mapping workflow |
+| Off the Grid | Submitted | No hosted LLM or remote inference service |
+| Sharing is Caring | Submitted | LinkedIn post and reusable Space source are public |
+| Field Notes | Submitted | `FIELD_NOTES.md` documents the build and deployment choices |
+
+## Running Locally
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+## Submission Links
+
+| Item | Link |
+| --- | --- |
+| Live Space | https://huggingface.co/spaces/build-small-hackathon/EuroSATFieldScout |
+| Demo video + social post | https://www.linkedin.com/posts/varfolomiy-yasenoviy-a0209a2a3_gradio-huggingface-hackaton-share-7471607916270080000-W9RZ/ |
+| Field notes | [`FIELD_NOTES.md`](FIELD_NOTES.md) |

app.py

@@ -1,7 +1,83 @@
+from io import BytesIO
+from pathlib import Path
+
+import torch
 import gradio as gr
+from torchvision import transforms
+from PIL import Image
+
+from model import SimpleNet, CLASS_NAMES
+
+
+WEIGHTS_DIR = Path("weights")
+EXAMPLES = [
+    ["examples/annualcrop_sample.jpg"],
+    ["examples/forest_sample.jpg"],
+    ["examples/highway_sample.jpg"],
+    ["examples/industrial_sample.jpg"],
+    ["examples/residential_sample.jpg"],
+    ["examples/sealake_sample.jpg"],
+]
+
+
+def load_model():
+    model = SimpleNet(num_classes=10)
+    weight_bytes = b"".join(
+        path.read_bytes() for path in sorted(WEIGHTS_DIR.glob("simple_net_v1.part*"))
+    )
+    state_dict = torch.load(BytesIO(weight_bytes), map_location="cpu")
+    state_dict = {
+        name: tensor.float() if torch.is_floating_point(tensor) else tensor
+        for name, tensor in state_dict.items()
+    }
+    model.load_state_dict(state_dict)
+    model.eval()
+    return model
+
+
+model = load_model()
+
+preprocess = transforms.Compose([
+    transforms.Resize((64, 64)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                         std=[0.229, 0.224, 0.225]),
+])
+
+
+def predict(image: Image.Image) -> dict[str, float]:
+    if image is None:
+        return {}
+
+    image = image.convert("RGB")
+    tensor = preprocess(image).unsqueeze(0)  # [1, 3, 64, 64]
+
+    with torch.no_grad():
+        logits = model(tensor)
+        probs = torch.nn.functional.softmax(logits, dim=1)[0]
+
+    return {CLASS_NAMES[i]: float(probs[i]) for i in range(len(CLASS_NAMES))}
+
 
-def greet(name):
-    return "Hello " + name + "!!"
+demo = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(type="pil", label="Upload a Sentinel-style land image"),
+    outputs=gr.Label(num_top_classes=5, label="Top land-use guesses"),
+    title="EuroSAT Field Scout",
+    description=(
+        "A small local-first Gradio classifier for quick land-use triage. "
+        "It runs a custom PyTorch CNN trained on EuroSAT and returns the closest scene class."
+    ),
+    article=(
+        "Built for the Build Small Hackathon Backyard AI track. "
+        "No cloud inference API, no giant model: the Space loads local weights "
+        "and runs CPU inference inside the app."
+    ),
+    examples=EXAMPLES,
+    cache_examples=False,
+    allow_flagging="never",
+    theme=gr.themes.Soft(),
+)
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+if __name__ == "__main__":
+    demo.queue(default_concurrency_limit=2).launch()

model.py

@@ -0,0 +1,64 @@
+"""
+SimpleNet — lightweight CNN for EuroSAT satellite image classification.
+4 convolutional blocks (double-and-halve pattern) + FC classifier.
+Input: 3×64×64 RGB | Output: 10 land-use classes | ~2.49M parameters
+"""
+
+import torch
+import torch.nn as nn
+
+
+CLASS_NAMES = [
+    "AnnualCrop", "Forest", "HerbaceousVegetation", "Highway",
+    "Industrial", "Pasture", "PermanentCrop", "Residential",
+    "River", "SeaLake"
+]
+
+
+class SimpleNet(nn.Module):
+    def __init__(self, num_classes: int = 10):
+        super().__init__()
+
+        # 64×64 → 32×32
+        self.block1 = nn.Sequential(
+            nn.Conv2d(3, 32, kernel_size=3, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+        )
+        # 32×32 → 16×16
+        self.block2 = nn.Sequential(
+            nn.Conv2d(32, 64, kernel_size=3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+        )
+        # 16×16 → 8×8
+        self.block3 = nn.Sequential(
+            nn.Conv2d(64, 128, kernel_size=3, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+        )
+        # 8×8 → 4×4
+        self.block4 = nn.Sequential(
+            nn.Conv2d(128, 256, kernel_size=3, padding=1),
+            nn.BatchNorm2d(256),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+        )
+
+        self.classifier = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(256 * 4 * 4, 512),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(512, num_classes),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.block1(x)
+        x = self.block2(x)
+        x = self.block3(x)
+        x = self.block4(x)
+        return self.classifier(x)

requirements.txt

@@ -0,0 +1,5 @@
+torch>=2.2,<3
+torchvision>=0.17,<1
+gradio>=5.34,<6
+huggingface_hub>=0.25,<1
+Pillow>=10

weights/simple_net_v1.part00

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8681a2e1cb7d4188af217f57fdda104d07664455a779cdc241dd39008c102304
+size 1000000

weights/simple_net_v1.part01

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d139af73bfe778f069f0fe9c373a81b401a93f60103b90228bef271345077b46
+size 1000000

weights/simple_net_v1.part02

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8a8e3bd5e1863a6e2976bacfd504ff972d2640f198c49fade23e78232ea464af
+size 1000000

weights/simple_net_v1.part03

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:280199fe980e2ee5845ce5cbe9e7ee56dd5493384b69c970cbf1d9367d2f5d63
+size 1000000

weights/simple_net_v1.part04

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c08cfae02a27254d8aac9d9b5ff7e861010ee8de995aac3471c89205ed576f3
+size 996327