Add Streamlit app source and RGB model weights

README.md

@@ -1,19 +1,61 @@
 ---
 title: EuroSAT RGB Land Cover Classifier
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Intereactive demo for classifying land cover classes
+sdk: streamlit
+app_file: app/app.py
 ---
 
-# Welcome to Streamlit!
+# EuroSAT Land Cover Classification
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+CNN-based land cover classification on EuroSAT, comparing RGB imagery with 13-band Sentinel-2 multispectral input.
+
+## Streamlit RGB Demo
+
+`app/app.py` is a Hugging Face Spaces-ready Streamlit demo for the EuroSAT-RGB ResNet-50 classifier. It shows an Esri World Imagery map centered on Bergen, Norway, lets a user draw a rectangle, fetches the corresponding RGB map tiles, and displays the predicted EuroSAT land cover class plus the top-3 class probabilities.
+
+The RGB model was trained on EuroSAT-RGB tiles, which are about 64x64 pixels and roughly 640m on a side. Predictions on arbitrary map regions are illustrative; for best results, draw a rectangle of roughly 500m-1km on a side over land.
+
+Classes: Annual Crop, Forest, Herbaceous Vegetation, Highway, Industrial Buildings, Pasture, Permanent Crop, Residential Buildings, River, SeaLake.
+
+Validation accuracy on EuroSAT-RGB: **96.8%**.
+
+Main GitHub repo: [davidlsan/EuroSAT-Land-Cover-Classification](https://github.com/davidlsan/EuroSAT-Land-Cover-Classification)
+
+## Run Locally
+
+Place the trained RGB checkpoint at:
+
+```bash
+weights/rgb_e15_best.pt
+```
+
+Install dependencies with uv and start the app:
+
+```bash
+uv sync
+uv run streamlit run app/app.py
+```
+
+For Hugging Face Spaces, use the Streamlit SDK and include `app/app.py`, `app/model_utils.py`, `app/tile_utils.py`, `requirements.txt`, and the checkpoint at `weights/rgb_e15_best.pt`.
+
+## Notebooks
+
+- `[notebooks/01_data_exploration.ipynb](notebooks/01_data_exploration.ipynb)` - RGB EDA (class balance, sample grid). Run from the repository root so PNGs land in `[figures/](figures/)`.
+- `[notebooks/02_data_exploration_multispectral.ipynb](notebooks/02_data_exploration_multispectral.ipynb)` - 13-band MSI EDA (class balance, composites, per-band stats, class-mean spectra, band correlation, RGB-MSI alignment).
+
+## Training
+
+Run from the repository root:
+
+```bash
+python3 main.py --modality rgb --epochs 15 --batch-size 32 --num-workers 2 --lr 1e-3
+```
+
+### CLI Flags
+
+- `--modality`: values `rgb` or `msi`. RGB loads the `blanchon/EuroSAT_RGB` dataset, while MSI loads `blanchon/EuroSAT_MSI`.
+- `--epochs`: number of full passes over the training split. Defaults to `15`.
+- `--batch-size`: number of samples per batch. Defaults to `32`.
+- `--num-workers`: DataLoader worker processes. Defaults to `2`, but `0` is safer for debugging.
+- `--lr`: learning rate for Adam. Defaults to `1e-3`.
+- `--seed`: seeds Python, NumPy, and PyTorch for best-effort reproducibility.
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).

app/__init__.py

@@ -0,0 +1 @@
+"""Streamlit EuroSAT RGB demo package."""

app/app.py

