Delete t.sh

t.sh

@@ -1,180 +0,0 @@
-#!/bin/bash
-set -e
-
-# === Create folder structure ===
-mkdir -p geo-risk-space/src geo-risk-space/model geo-risk-space/keys
-
-# === model placeholder ===
-cat > geo-risk-space/model/README.txt <<'EOF'
-Place your trained model weights here as:
-    geo-risk-space/model/geo_model.pth
-EOF
-
-# === src/model.py ===
-cat > geo-risk-space/src/model.py <<'EOF'
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torchvision.models as models
-
-class CompactGeoEmbed(nn.Module):
-    def __init__(self, embed_c=32, proj_dim=96, pretrained=False):
-        super().__init__()
-        backbone = models.mobilenet_v2(
-            weights=None if not pretrained else models.MobileNet_V2_Weights.IMAGENET1K_V1
-        ).features
-        self.backbone = backbone
-        self.reduce = nn.Conv2d(1280, embed_c, 1)
-        self.elev_conv = nn.Conv2d(1, embed_c, 3, padding=1)
-        self.conv_head = nn.Sequential(
-            nn.Conv2d(embed_c * 2, embed_c, 3, padding=1),
-            nn.ReLU(True),
-            nn.Conv2d(embed_c, embed_c, 3, padding=1),
-            nn.ReLU(True),
-        )
-        self.proj = nn.Sequential(
-            nn.AdaptiveAvgPool2d(1),
-            nn.Flatten(),
-            nn.Linear(embed_c, proj_dim),
-            nn.ReLU(),
-            nn.Linear(proj_dim, proj_dim),
-        )
-        self.risk_head = nn.Sequential(
-            nn.Linear(proj_dim, proj_dim // 2),
-            nn.ReLU(),
-            nn.Linear(proj_dim // 2, 1),
-            nn.Sigmoid(),
-        )
-
-    def forward(self, img, elev=None):
-        x = self.backbone(img)
-        x = self.reduce(x)
-        if elev is None:
-            elev = torch.zeros(x.size(0), 1, img.size(2), img.size(3), device=x.device)
-        elev = F.interpolate(elev, size=x.shape[2:], mode="bilinear", align_corners=False)
-        e = self.elev_conv(elev)
-        x = self.conv_head(torch.cat([x, e], 1))
-        p = self.proj(x)
-        p = F.normalize(p, dim=1)
-        risk = self.risk_head(p).squeeze(-1)
-        return x, p, risk
-EOF
-
-# === app.py ===
-cat > geo-risk-space/app.py <<'EOF'
-import os, json, io, torch, requests, numpy as np, gradio as gr, ee
-from PIL import Image
-import torchvision.transforms as T
-from huggingface_hub import hf_hub_download
-from src.model import CompactGeoEmbed
-
-MODEL_LOCAL = "/app/model/geo_model.pth"
-HF_REPO_ID = "USERNAME/geo-risk-model"
-HF_FILENAME = "geo_model.pth"
-GEE_KEY_PATH = "/app/keys/gee_service_account.json"
-
-device = torch.device("cpu")
-
-def init_gee():
-    if os.path.exists(GEE_KEY_PATH):
-        with open(GEE_KEY_PATH) as f:
-            svc = json.load(f)
-        ee.Initialize(ee.ServiceAccountCredentials(svc["client_email"], GEE_KEY_PATH))
-        print("✅ GEE initialized")
-    else:
-        print("⚠️ Missing GEE key, skipping Earth Engine init")
-
-def load_model():
-    model = CompactGeoEmbed(32, 96)
-    state = None
-    if os.path.exists(MODEL_LOCAL):
-        state = torch.load(MODEL_LOCAL, map_location="cpu")
-    else:
-        try:
-            p = hf_hub_download(repo_id=HF_REPO_ID, filename=HF_FILENAME)
-            state = torch.load(p, map_location="cpu")
-        except Exception as e:
-            print("⚠️ No weights found:", e)
-    if state:
-        model.load_state_dict(state)
-    model.to(device).eval()
-    return model
-
-init_gee()
-MODEL = load_model()
-tf = T.Compose([T.Resize((128, 128)), T.ToTensor()])
-
-def fetch_satellite(lat, lon):
-    p = ee.Geometry.Point([lon, lat])
-    srtm = ee.Image("USGS/SRTMGL1_003")
-    ndvi = ee.ImageCollection("MODIS/061/MOD13A2").select("NDVI").mean()
-    rgb = (
-        ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED")
-        .filterBounds(p)
-        .filterDate("2023-01-01", "2024-01-01")
-        .sort("CLOUDY_PIXEL_PERCENTAGE")
-        .first()
-    )
-    region = p.buffer(1000).bounds()
-    elev_url = srtm.visualize(min=0, max=3000).getThumbURL(
-        {"region": region, "dimensions": "128x128", "format": "png"}
-    )
-    ndvi_url = ndvi.visualize(min=-2000, max=10000, palette=["white", "green"]).getThumbURL(
-        {"region": region, "dimensions": "128x128", "format": "png"}
-    )
-    elev = Image.open(io.BytesIO(requests.get(elev_url).content)).convert("L")
-    ndvi_img = Image.open(io.BytesIO(requests.get(ndvi_url).content)).convert("RGB")
-    return elev, ndvi_img
-
-def preprocess(img):
-    if img is None:
-        img = Image.new("RGB", (128, 128), (127, 127, 127))
-    return tf(img.convert("RGB")).unsqueeze(0)
-
-def predict(lat, lon, img):
-    lat, lon = float(lat), float(lon)
-    try:
-        elev, sat = fetch_satellite(lat, lon)
-    except Exception as e:
-        elev = Image.new("L", (128, 128), 127)
-        sat = img
-    x = preprocess(sat).to(device)
-    e = torch.tensor(np.array(elev) / 255.0, dtype=torch.float32).unsqueeze(0).unsqueeze(0).to(device)
-    with torch.no_grad():
-        _, _, r = MODEL(x, e)
-    return f"Predicted Risk Score: {float(r.item()):.4f}"
-
-with gr.Blocks() as demo:
-    gr.Markdown("## 🌍 Geo-Risk Prediction (GEE-powered)")
-    lat = gr.Number(value=51.5072, label="Latitude")
-    lon = gr.Number(value=-0.1276, label="Longitude")
-    img = gr.Image(type="pil", label="Optional RGB (Sentinel-2 fallback)")
-    out = gr.Textbox(label="Prediction")
-    gr.Button("Run").click(fn=predict, inputs=[lat, lon, img], outputs=out)
-
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))
-EOF
-
-# === requirements.txt ===
-cat > geo-risk-space/requirements.txt <<'EOF'
-torch
-torchvision
-gradio
-pillow
-requests
-huggingface_hub
-earthengine-api
-EOF
-
-# === README.md ===
-cat > geo-risk-space/README.md <<'EOF'
-# 🌍 Geo-Risk Prediction (GEE + Gradio)
-
-### Setup
-
-```bash
-bash setup_space.sh
-cd geo-risk-space
-pip install -r requirements.txt
-python app.py