see torch and cuda config

README.md

@@ -6,7 +6,7 @@ colorTo: purple
 sdk: gradio
 sdk_version: 6.19.0
 python_version: '3.12'
-app_file: app2.py
+app_file: app.py
 pinned: false
 license: apache-2.0
 tags:

app-test.py

@@ -0,0 +1,348 @@
+"""
+AIFS Single v2 — Gradio Forecast App
+Runs ECMWF AIFS Single v2 inference and displays output fields interactively.
+
+Requirements (install in Colab with an L4 or A100 runtime):
+    pip install gradio
+    pip install anemoi-inference[huggingface]==0.8.3 anemoi-models==0.9.3 anemoi-utils==0.4.35.post3
+    pip install torch==2.7.0 torch-geometric==2.6.1
+    pip install earthkit-regrid==0.5.1 ecmwf-opendata==0.3.29 'earthkit-data<1.0.0'
+    pip install flash-attn==2.7.4.post1
+    pip install matplotlib cartopy
+"""
+
+import os
+import datetime
+from collections import defaultdict
+
+import numpy as np
+import gradio as gr
+import spaces
+
+
+# ── Lazy imports so Gradio loads even before heavy deps are installed ──────────
+
+def _import_deps():
+    import torch
+    import earthkit.data as ekd
+    import earthkit.regrid as ekr
+    from anemoi.inference.runners.simple import SimpleRunner
+    from ecmwf.opendata import Client as OpendataClient
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    import cartopy.crs as ccrs
+    import cartopy.feature as cfeature
+    import matplotlib.tri as tri
+    return torch, ekd, ekr, SimpleRunner, OpendataClient, plt, ccrs, cfeature, tri
+
+
+# ── Constants ─────────────────────────────────────────────────────────────────
+
+PARAM_SFC  = ["10u", "10v", "2d", "2t", "msl", "skt", "sp", "tcw", "lsm", "z", "slor", "sdor", "sd"]
+PARAM_SOIL = ["vsw", "sot"]
+PARAM_WAVE = ["wmb", "h1012", "h1214", "h1417", "h1721", "h2125", "h2530", "mwd", "cdww", "mwp", "swh"]
+PARAM_PL   = ["gh", "t", "u", "v", "q"]
+LEVELS     = [1000, 925, 850, 700, 600, 500, 400, 300, 250, 200, 150, 100, 50, 10]
+SOIL_LEVELS = [1, 2]
+
+CHECKPOINT = {"huggingface": "ecmwf/aifs-single-2.0"}
+
+PLOTTABLE_FIELDS = [
+    "100u", "100v", "10u", "10v", "2t", "msl", "sp", "tcw", "swh", "mwp",
+    "t_850", "t_500", "u_850", "v_850", "z_500", "q_700",
+]
+
+CMAP_MAP = {
+    "2t": "RdBu_r", "t_850": "RdBu_r", "t_500": "RdBu_r",
+    "msl": "viridis", "sp": "viridis",
+    "100u": "RdBu", "100v": "RdBu", "10u": "RdBu", "10v": "RdBu",
+    "u_850": "RdBu", "v_850": "RdBu",
+    "swh": "Blues", "mwp": "Blues", "tcw": "Blues",
+    "z_500": "plasma", "q_700": "YlGn",
+}
+
+UNITS_MAP = {
+    "2t": "K", "t_850": "K", "t_500": "K",
+    "msl": "Pa", "sp": "Pa", "z_500": "m²/s²",
+    "100u": "m/s", "100v": "m/s", "10u": "m/s", "10v": "m/s",
+    "u_850": "m/s", "v_850": "m/s",
+    "swh": "m", "mwp": "s", "tcw": "kg/m²", "q_700": "kg/kg",
+}
+
+SOURCE = "ecmwf"
+
+# ── Global state (populated during the run) ───────────────────────────────────
+
+_runner  = None   # cached runner
+_states  = []     # list of forecast state dicts
+
+
+# ── Helper: download + interpolate ────────────────────────────────────────────
+
+def _get_open_data(ekd, ekr, date, param, levelist=[], **kwargs):
+    fields = defaultdict(list)
+    for d in [date - datetime.timedelta(hours=6), date]:
+        data = ekd.from_source(
+            "ecmwf-open-data", date=d, param=param,
+            levelist=levelist, source=SOURCE, **kwargs
+        )
+        for f in data:
+            assert f.to_numpy().shape == (721, 1440)
+            values = np.roll(f.to_numpy(), -f.shape[1] // 2, axis=1)
+            values = ekr.interpolate(values, {"grid": (0.25, 0.25)}, {"grid": "N320"})
+            name = (
+                f"{f.metadata('param')}_{f.metadata('levelist')}"
+                if levelist else f.metadata("param")
+            )
+            fields[name].append(values)
+    for k, v in fields.items():
+        fields[k] = np.stack(v)
+    return fields
+
+
+# ── Core inference function ───────────────────────────────────────────────────
+
+@spaces.GPU
+def run_forecast(lead_time: int, num_chunks: int, progress=gr.Progress(track_tqdm=True)):
+    """Download ICs, run AIFS, return status message."""
+    global _runner, _states
+
+    torch, ekd, ekr, SimpleRunner, OpendataClient, plt, ccrs, cfeature, tri = _import_deps()
+
+    # GPU check
+    if not torch.cuda.is_available():
+        return "❌ No CUDA GPU detected. This model requires an Ampere GPU (e.g. Colab L4/A100).", gr.update(choices=[])
+
+    major, _ = torch.cuda.get_device_capability(0)
+    if major < 8:
+        gpu = torch.cuda.get_device_name(0)
+        return f"❌ GPU '{gpu}' is below Ampere (compute capability < 8.0). FlashAttention requires Ampere or newer.", gr.update(choices=[])
+
+    # Memory optimisation
+    os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
+    os.environ["ANEMOI_INFERENCE_NUM_CHUNKS"] = str(num_chunks)
+
+    yield "⬇️  Fetching latest ECMWF open-data date…", gr.update(choices=[])
+
+    ekd.config.set({"cache-policy": "user"})
+    DATE = OpendataClient(SOURCE).latest()
+
+    yield f"📅  Initial date: {DATE}  |  ⬇️  Downloading surface fields…", gr.update(choices=[])
+    fields = {}
+    fields.update(_get_open_data(ekd, ekr, DATE, PARAM_SFC, levtype="sfc"))
+
+    yield "⬇️  Downloading wave fields…", gr.update(choices=[])
+    fields.update(_get_open_data(ekd, ekr, DATE, PARAM_WAVE, stream="wave"))
+
+    yield "⬇️  Downloading soil fields…", gr.update(choices=[])
+    soil = _get_open_data(ekd, ekr, DATE, PARAM_SOIL, levelist=SOIL_LEVELS)
+
+    yield "⬇️  Downloading pressure-level fields…", gr.update(choices=[])
+    fields.update(_get_open_data(ekd, ekr, DATE, PARAM_PL, levelist=LEVELS))
+
+    # Transforms
+    yield "🔧  Applying data transformations…", gr.update(choices=[])
+    mwd = fields.pop("mwd")
+    mwd_rad = np.deg2rad(mwd)
+    fields["cos_mwd"] = np.cos(mwd_rad)
+    fields["sin_mwd"] = np.sin(mwd_rad)
+
+    mapping = {"sot_1": "stl1", "sot_2": "stl2", "vsw_1": "swvl1", "vsw_2": "swvl2"}
+    for k, v in soil.items():
+        fields[mapping[k]] = v
+
+    fields.pop("q_10", None)
+    fields.pop("q_50", None)
+
+    try:
+        mask = np.equal(ekd.from_source("file", "lsm.grib")[0].to_numpy(flatten=True), 0)
+        for var in ("sd", "swvl1", "swvl2"):
+            fields[var][:, mask] = np.nan
+    except Exception:
+        pass  # lsm.grib optional
+
+    for level in LEVELS:
+        gh = fields.pop(f"gh_{level}")
+        fields[f"z_{level}"] = gh * 9.80665
+
+    input_state = dict(date=DATE, fields=fields)
+
+    # Load runner (cache it)
+    yield "🤖  Loading AIFS Single v2 checkpoint from Hugging Face…", gr.update(choices=[])
+    if _runner is None:
+        _runner = SimpleRunner(CHECKPOINT)
+
+    # Run inference
+    _states = []
+    yield f"🌍  Running {lead_time}h forecast…", gr.update(choices=[])
+    for state in _runner.run(input_state=input_state, lead_time=lead_time):
+        _states.append(state)
+
+    timestamps = [str(s["date"]) for s in _states]
+    available = [f for f in PLOTTABLE_FIELDS if f in _states[-1]["fields"]]
+
+    yield (
+        f"✅  Forecast complete! {len(_states)} time steps generated "
+        f"({lead_time}h at 6h intervals).  GPU: {torch.cuda.get_device_name(0)}",
+        gr.update(choices=timestamps, value=timestamps[-1]),
+    )
+
+
+# ── Plot function ─────────────────────────────────────────────────────────────
+
+def plot_field(field_name: str, timestamp: str):
+    if not _states:
+        return None, "Run the forecast first."
+
+    torch, *rest = _import_deps()
+    plt = rest[4]; ccrs = rest[5]; cfeature = rest[6]; tri_mod = rest[7]
+
+    state = next((s for s in _states if str(s["date"]) == timestamp), _states[-1])
+
+    if field_name not in state["fields"]:
+        return None, f"Field '{field_name}' not available in this forecast state."
+
+    lats = state["latitudes"]
+    lons = state["longitudes"]
+    values = state["fields"][field_name]
+
+    # Shift lons 0-360 → -180-180
+    lons_shifted = np.where(lons > 180, lons - 360, lons)
+
+    cmap  = CMAP_MAP.get(field_name, "viridis")
+    units = UNITS_MAP.get(field_name, "")
+
+    fig, ax = plt.subplots(
+        figsize=(12, 6),
+        subplot_kw={"projection": ccrs.PlateCarree()},
+        facecolor="#0d1117",
+    )
+    ax.set_facecolor("#0d1117")
+    ax.coastlines(color="#8b9ab0", linewidth=0.7)
+    ax.add_feature(cfeature.BORDERS, linestyle=":", edgecolor="#5a6a7e", linewidth=0.5)
+    ax.add_feature(cfeature.OCEAN, facecolor="#111827")
+    ax.add_feature(cfeature.LAND, facecolor="#1a2332")
+
+    triang = tri_mod.Triangulation(lons_shifted, lats)
+    cf = ax.tricontourf(
+        triang, values, levels=24,
+        transform=ccrs.PlateCarree(), cmap=cmap,
+        alpha=0.92,
+    )
+    cbar = fig.colorbar(cf, ax=ax, orientation="vertical", shrink=0.75, pad=0.02)
+    cbar.set_label(f"{field_name}  [{units}]" if units else field_name,
+                   color="white", fontsize=10)
+    cbar.ax.yaxis.set_tick_params(color="white")
+    plt.setp(cbar.ax.yaxis.get_ticklabels(), color="white")
+
+    title = f"{field_name}  |  {timestamp}"
+    ax.set_title(title, color="white", fontsize=12, pad=10)
+
+    fig.patch.set_facecolor("#0d1117")
+    plt.tight_layout()
+
+    path = "/tmp/aifs_plot.png"
+    fig.savefig(path, dpi=130, bbox_inches="tight", facecolor=fig.get_facecolor())
+    plt.close(fig)
+
+    stats = (
+        f"**{field_name}** at {timestamp}\n\n"
+        f"- Min: `{values.min():.4g}` {units}\n"
+        f"- Max: `{values.max():.4g}` {units}\n"
+        f"- Mean: `{values.mean():.4g}` {units}\n"
+        f"- Grid points: `{len(values):,}`"
+    )
+    return path, stats
+
+
+# ── UI ────────────────────────────────────────────��───────────────────────────
+
+DARK_CSS = """
+body, .gradio-container {
+    background: #0d1117 !important;
+    color: #cdd9e5 !important;
+    font-family: 'Inter', 'Segoe UI', sans-serif;
+}
+h1 { color: #58a6ff !important; letter-spacing: -0.5px; }
+h3 { color: #79c0ff !important; }
+.panel { background: #161b22 !important; border: 1px solid #30363d !important; border-radius: 8px; }
+button.primary { background: #1f6feb !important; border: none !important; color: white !important; }
+button.primary:hover { background: #388bfd !important; }
+.label-wrap { color: #8b949e !important; }
+textarea, input, select { background: #1c2128 !important; color: #cdd9e5 !important; border-color: #30363d !important; }
+.output-markdown { color: #cdd9e5 !important; }
+footer { display: none !important; }
+"""
+
+with gr.Blocks(css=DARK_CSS, title="AIFS Single v2 Forecast") as demo:
+    gr.Markdown(
+        """
+# 🌍 AIFS Single v2 — Weather Forecast
+**ECMWF's AI Integrated Forecasting System** | Requires Ampere GPU (Colab L4 / A100)
+        """
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1, elem_classes="panel"):
+            gr.Markdown("### ⚙️ Forecast Settings")
+            lead_time_sl = gr.Slider(
+                minimum=6, maximum=240, step=6, value=24,
+                label="Lead time (hours)",
+                info="Number of forecast hours. Each 6h step adds ~30–60s on an A100.",
+            )
+            num_chunks_sl = gr.Slider(
+                minimum=1, maximum=32, step=1, value=16,
+                label="Memory chunks (ANEMOI_INFERENCE_NUM_CHUNKS)",
+                info="Higher = less GPU memory, slightly slower. 16 works well on A100.",
+            )
+            run_btn = gr.Button("▶ Run Forecast", variant="primary", size="lg")
+            status_box = gr.Textbox(
+                label="Status", lines=3, interactive=False,
+                placeholder="Click 'Run Forecast' to begin…",
+            )
+
+        with gr.Column(scale=2, elem_classes="panel"):
+            gr.Markdown("### 🗺️ Visualise Output")
+            with gr.Row():
+                field_dd = gr.Dropdown(
+                    choices=PLOTTABLE_FIELDS,
+                    value="2t",
+                    label="Field",
+                    info="Select the variable to plot.",
+                )
+                timestamp_dd = gr.Dropdown(
+                    choices=[],
+                    label="Forecast step",
+                    info="Available after running the forecast.",
+                )
+            plot_btn = gr.Button("🖼 Plot Field", variant="secondary")
+            map_img  = gr.Image(label="Global Map", type="filepath")
+            stats_md = gr.Markdown()
+
+    # Wire up
+    run_btn.click(
+        fn=run_forecast,
+        inputs=[lead_time_sl, num_chunks_sl],
+        outputs=[status_box, timestamp_dd],
+    )
+
+    plot_btn.click(
+        fn=plot_field,
+        inputs=[field_dd, timestamp_dd],
+        outputs=[map_img, stats_md],
+    )
+
+    gr.Markdown(
+        """
+---
+**Notes**
+- First run downloads the ~2 GB model checkpoint from Hugging Face and caches it.
+- Data is downloaded from the ECMWF Open Data API (CC BY 4.0 — please attribute ECMWF).
+- Results may differ slightly from operational AIFS due to GPU non-determinism and regrid differences.
+        """
+    )
+
+
+if __name__ == "__main__":
+    demo.launch(share=True)

app.py

@@ -1,348 +1,19 @@
-"""
-AIFS Single v2 — Gradio Forecast App
-Runs ECMWF AIFS Single v2 inference and displays output fields interactively.
-
-Requirements (install in Colab with an L4 or A100 runtime):
-    pip install gradio
-    pip install anemoi-inference[huggingface]==0.8.3 anemoi-models==0.9.3 anemoi-utils==0.4.35.post3
-    pip install torch==2.7.0 torch-geometric==2.6.1
-    pip install earthkit-regrid==0.5.1 ecmwf-opendata==0.3.29 'earthkit-data<1.0.0'
-    pip install flash-attn==2.7.4.post1
-    pip install matplotlib cartopy
-"""
-
-import os
-import datetime
-from collections import defaultdict
-
-import numpy as np
 import gradio as gr
-import spaces
-
-
-# ── Lazy imports so Gradio loads even before heavy deps are installed ──────────
-
-def _import_deps():
-    import torch
-    import earthkit.data as ekd
-    import earthkit.regrid as ekr
-    from anemoi.inference.runners.simple import SimpleRunner
-    from ecmwf.opendata import Client as OpendataClient
-    import matplotlib
-    matplotlib.use("Agg")
-    import matplotlib.pyplot as plt
-    import cartopy.crs as ccrs
-    import cartopy.feature as cfeature
-    import matplotlib.tri as tri
-    return torch, ekd, ekr, SimpleRunner, OpendataClient, plt, ccrs, cfeature, tri
-
-
-# ── Constants ─────────────────────────────────────────────────────────────────
-
-PARAM_SFC  = ["10u", "10v", "2d", "2t", "msl", "skt", "sp", "tcw", "lsm", "z", "slor", "sdor", "sd"]
-PARAM_SOIL = ["vsw", "sot"]
-PARAM_WAVE = ["wmb", "h1012", "h1214", "h1417", "h1721", "h2125", "h2530", "mwd", "cdww", "mwp", "swh"]
-PARAM_PL   = ["gh", "t", "u", "v", "q"]
-LEVELS     = [1000, 925, 850, 700, 600, 500, 400, 300, 250, 200, 150, 100, 50, 10]
-SOIL_LEVELS = [1, 2]
-
-CHECKPOINT = {"huggingface": "ecmwf/aifs-single-2.0"}
-
-PLOTTABLE_FIELDS = [
-    "100u", "100v", "10u", "10v", "2t", "msl", "sp", "tcw", "swh", "mwp",
-    "t_850", "t_500", "u_850", "v_850", "z_500", "q_700",
-]
-
-CMAP_MAP = {
-    "2t": "RdBu_r", "t_850": "RdBu_r", "t_500": "RdBu_r",
-    "msl": "viridis", "sp": "viridis",
-    "100u": "RdBu", "100v": "RdBu", "10u": "RdBu", "10v": "RdBu",
-    "u_850": "RdBu", "v_850": "RdBu",
-    "swh": "Blues", "mwp": "Blues", "tcw": "Blues",
-    "z_500": "plasma", "q_700": "YlGn",
-}
-
-UNITS_MAP = {
-    "2t": "K", "t_850": "K", "t_500": "K",
-    "msl": "Pa", "sp": "Pa", "z_500": "m²/s²",
-    "100u": "m/s", "100v": "m/s", "10u": "m/s", "10v": "m/s",
-    "u_850": "m/s", "v_850": "m/s",
-    "swh": "m", "mwp": "s", "tcw": "kg/m²", "q_700": "kg/kg",
-}
-
-SOURCE = "ecmwf"
-
-# ── Global state (populated during the run) ───────────────────────────────────
-
-_runner  = None   # cached runner
-_states  = []     # list of forecast state dicts
-
-
-# ── Helper: download + interpolate ────────────────────────────────────────────
-
-def _get_open_data(ekd, ekr, date, param, levelist=[], **kwargs):
-    fields = defaultdict(list)
-    for d in [date - datetime.timedelta(hours=6), date]:
-        data = ekd.from_source(
-            "ecmwf-open-data", date=d, param=param,
-            levelist=levelist, source=SOURCE, **kwargs
-        )
-        for f in data:
-            assert f.to_numpy().shape == (721, 1440)
-            values = np.roll(f.to_numpy(), -f.shape[1] // 2, axis=1)
-            values = ekr.interpolate(values, {"grid": (0.25, 0.25)}, {"grid": "N320"})
-            name = (
-                f"{f.metadata('param')}_{f.metadata('levelist')}"
-                if levelist else f.metadata("param")
-            )
-            fields[name].append(values)
-    for k, v in fields.items():
-        fields[k] = np.stack(v)
-    return fields
-
-
-# ── Core inference function ───────────────────────────────────────────────────
-
-@spaces.GPU
-def run_forecast(lead_time: int, num_chunks: int, progress=gr.Progress(track_tqdm=True)):
-    """Download ICs, run AIFS, return status message."""
-    global _runner, _states
-
-    torch, ekd, ekr, SimpleRunner, OpendataClient, plt, ccrs, cfeature, tri = _import_deps()
-
-    # GPU check
-    if not torch.cuda.is_available():
-        return "❌ No CUDA GPU detected. This model requires an Ampere GPU (e.g. Colab L4/A100).", gr.update(choices=[])
-
-    major, _ = torch.cuda.get_device_capability(0)
-    if major < 8:
-        gpu = torch.cuda.get_device_name(0)
-        return f"❌ GPU '{gpu}' is below Ampere (compute capability < 8.0). FlashAttention requires Ampere or newer.", gr.update(choices=[])
-
-    # Memory optimisation
-    os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
-    os.environ["ANEMOI_INFERENCE_NUM_CHUNKS"] = str(num_chunks)
-
-    yield "⬇️  Fetching latest ECMWF open-data date…", gr.update(choices=[])
-
-    ekd.config.set({"cache-policy": "user"})
-    DATE = OpendataClient(SOURCE).latest()
-
-    yield f"📅  Initial date: {DATE}  |  ⬇️  Downloading surface fields…", gr.update(choices=[])
-    fields = {}
-    fields.update(_get_open_data(ekd, ekr, DATE, PARAM_SFC, levtype="sfc"))
-
-    yield "⬇️  Downloading wave fields…", gr.update(choices=[])
-    fields.update(_get_open_data(ekd, ekr, DATE, PARAM_WAVE, stream="wave"))
-
-    yield "⬇️  Downloading soil fields…", gr.update(choices=[])
-    soil = _get_open_data(ekd, ekr, DATE, PARAM_SOIL, levelist=SOIL_LEVELS)
-
-    yield "⬇️  Downloading pressure-level fields…", gr.update(choices=[])
-    fields.update(_get_open_data(ekd, ekr, DATE, PARAM_PL, levelist=LEVELS))
-
-    # Transforms
-    yield "🔧  Applying data transformations…", gr.update(choices=[])
-    mwd = fields.pop("mwd")
-    mwd_rad = np.deg2rad(mwd)
-    fields["cos_mwd"] = np.cos(mwd_rad)
-    fields["sin_mwd"] = np.sin(mwd_rad)
-
-    mapping = {"sot_1": "stl1", "sot_2": "stl2", "vsw_1": "swvl1", "vsw_2": "swvl2"}
-    for k, v in soil.items():
-        fields[mapping[k]] = v
-
-    fields.pop("q_10", None)
-    fields.pop("q_50", None)
-
-    try:
-        mask = np.equal(ekd.from_source("file", "lsm.grib")[0].to_numpy(flatten=True), 0)
-        for var in ("sd", "swvl1", "swvl2"):
-            fields[var][:, mask] = np.nan
-    except Exception:
-        pass  # lsm.grib optional
-
-    for level in LEVELS:
-        gh = fields.pop(f"gh_{level}")
-        fields[f"z_{level}"] = gh * 9.80665
-
-    input_state = dict(date=DATE, fields=fields)
-
-    # Load runner (cache it)
-    yield "🤖  Loading AIFS Single v2 checkpoint from Hugging Face…", gr.update(choices=[])
-    if _runner is None:
-        _runner = SimpleRunner(CHECKPOINT)
-
-    # Run inference
-    _states = []
-    yield f"🌍  Running {lead_time}h forecast…", gr.update(choices=[])
-    for state in _runner.run(input_state=input_state, lead_time=lead_time):
-        _states.append(state)
-
-    timestamps = [str(s["date"]) for s in _states]
-    available = [f for f in PLOTTABLE_FIELDS if f in _states[-1]["fields"]]
-
-    yield (
-        f"✅  Forecast complete! {len(_states)} time steps generated "
-        f"({lead_time}h at 6h intervals).  GPU: {torch.cuda.get_device_name(0)}",
-        gr.update(choices=timestamps, value=timestamps[-1]),
-    )
-
-
-# ── Plot function ─────────────────────────────────────────────────────────────
-
-def plot_field(field_name: str, timestamp: str):
-    if not _states:
-        return None, "Run the forecast first."
-
-    torch, *rest = _import_deps()
-    plt = rest[4]; ccrs = rest[5]; cfeature = rest[6]; tri_mod = rest[7]
-
-    state = next((s for s in _states if str(s["date"]) == timestamp), _states[-1])
-
-    if field_name not in state["fields"]:
-        return None, f"Field '{field_name}' not available in this forecast state."
-
-    lats = state["latitudes"]
-    lons = state["longitudes"]
-    values = state["fields"][field_name]
-
-    # Shift lons 0-360 → -180-180
-    lons_shifted = np.where(lons > 180, lons - 360, lons)
-
-    cmap  = CMAP_MAP.get(field_name, "viridis")
-    units = UNITS_MAP.get(field_name, "")
-
-    fig, ax = plt.subplots(
-        figsize=(12, 6),
-        subplot_kw={"projection": ccrs.PlateCarree()},
-        facecolor="#0d1117",
-    )
-    ax.set_facecolor("#0d1117")
-    ax.coastlines(color="#8b9ab0", linewidth=0.7)
-    ax.add_feature(cfeature.BORDERS, linestyle=":", edgecolor="#5a6a7e", linewidth=0.5)
-    ax.add_feature(cfeature.OCEAN, facecolor="#111827")
-    ax.add_feature(cfeature.LAND, facecolor="#1a2332")
-
-    triang = tri_mod.Triangulation(lons_shifted, lats)
-    cf = ax.tricontourf(
-        triang, values, levels=24,
-        transform=ccrs.PlateCarree(), cmap=cmap,
-        alpha=0.92,
-    )
-    cbar = fig.colorbar(cf, ax=ax, orientation="vertical", shrink=0.75, pad=0.02)
-    cbar.set_label(f"{field_name}  [{units}]" if units else field_name,
-                   color="white", fontsize=10)
-    cbar.ax.yaxis.set_tick_params(color="white")
-    plt.setp(cbar.ax.yaxis.get_ticklabels(), color="white")
-
-    title = f"{field_name}  |  {timestamp}"
-    ax.set_title(title, color="white", fontsize=12, pad=10)
-
-    fig.patch.set_facecolor("#0d1117")
-    plt.tight_layout()
-
-    path = "/tmp/aifs_plot.png"
-    fig.savefig(path, dpi=130, bbox_inches="tight", facecolor=fig.get_facecolor())
-    plt.close(fig)
-
-    stats = (
-        f"**{field_name}** at {timestamp}\n\n"
-        f"- Min: `{values.min():.4g}` {units}\n"
-        f"- Max: `{values.max():.4g}` {units}\n"
-        f"- Mean: `{values.mean():.4g}` {units}\n"
-        f"- Grid points: `{len(values):,}`"
-    )
-    return path, stats
-
-
-# ── UI ────────────────────────────────────────────���───────────────────────────
-
-DARK_CSS = """
-body, .gradio-container {
-    background: #0d1117 !important;
-    color: #cdd9e5 !important;
-    font-family: 'Inter', 'Segoe UI', sans-serif;
-}
-h1 { color: #58a6ff !important; letter-spacing: -0.5px; }
-h3 { color: #79c0ff !important; }
-.panel { background: #161b22 !important; border: 1px solid #30363d !important; border-radius: 8px; }
-button.primary { background: #1f6feb !important; border: none !important; color: white !important; }
-button.primary:hover { background: #388bfd !important; }
-.label-wrap { color: #8b949e !important; }
-textarea, input, select { background: #1c2128 !important; color: #cdd9e5 !important; border-color: #30363d !important; }
-.output-markdown { color: #cdd9e5 !important; }
-footer { display: none !important; }
+import torch
+import sys
+import platform
+
+def get_info():
+    return f"""
+Python: {sys.version}
+Platform: {platform.platform()}
+Torch: {torch.__version__}
+CUDA: {torch.version.cuda}
+CXX11 ABI: {torch._C._GLIBCXX_USE_CXX11_ABI}
+GPU: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'N/A'}
 """
 
-with gr.Blocks(css=DARK_CSS, title="AIFS Single v2 Forecast") as demo:
-    gr.Markdown(
-        """
-# 🌍 AIFS Single v2 — Weather Forecast
-**ECMWF's AI Integrated Forecasting System** | Requires Ampere GPU (Colab L4 / A100)
-        """
-    )
-
-    with gr.Row():
-        with gr.Column(scale=1, elem_classes="panel"):
-            gr.Markdown("### ⚙️ Forecast Settings")
-            lead_time_sl = gr.Slider(
-                minimum=6, maximum=240, step=6, value=24,
-                label="Lead time (hours)",
-                info="Number of forecast hours. Each 6h step adds ~30–60s on an A100.",
-            )
-            num_chunks_sl = gr.Slider(
-                minimum=1, maximum=32, step=1, value=16,
-                label="Memory chunks (ANEMOI_INFERENCE_NUM_CHUNKS)",
-                info="Higher = less GPU memory, slightly slower. 16 works well on A100.",
-            )
-            run_btn = gr.Button("▶ Run Forecast", variant="primary", size="lg")
-            status_box = gr.Textbox(
-                label="Status", lines=3, interactive=False,
-                placeholder="Click 'Run Forecast' to begin…",
-            )
-
-        with gr.Column(scale=2, elem_classes="panel"):
-            gr.Markdown("### 🗺️ Visualise Output")
-            with gr.Row():
-                field_dd = gr.Dropdown(
-                    choices=PLOTTABLE_FIELDS,
-                    value="2t",
-                    label="Field",
-                    info="Select the variable to plot.",
-                )
-                timestamp_dd = gr.Dropdown(
-                    choices=[],
-                    label="Forecast step",
-                    info="Available after running the forecast.",
-                )
-            plot_btn = gr.Button("🖼 Plot Field", variant="secondary")
-            map_img  = gr.Image(label="Global Map", type="filepath")
-            stats_md = gr.Markdown()
-
-    # Wire up
-    run_btn.click(
-        fn=run_forecast,
-        inputs=[lead_time_sl, num_chunks_sl],
-        outputs=[status_box, timestamp_dd],
-    )
-
-    plot_btn.click(
-        fn=plot_field,
-        inputs=[field_dd, timestamp_dd],
-        outputs=[map_img, stats_md],
-    )
-
-    gr.Markdown(
-        """
----
-**Notes**
-- First run downloads the ~2 GB model checkpoint from Hugging Face and caches it.
-- Data is downloaded from the ECMWF Open Data API (CC BY 4.0 — please attribute ECMWF).
-- Results may differ slightly from operational AIFS due to GPU non-determinism and regrid differences.
-        """
-    )
-
+with gr.Blocks() as demo:
+    gr.Textbox(value=get_info, every=1)
 
-if __name__ == "__main__":
-    demo.launch(share=True)
+demo.launch()

app2.py

@@ -1,19 +0,0 @@
-import gradio as gr
-import torch
-import sys
-import platform
-
-def get_info():
-    return f"""
-Python: {sys.version}
-Platform: {platform.platform()}
-Torch: {torch.__version__}
-CUDA: {torch.version.cuda}
-CXX11 ABI: {torch._C._GLIBCXX_USE_CXX11_ABI}
-GPU: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'N/A'}
-"""
-
-with gr.Blocks() as demo:
-    gr.Textbox(value=get_info, every=1)
-
-demo.launch()