@@ -0,0 +1,276 @@
+from pathlib import Path
+import sys
+
+import folium
+import streamlit as st
+from branca.element import MacroElement, Template
+from folium.plugins import Draw, MeasureControl
+from streamlit_folium import st_folium
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+from app.model_utils import (  # noqa: E402
+    CLASS_NAMES,
+    DEFAULT_CHECKPOINT_PATH,
+    load_rgb_model,
+    predict_topk,
+)
+from app.tile_utils import (  # noqa: E402
+    TileFetchError,
+    bbox_scale_status,
+    bbox_size_meters,
+    choose_zoom_level,
+    extract_bbox_from_geojson,
+    fetch_bbox_image,
+    size_warning_for_bbox,
+)
+
+
+ESRI_WORLD_IMAGERY = (
+    "https://server.arcgisonline.com/ArcGIS/rest/services/"
+    "World_Imagery/MapServer/tile/{z}/{y}/{x}"
+)
+
+# Farmlands starter pos, good for examples right of the bat
+DEFAULT_MAP_CENTER = [50, 10]
+DEFAULT_MAP_ZOOM = 15
+
+
+class SingleRectangleLimiter(MacroElement):
+    _template = Template(
+        """
+        {% macro script(this, kwargs) %}
+        {{ this.map_name }}.on('draw:created', function(e) {
+            {{ this.drawn_items_name }}.clearLayers();
+            {{ this.drawn_items_name }}.addLayer(e.layer);
+        });
+        {% endmacro %}
+        """
+    )
+
+    def __init__(self, map_name: str, drawn_items_name: str):
+        super().__init__()
+        self._name = "SingleRectangleLimiter"
+        self.map_name = map_name
+        self.drawn_items_name = drawn_items_name
+
+
+@st.cache_resource(show_spinner="Loading RGB ResNet-50 model...")
+def get_model():
+    return load_rgb_model(DEFAULT_CHECKPOINT_PATH)
+
+
+def build_map(
+    drawing: dict | None = None,
+    center: list[float] | None = None,
+    zoom: int = DEFAULT_MAP_ZOOM,
+) -> folium.Map:
+    fmap = folium.Map(
+        location=center or DEFAULT_MAP_CENTER,
+        zoom_start=zoom,
+        min_zoom=13,
+        max_zoom=18,
+        tiles=None,
+        control_scale=True,
+    )
+    folium.TileLayer(
+        tiles=ESRI_WORLD_IMAGERY,
+        attr="Tiles © Esri — Source: Esri, Maxar, Earthstar Geographics, and GIS User Community",
+        name="Esri World Imagery",
+        overlay=False,
+        control=True,
+    ).add_to(fmap)
+    draw_control = Draw(
+        export=False,
+        draw_options={
+            "polyline": False,
+            "polygon": False,
+            "circle": False,
+            "marker": False,
+            "circlemarker": False,
+            "rectangle": {
+                "shapeOptions": {
+                    "color": "#ff7800",
+                    "weight": 2,
+                    "fillOpacity": 0.05,
+                }
+            },
+        },
+        edit_options={"edit": True, "remove": True},
+    )
+    draw_control.add_to(fmap)
+    SingleRectangleLimiter(
+        map_name=fmap.get_name(),
+        drawn_items_name=f"drawnItems_{draw_control.get_name()}",
+    ).add_to(fmap)
+    MeasureControl(
+        position="bottomleft",
+        primary_length_unit="meters",
+        secondary_length_unit="kilometers",
+        primary_area_unit="sqmeters",
+    ).add_to(fmap)
+
+    if drawing:
+        folium.GeoJson(
+            drawing,
+            name="Last selected rectangle",
+            style_function=lambda _: {
+                "color": "#00bcd4",
+                "weight": 2,
+                "fillOpacity": 0.04,
+            },
+        ).add_to(fmap)
+
+    return fmap
+
+
+def render_sidebar() -> None:
+    st.sidebar.header("How to use")
+    st.sidebar.markdown(
+        "1. Pan and zoom to a land area.\n"
+        "2. Select the rectangle tool on the map.\n"
+        "3. Use the map scale bar or measure tool as a guide.\n"
+        "4. Draw a near-square box roughly 500m-1km on a side.\n"
+        "5. Review the fetched image and top predictions."
+    )
+    st.sidebar.warning(
+        "This model was trained on EuroSAT-RGB tiles (~64x64 pixels, ~640m on a side). "
+        "Predictions on arbitrary map regions are illustrative; for best results, draw "
+        "a rectangle of roughly 500m-1km on a side over land."
+    )
+    st.sidebar.header("EuroSAT Classes")
+    for class_name in CLASS_NAMES:
+        st.sidebar.write(f"- {class_name}")
+
+
+def render_prediction(drawing) -> None:
+    try:
+        bbox = extract_bbox_from_geojson(drawing)
+    except ValueError as exc:
+        st.error(str(exc))
+        return
+
+    width_m, height_m = bbox_size_meters(bbox)
+    scale_state, scale_message = bbox_scale_status(bbox)
+
+    metric_col, scale_col, zoom_col = st.columns(3)
+    metric_col.metric("Rectangle width", format_meters(width_m))
+    scale_col.metric("Rectangle height", format_meters(height_m))
+    zoom_col.metric("Tile zoom", choose_zoom_level(bbox))
+
+    warning = size_warning_for_bbox(bbox)
+    if warning:
+        st.warning(warning)
+        return
+    if scale_state == "invalid":
+        st.warning(scale_message)
+        return
+    if scale_state == "good":
+        st.success(scale_message)
+    else:
+        st.warning(scale_message)
+
+    try:
+        with st.spinner("Fetching Esri imagery tiles..."):
+            image = fetch_bbox_image(bbox)
+    except TileFetchError as exc:
+        st.error(f"Could not fetch satellite imagery for this rectangle. {exc}")
+        return
+
+    try:
+        model = get_model()
+    except FileNotFoundError as exc:
+        st.error(str(exc))
+        return
+
+    with st.spinner("Running RGB land cover inference..."):
+        top_predictions = predict_topk(model, image, top_k=3)
+
+    preview_col, prediction_col = st.columns([1, 1])
+    with preview_col:
+        st.subheader("Fetched Tile Preview")
+        st.image(image, caption="Cropped Esri World Imagery", width='stretch')
+
+    with prediction_col:
+        st.subheader("Prediction")
+        best_class, best_prob = top_predictions[0]
+        st.metric("Predicted class", best_class, f"{best_prob:.1%}")
+        st.write("Top-3 class probabilities")
+        st.bar_chart(
+            {"Probability": {name: prob for name, prob in top_predictions}},
+            horizontal=True,
+        )
+
+
+def format_meters(value: float) -> str:
+    if value >= 1_000:
+        return f"{value / 1_000:.2f} km"
+    return f"{value:.0f} m"
+
+
+def get_drawing(data: dict | None) -> dict | None:
+    incoming_drawing = data.get("last_active_drawing") if data else None
+    current_drawing = st.session_state.get("last_drawing")
+    if incoming_drawing and incoming_drawing != current_drawing:
+        st.session_state["last_drawing"] = incoming_drawing
+        st.session_state["map_center"] = drawing_center(incoming_drawing)
+        st.rerun()
+    return st.session_state.get("last_drawing")
+
+
+def drawing_center(drawing: dict) -> list[float]:
+    bbox = extract_bbox_from_geojson(drawing)
+    return [
+        (bbox.south + bbox.north) / 2.0,
+        (bbox.west + bbox.east) / 2.0,
+    ]
+
+
+def reset_map() -> None:
+    st.session_state["map_version"] = st.session_state.get("map_version", 0) + 1
+
+
+def clear_selection() -> None:
+    st.session_state.pop("last_drawing", None)
+    st.session_state.pop("map_center", None)
+    reset_map()
+
+
+def main() -> None:
+    st.set_page_config(
+        page_title="EuroSAT RGB Land Cover Classifier",
+        layout="wide",
+    )
+    st.title("EuroSAT Land Cover Classifier (RGB Model)")
+    st.markdown(
+        "This demo classifies RGB satellite imagery into the 10 EuroSAT land cover "
+        "classes using a ResNet-50."
+    )
+    render_sidebar()
+
+    previous_drawing = st.session_state.get("last_drawing")
+    map_version = st.session_state.get("map_version", 0)
+    map_center = st.session_state.get("map_center", DEFAULT_MAP_CENTER)
+    data = st_folium(
+        build_map(previous_drawing, center=map_center),
+        key=f"eurosat-rgb-map-{map_version}",
+        height=600,
+        width='stretch',
+        returned_objects=["last_active_drawing"],
+    )
+
+    drawing = get_drawing(data)
+    if drawing:
+        st.button("Reset rectangle", on_click=clear_selection)
+        render_prediction(drawing)
+    else:
+        st.info(
+            "Draw a near-square rectangle on the map to fetch imagery and run the classifier. "
+            "Aim for 500m-1km on each side, similar to the original EuroSAT-RGB tiles."
+        )
+
+
+if __name__ == "__main__":
+    main()

app/model_utils.py

@@ -0,0 +1,55 @@
+from pathlib import Path
+
+import torch
+from PIL import Image
+
+from train import build_model, build_rgb_transform
+
+
+CLASS_NAMES = [
+    "Annual Crop",
+    "Forest",
+    "Herbaceous Vegetation",
+    "Highway",
+    "Industrial Buildings",
+    "Pasture",
+    "Permanent Crop",
+    "Residential Buildings",
+    "River",
+    "SeaLake",
+]
+
+DEFAULT_CHECKPOINT_PATH = Path("weights/rgb_e15_best.pt")
+
+
+def load_rgb_model(checkpoint_path: str | Path = DEFAULT_CHECKPOINT_PATH) -> torch.nn.Module:
+    """Load the EuroSAT-RGB ResNet-50 checkpoint for CPU inference."""
+    checkpoint_path = Path(checkpoint_path)
+    if not checkpoint_path.exists():
+        raise FileNotFoundError(
+            f"RGB checkpoint not found at {checkpoint_path}. "
+            "Add weights/rgb_e15_best.pt before running the demo."
+        )
+
+    device = torch.device("cpu")
+    model = build_model(num_classes=len(CLASS_NAMES), device=device, in_channels=3)
+    checkpoint = torch.load(checkpoint_path, map_location=device)
+    model.load_state_dict(checkpoint["model_state_dict"])
+    model.eval()
+    return model
+
+
+@torch.no_grad()
+def predict_topk(
+    model: torch.nn.Module, image: Image.Image, top_k: int = 3
+) -> list[tuple[str, float]]:
+    """Run RGB inference and return class names with probabilities."""
+    transform = build_rgb_transform(train=False)
+    tensor = transform(image.convert("RGB")).unsqueeze(0)
+    logits = model(tensor)
+    probs = torch.softmax(logits, dim=1).squeeze(0)
+    top_probs, top_indices = torch.topk(probs, k=top_k)
+    return [
+        (CLASS_NAMES[int(class_idx)], float(prob))
+        for prob, class_idx in zip(top_probs, top_indices, strict=True)
+    ]

app/tile_utils.py

@@ -0,0 +1,261 @@
+import math
+import time
+from dataclasses import dataclass
+from io import BytesIO
+from typing import Any
+
+import requests
+import streamlit as st
+from PIL import Image
+
+
+ESRI_TILE_URL = (
+    "https://server.arcgisonline.com/ArcGIS/rest/services/"
+    "World_Imagery/MapServer/tile/{z}/{y}/{x}"
+)
+TILE_SIZE = 256
+USER_AGENT = "eurosat-rgb-streamlit-demo/1.0"
+EUROSAT_TARGET_MIN_M = 500
+EUROSAT_TARGET_MAX_M = 1_000
+EUROSAT_ACCEPTABLE_MIN_M = 250
+EUROSAT_ACCEPTABLE_MAX_M = 1_500
+EUROSAT_MAX_ASPECT_RATIO = 2.0
+
+
+class TileFetchError(RuntimeError):
+    """Raised when an Esri imagery tile cannot be fetched."""
+
+
+@dataclass(frozen=True)
+class BBox:
+    west: float
+    south: float
+    east: float
+    north: float
+
+
+@dataclass(frozen=True)
+class TileRange:
+    zoom: int
+    x_min: int
+    x_max: int
+    y_min: int
+    y_max: int
+
+
+def extract_bbox_from_geojson(drawing: dict[str, Any]) -> BBox:
+    """Extract a lon/lat bbox from a Folium Draw GeoJSON rectangle."""
+    geometry = drawing.get("geometry", {})
+    coordinates = geometry.get("coordinates")
+    if geometry.get("type") != "Polygon" or not coordinates:
+        raise ValueError("Expected a drawn rectangle polygon.")
+
+    ring = coordinates[0]
+    lons = [point[0] for point in ring]
+    lats = [point[1] for point in ring]
+    west, east = min(lons), max(lons)
+    south, north = min(lats), max(lats)
+    if west == east or south == north:
+        raise ValueError("The drawn rectangle has no area.")
+
+    return BBox(west=west, south=south, east=east, north=north)
+
+
+def lonlat_to_tile_fraction(lon: float, lat: float, zoom: int) -> tuple[float, float]:
+    """Convert lon/lat to fractional XYZ tile coordinates.
+
+    Uses the OpenStreetMap slippy-map convention:
+    https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames
+    XYZ y coordinates start at 0 at the northern edge of the world.
+    """
+    lat = max(min(lat, 85.05112878), -85.05112878)
+    lat_rad = math.radians(lat)
+    n = 2**zoom
+    x = (lon + 180.0) / 360.0 * n
+    y = (
+        1.0
+        - math.log(math.tan(lat_rad) + (1.0 / math.cos(lat_rad))) / math.pi
+    ) / 2.0 * n
+    return x, y
+
+
+def bbox_to_tile_range(bbox: BBox, zoom: int) -> TileRange:
+    """Return the inclusive XYZ tile range covering a lon/lat bbox."""
+    max_tile = (2**zoom) - 1
+    x_west, y_north = lonlat_to_tile_fraction(bbox.west, bbox.north, zoom)
+    x_east, y_south = lonlat_to_tile_fraction(bbox.east, bbox.south, zoom)
+
+    x_min = max(0, min(max_tile, math.floor(x_west)))
+    x_max = max(0, min(max_tile, math.floor(x_east)))
+    y_min = max(0, min(max_tile, math.floor(y_north)))
+    y_max = max(0, min(max_tile, math.floor(y_south)))
+
+    return TileRange(
+        zoom=zoom,
+        x_min=min(x_min, x_max),
+        x_max=max(x_min, x_max),
+        y_min=min(y_min, y_max),
+        y_max=max(y_min, y_max),
+    )
+
+
+def choose_zoom_level(bbox: BBox) -> int:
+    """Choose a tile zoom; EuroSAT-scale rectangles use zoom 14-15."""
+    width_m, height_m = bbox_size_meters(bbox)
+    max_side_m = max(width_m, height_m)
+    if max_side_m <= 1_000:
+        return 15
+    if max_side_m <= 5_000:
+        return 14
+    return 13
+
+
+def bbox_size_meters(bbox: BBox) -> tuple[float, float]:
+    """Approximate bbox width and height in meters."""
+    mid_lat = (bbox.north + bbox.south) / 2.0
+    width_m = _haversine_meters(bbox.west, mid_lat, bbox.east, mid_lat)
+    height_m = _haversine_meters(bbox.west, bbox.south, bbox.west, bbox.north)
+    return width_m, height_m
+
+
+def size_warning_for_bbox(bbox: BBox) -> str | None:
+    """Return a user-facing warning for rectangles outside the demo range."""
+    width_m, height_m = bbox_size_meters(bbox)
+    min_side_m = min(width_m, height_m)
+    max_side_m = max(width_m, height_m)
+    if min_side_m < 50:
+        return "This rectangle is very small. Draw at least about 50m on a side."
+    if max_side_m > 5_000:
+        return "This rectangle is very large. Draw at most about 5km on a side."
+    return None
+
+
+def bbox_scale_status(bbox: BBox) -> tuple[str, str]:
+    """Classify whether a bbox is close enough to EuroSAT-RGB tile scale."""
+    width_m, height_m = bbox_size_meters(bbox)
+    min_side_m = min(width_m, height_m)
+    max_side_m = max(width_m, height_m)
+    aspect_ratio = max_side_m / min_side_m
+
+    if min_side_m < EUROSAT_ACCEPTABLE_MIN_M:
+        return (
+            "invalid",
+            "This rectangle is too small for a useful EuroSAT-style prediction. "
+            "Draw closer to 500m-1km on each side.",
+        )
+    if max_side_m > EUROSAT_ACCEPTABLE_MAX_M:
+        return (
+            "invalid",
+            "This rectangle is too large for this EuroSAT-style demo. "
+            "Zoom in and draw closer to 500m-1km on each side.",
+        )
+    if aspect_ratio > EUROSAT_MAX_ASPECT_RATIO:
+        return (
+            "invalid",
+            "This rectangle is too stretched. Draw a more square region, like the original EuroSAT tiles.",
+        )
+    if (
+        EUROSAT_TARGET_MIN_M <= min_side_m
+        and max_side_m <= EUROSAT_TARGET_MAX_M
+    ):
+        return (
+            "good",
+            "Great scale: this is close to the original EuroSAT-RGB tile footprint.",
+        )
+    return (
+        "usable",
+        "Usable, but not ideal. For the most trustworthy demo result, draw 500m-1km on each side.",
+    )
+
+
+def fetch_bbox_image(bbox: BBox, zoom: int | None = None) -> Image.Image:
+    """Fetch Esri XYZ tiles for a bbox, stitch them, and crop to the bbox."""
+    zoom = choose_zoom_level(bbox) if zoom is None else zoom
+    tile_range = bbox_to_tile_range(bbox, zoom)
+
+    stitched = Image.new(
+        "RGB",
+        (
+            (tile_range.x_max - tile_range.x_min + 1) * TILE_SIZE,
+            (tile_range.y_max - tile_range.y_min + 1) * TILE_SIZE,
+        ),
+    )
+
+    for x in range(tile_range.x_min, tile_range.x_max + 1):
+        for y in range(tile_range.y_min, tile_range.y_max + 1):
+            tile = fetch_esri_tile(zoom, x, y)
+            stitched.paste(
+                tile,
+                (
+                    (x - tile_range.x_min) * TILE_SIZE,
+                    (y - tile_range.y_min) * TILE_SIZE,
+                ),
+            )
+            time.sleep(0.05)
+
+    crop_box = _bbox_crop_box(bbox, tile_range, stitched.size)
+    cropped = stitched.crop(crop_box)
+    if cropped.width <= 0 or cropped.height <= 0:
+        raise TileFetchError("The fetched imagery crop was empty.")
+    return cropped
+
+
+@st.cache_data(show_spinner=False)
+def fetch_esri_tile(zoom: int, x: int, y: int) -> Image.Image:
+    """Download one Esri World Imagery XYZ tile."""
+    url = ESRI_TILE_URL.format(z=zoom, x=x, y=y)
+    try:
+        response = requests.get(
+            url,
+            headers={"User-Agent": USER_AGENT},
+            timeout=10,
+        )
+        response.raise_for_status()
+    except requests.RequestException as exc:
+        raise TileFetchError(f"Could not download imagery tile z{zoom}/{x}/{y}.") from exc
+
+    try:
+        return Image.open(BytesIO(response.content)).convert("RGB")
+    except OSError as exc:
+        raise TileFetchError(f"Downloaded imagery tile z{zoom}/{x}/{y} was invalid.") from exc
+
+
+def _bbox_crop_box(
+    bbox: BBox, tile_range: TileRange, stitched_size: tuple[int, int]
+) -> tuple[int, int, int, int]:
+    zoom = tile_range.zoom
+    west_px, north_px = _lonlat_to_global_pixel(bbox.west, bbox.north, zoom)
+    east_px, south_px = _lonlat_to_global_pixel(bbox.east, bbox.south, zoom)
+    origin_x = tile_range.x_min * TILE_SIZE
+    origin_y = tile_range.y_min * TILE_SIZE
+
+    left = math.floor(west_px - origin_x)
+    top = math.floor(north_px - origin_y)
+    right = math.ceil(east_px - origin_x)
+    bottom = math.ceil(south_px - origin_y)
+
+    width, height = stitched_size
+    return (
+        max(0, min(width, left)),
+        max(0, min(height, top)),
+        max(0, min(width, right)),
+        max(0, min(height, bottom)),
+    )
+
+
+def _lonlat_to_global_pixel(lon: float, lat: float, zoom: int) -> tuple[float, float]:
+    x_tile, y_tile = lonlat_to_tile_fraction(lon, lat, zoom)
+    return x_tile * TILE_SIZE, y_tile * TILE_SIZE
+
+
+def _haversine_meters(lon1: float, lat1: float, lon2: float, lat2: float) -> float:
+    radius_m = 6_371_000
+    phi1 = math.radians(lat1)
+    phi2 = math.radians(lat2)
+    delta_phi = math.radians(lat2 - lat1)
+    delta_lambda = math.radians(lon2 - lon1)
+    a = (
+        math.sin(delta_phi / 2.0) ** 2
+        + math.cos(phi1) * math.cos(phi2) * math.sin(delta_lambda / 2.0) ** 2
+    )
+    return 2.0 * radius_m * math.atan2(math.sqrt(a), math.sqrt(1.0 - a))

requirements.txt

@@ -1,3 +1,309 @@
-altair
-pandas
-streamlit
+# This file was autogenerated by uv via the following command:
+#    uv export --format requirements-txt --no-hashes --output-file requirements.txt
+aiohappyeyeballs==2.6.1
+    # via aiohttp
+aiohttp==3.13.3
+    # via fsspec
+aiosignal==1.4.0
+    # via aiohttp
+altair==6.1.0
+    # via streamlit
+annotated-doc==0.0.4
+    # via typer
+anyio==4.12.1
+    # via httpx
+attrs==25.4.0
+    # via
+    #   aiohttp
+    #   jsonschema
+    #   referencing
+blinker==1.9.0
+    # via streamlit
+branca==0.8.2
+    # via
+    #   folium
+    #   streamlit-folium
+cachetools==7.0.6
+    # via streamlit
+certifi==2026.2.25
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+charset-normalizer==3.4.6
+    # via requests
+click==8.3.1
+    # via
+    #   streamlit
+    #   typer
+colorama==0.4.6 ; sys_platform == 'win32'
+    # via
+    #   click
+    #   tqdm
+contourpy==1.3.3
+    # via matplotlib
+cuda-bindings==12.9.4 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+cuda-pathfinder==1.4.3 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via cuda-bindings
+cycler==0.12.1
+    # via matplotlib
+datasets==4.8.2
+    # via eurosat-land-cover-classification
+dill==0.4.1
+    # via
+    #   datasets
+    #   multiprocess
+filelock==3.25.2
+    # via
+    #   datasets
+    #   huggingface-hub
+    #   torch
+folium==0.20.0
+    # via
+    #   eurosat-land-cover-classification
+    #   streamlit-folium
+fonttools==4.62.1
+    # via matplotlib
+frozenlist==1.8.0
+    # via
+    #   aiohttp
+    #   aiosignal
+fsspec==2026.2.0
+    # via
+    #   datasets
+    #   huggingface-hub
+    #   torch
+gitdb==4.0.12
+    # via gitpython
+gitpython==3.1.48
+    # via streamlit
+h11==0.16.0
+    # via httpcore
+hf-xet==1.4.2 ; platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'
+    # via huggingface-hub
+httpcore==1.0.9
+    # via httpx
+httpx==0.28.1
+    # via
+    #   datasets
+    #   huggingface-hub
+huggingface-hub==1.7.1
+    # via datasets
+idna==3.11
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+    #   yarl
+jinja2==3.1.6
+    # via
+    #   altair
+    #   branca
+    #   folium
+    #   pydeck
+    #   streamlit-folium
+    #   torch
+joblib==1.5.3
+    # via scikit-learn
+jsonschema==4.26.0
+    # via altair
+jsonschema-specifications==2025.9.1
+    # via jsonschema
+kiwisolver==1.5.0
+    # via matplotlib
+markdown-it-py==4.0.0
+    # via rich
+markupsafe==3.0.3
+    # via jinja2
+matplotlib==3.10.8
+    # via
+    #   eurosat-land-cover-classification
+    #   seaborn
+mdurl==0.1.2
+    # via markdown-it-py
+mpmath==1.3.0
+    # via sympy
+multidict==6.7.1
+    # via
+    #   aiohttp
+    #   yarl
+multiprocess==0.70.19
+    # via datasets
+narwhals==2.20.0
+    # via altair
+networkx==3.6.1
+    # via torch
+numpy==2.4.3
+    # via
+    #   contourpy
+    #   datasets
+    #   eurosat-land-cover-classification
+    #   folium
+    #   matplotlib
+    #   pandas
+    #   pydeck
+    #   scikit-learn
+    #   scipy
+    #   seaborn
+    #   streamlit
+    #   torchvision
+nvidia-cublas-cu12==12.8.4.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.8.90 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.8.93 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-runtime-cu12==12.8.90 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cudnn-cu12==9.10.2.21 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufft-cu12==11.3.3.83 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufile-cu12==1.13.1.3 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-curand-cu12==10.3.9.90 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusolver-cu12==11.7.3.90 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusparse-cu12==12.5.8.93 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cusparselt-cu12==0.7.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nccl-cu12==2.27.5 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvjitlink-cu12==12.8.93 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cufft-cu12
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+    #   torch
+nvidia-nvshmem-cu12==3.4.5 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvtx-cu12==12.8.90 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+packaging==26.0
+    # via
+    #   altair
+    #   datasets
+    #   huggingface-hub
+    #   matplotlib
+    #   streamlit
+pandas==3.0.1
+    # via
+    #   datasets
+    #   seaborn
+    #   streamlit
+pillow==12.1.1
+    # via
+    #   eurosat-land-cover-classification
+    #   matplotlib
+    #   streamlit
+    #   torchvision
+propcache==0.4.1
+    # via
+    #   aiohttp
+    #   yarl
+protobuf==7.34.1
+    # via streamlit
+pyarrow==23.0.1
+    # via
+    #   datasets
+    #   streamlit
+pydeck==0.9.2
+    # via streamlit
+pygments==2.19.2
+    # via rich
+pyparsing==3.3.2
+    # via matplotlib
+python-dateutil==2.9.0.post0
+    # via
+    #   matplotlib
+    #   pandas
+pyyaml==6.0.3
+    # via
+    #   datasets
+    #   huggingface-hub
+referencing==0.37.0
+    # via
+    #   jsonschema
+    #   jsonschema-specifications
+requests==2.32.5
+    # via
+    #   datasets
+    #   folium
+    #   streamlit
+rich==14.3.3
+    # via typer
+rpds-py==0.30.0
+    # via
+    #   jsonschema
+    #   referencing
+scikit-learn==1.8.0
+    # via eurosat-land-cover-classification
+scipy==1.17.1
+    # via scikit-learn
+seaborn==0.13.2
+    # via eurosat-land-cover-classification
+setuptools==82.0.1
+    # via torch
+shellingham==1.5.4
+    # via typer
+six==1.17.0
+    # via python-dateutil
+smmap==5.0.3
+    # via gitdb
+streamlit==1.56.0
+    # via
+    #   eurosat-land-cover-classification
+    #   streamlit-folium
+streamlit-folium==0.27.1
+    # via eurosat-land-cover-classification
+sympy==1.14.0
+    # via torch
+tenacity==9.1.4
+    # via streamlit
+threadpoolctl==3.6.0
+    # via scikit-learn
+toml==0.10.2
+    # via streamlit
+torch==2.10.0
+    # via
+    #   eurosat-land-cover-classification
+    #   torchvision
+torchvision==0.25.0
+    # via eurosat-land-cover-classification
+tornado==6.5.5
+    # via streamlit
+tqdm==4.67.3
+    # via
+    #   datasets
+    #   eurosat-land-cover-classification
+    #   huggingface-hub
+triton==3.6.0 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+typer==0.24.1
+    # via huggingface-hub
+typing-extensions==4.15.0
+    # via
+    #   altair
+    #   huggingface-hub
+    #   streamlit
+    #   torch
+tzdata==2025.3 ; sys_platform == 'emscripten' or sys_platform == 'win32'
+    # via pandas
+urllib3==2.6.3
+    # via requests
+watchdog==6.0.0 ; sys_platform != 'darwin'
+    # via streamlit
+xxhash==3.6.0
+    # via datasets
+xyzservices==2026.3.0
+    # via folium
+yarl==1.23.0
+    # via aiohttp

train.py

@@ -0,0 +1,169 @@
+import datasets
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+from torchvision import transforms
+from torch import nn
+import torchvision
+from tqdm import tqdm
+from dataset import EuroSATDataset
+import torch.nn.functional as F
+
+# Constants retrieved from:
+# https://docs.pytorch.org/vision/main/models/generated/torchvision.models.resnet50.html
+RESNET_50_WEIGHT_MEAN = [0.485, 0.456, 0.406]
+RESNET_50_WEIGHT_STD = [0.229, 0.224, 0.225]
+
+DATASET_CFG = {
+    "rgb": {"hf_id": "blanchon/EuroSAT_RGB", "in_channels": 3},
+    "msi": {"hf_id": "blanchon/EuroSAT_MSI", "in_channels": 13},
+}
+
+
+def to_chw_tensor(image):
+    hwc = np.array(image, dtype=np.float32)  # HWC typical shape: 64x64x3
+    chw = torch.from_numpy(hwc).permute(2, 0, 1)  # CHW typical shape: 3x64x64
+    return chw
+
+
+def build_rgb_transform(train: bool):
+    ops = [transforms.Resize((224, 224))]
+    if train:
+        ops.append(transforms.RandomHorizontalFlip())
+    ops.extend(
+        [
+            transforms.ToTensor(),
+            transforms.Normalize(RESNET_50_WEIGHT_MEAN, RESNET_50_WEIGHT_STD),
+        ]
+    )
+    return transforms.Compose(ops)
+
+
+def build_msi_transform(train: bool):
+    def _tf(image):
+        chw = to_chw_tensor(image)
+        chw = chw / 10000.0
+        if train and torch.rand(1).item() < 0.5:
+            chw = torch.flip(chw, dims=[2])
+        chw = F.interpolate(
+            chw.unsqueeze(0), size=(224, 224), mode="bilinear", align_corners=False
+        ).squeeze(0)
+        return chw
+
+    return _tf
+
+
+def build_dataloaders(
+    modality: str,
+    batch_size: int,
+    num_workers: int,
+):
+    cfg = DATASET_CFG[modality]
+    ds = datasets.load_dataset(cfg["hf_id"])
+    in_channels = cfg["in_channels"]
+    num_classes = ds["train"].features["label"].num_classes
+
+    if modality == "rgb":
+        train_tf = build_rgb_transform(train=True)
+        eval_tf = build_rgb_transform(train=False)
+    else:
+        train_tf = build_msi_transform(train=True)
+        eval_tf = build_msi_transform(train=False)
+
+    train_ds = EuroSATDataset(ds["train"], train_tf)
+    val_ds = EuroSATDataset(ds["validation"], eval_tf)
+
+    train_loader = DataLoader(
+        train_ds,
+        batch_size=batch_size,
+        shuffle=True,
+        num_workers=num_workers,
+        pin_memory=torch.cuda.is_available(),
+    )
+
+    val_loader = DataLoader(
+        val_ds,
+        batch_size=batch_size,
+        shuffle=False,
+        num_workers=num_workers,
+        pin_memory=torch.cuda.is_available(),
+    )
+
+    return train_loader, val_loader, num_classes, in_channels
+
+
+# Helper function to get the device CPU or GPU available to train the models.
+def get_device() -> torch.device:
+    if torch.cuda.is_available():
+        return torch.device("cuda")
+    if torch.backends.mps.is_available():
+        return torch.device("mps")
+    return torch.device("cpu")
+
+
+def build_model(num_classes: int, device: torch.device, in_channels: int) -> nn.Module:
+    model = torchvision.models.resnet50(weights=None)
+
+    if in_channels != 3:
+        model.conv1 = nn.Conv2d(
+            in_channels=in_channels,
+            out_channels=model.conv1.out_channels,
+            kernel_size=model.conv1.kernel_size,
+            stride=model.conv1.stride,
+            padding=model.conv1.padding,
+            bias=False,
+        )
+    model.fc = nn.Linear(model.fc.in_features, num_classes)
+    return model.to(device)
+
+
+def train_one_epoch(
+    model: nn.Module,
+    loader: DataLoader,
+    criterion: nn.Module,
+    optimizer: torch.optim.Optimizer,
+    device: torch.device,
+):
+    model.train()
+    total_loss = 0.0
+    n = 0
+    
+    for images, labels in tqdm(loader, desc="train", leave=False):
+        images = images.to(device)
+        labels = labels.to(device, dtype=torch.long)
+
+        optimizer.zero_grad()
+        logits = model(images)
+        loss = criterion(logits, labels)
+        loss.backward()
+        optimizer.step()
+
+        batch_n = labels.size(0)
+        total_loss += loss.item() * batch_n
+        n += batch_n
+
+        train_loss = total_loss / max(n, 1)  # max(n, 1) to avoid division by zero
+    return train_loss
+
+
+@torch.no_grad()
+def evaluate(
+    model: nn.Module, loader: DataLoader, criterion: nn.Module, device: torch.device
+):
+    model.eval()
+    total_loss, correct, total = 0.0, 0, 0
+    for images, labels in loader:
+        images = images.to(device)
+        labels = labels.to(device)
+        logits = model(images)
+        loss = criterion(logits, labels)
+
+        total_loss += loss.item() * labels.size(0)
+        correct += (logits.argmax(1) == labels).sum().item()
+        total += labels.size(0)
+
+        val_loss = total_loss / total
+        val_acc = correct / total
+
+    return val_loss, val_acc
+    

weights/rgb_e15_best.pt

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