From d691197b33a523e3bacba60e13edf781b6d08862 Mon Sep 17 00:00:00 2001 From: ncclementi Date: Wed, 20 May 2026 11:31:03 -0400 Subject: [PATCH] Debbuguing and performance guide (wip) --- .../debbuging-performance/cupy-naive.ipynb | 729 +++++++++++++++++ .../debbuging-performance/cupy_optimal.ipynb | 107 +++ source/guides/debbuging-performance/env.yaml | 14 + .../debbuging-performance/numpy-version.ipynb | 751 ++++++++++++++++++ .../debbuging-performance/pyproject.toml | 14 + .../scripts/cupy-naive.py | 30 + .../scripts/cupy-optimal.py | 32 + .../scripts/eof-analysis.ipynb | 279 +++++++ .../scripts/numpy-version.py | 44 + .../debbuging-performance/xarray-example.md | 46 ++ 10 files changed, 2046 insertions(+) create mode 100644 source/guides/debbuging-performance/cupy-naive.ipynb create mode 100644 source/guides/debbuging-performance/cupy_optimal.ipynb create mode 100644 source/guides/debbuging-performance/env.yaml create mode 100644 source/guides/debbuging-performance/numpy-version.ipynb create mode 100644 source/guides/debbuging-performance/pyproject.toml create mode 100644 source/guides/debbuging-performance/scripts/cupy-naive.py create mode 100644 source/guides/debbuging-performance/scripts/cupy-optimal.py create mode 100644 source/guides/debbuging-performance/scripts/eof-analysis.ipynb create mode 100644 source/guides/debbuging-performance/scripts/numpy-version.py create mode 100644 source/guides/debbuging-performance/xarray-example.md diff --git a/source/guides/debbuging-performance/cupy-naive.ipynb b/source/guides/debbuging-performance/cupy-naive.ipynb new file mode 100644 index 00000000..7170c5a6 --- /dev/null +++ b/source/guides/debbuging-performance/cupy-naive.ipynb @@ -0,0 +1,729 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a49ca19d-7240-4d28-b67c-795982cb4323", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "import cupy as cp\n", + "import numpy as np\n", + "import xarray as xr" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1aed8ba0-1129-47b1-b406-4d45509b4674", + "metadata": {}, + "outputs": [], + "source": [ + "ds = xr.open_dataset(\"air.sig995.2025.nc\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b69b05be-972b-485a-8a32-b8d71b6e20d1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 61MB\n",
+       "Dimensions:  (time: 1460, lat: 73, lon: 144)\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 12kB 2025-01-01 ... 2025-12-31T18:00:00\n",
+       "  * lat      (lat) float32 292B 90.0 87.5 85.0 82.5 ... -82.5 -85.0 -87.5 -90.0\n",
+       "  * lon      (lon) float32 576B 0.0 2.5 5.0 7.5 10.0 ... 350.0 352.5 355.0 357.5\n",
+       "Data variables:\n",
+       "    air      (time, lat, lon) float32 61MB ...\n",
+       "Attributes:\n",
+       "    Conventions:    COARDS\n",
+       "    title:          4x daily NMC reanalysis (2014)\n",
+       "    history:        created 2022/12 by Hoop (netCDF2.3)\n",
+       "    description:    Data is from NMC initialized reanalysis\\n(4x/day).  These...\n",
+       "    platform:       Model\n",
+       "    dataset_title:  NCEP-NCAR Reanalysis 1\n",
+       "    References:     http://www.psl.noaa.gov/data/gridded/data.ncep.reanalysis...
" + ], + "text/plain": [ + " Size: 61MB\n", + "Dimensions: (time: 1460, lat: 73, lon: 144)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 12kB 2025-01-01 ... 2025-12-31T18:00:00\n", + " * lat (lat) float32 292B 90.0 87.5 85.0 82.5 ... -82.5 -85.0 -87.5 -90.0\n", + " * lon (lon) float32 576B 0.0 2.5 5.0 7.5 10.0 ... 350.0 352.5 355.0 357.5\n", + "Data variables:\n", + " air (time, lat, lon) float32 61MB ...\n", + "Attributes:\n", + " Conventions: COARDS\n", + " title: 4x daily NMC reanalysis (2014)\n", + " history: created 2022/12 by Hoop (netCDF2.3)\n", + " description: Data is from NMC initialized reanalysis\\n(4x/day). These...\n", + " platform: Model\n", + " dataset_title: NCEP-NCAR Reanalysis 1\n", + " References: http://www.psl.noaa.gov/data/gridded/data.ncep.reanalysis..." + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4b4eb531-c238-4388-993d-b97b0a4fd102", + "metadata": {}, + "outputs": [], + "source": [ + "t0 = time.perf_counter()\n", + "\n", + "air = ds[\"air\"]\n", + "T = cp.asarray(air)\n", + "# breakpoint()\n", + "ntime, nlat, nlon = T.shape\n", + "\n", + "# --- Build X = anomalies (time × space) ---\n", + "X = T.reshape(ntime, nlat * nlon)\n", + "X = X - X.mean(axis=0, keepdims=True) # remove 2025 mean at each grid point\n", + "\n", + "X = X.get() # get to numpy for np linalg.svd\n", + "# --- EOF via SVD ---\n", + "U, S, Vt = np.linalg.svd(X, full_matrices=False)\n", + "\n", + "# First mode\n", + "eof1 = Vt[0, :].reshape(nlat, nlon) # spatial pattern\n", + "pc1 = U[:, 0] * S[0] # time series\n", + "var_frac1 = (S[0] ** 2) / np.sum(S**2) # variance fraction (0–1)\n", + "\n", + "elapsed = time.perf_counter() - t0" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "08ca3df0-cb2c-4890-bfc6-116cc536b52d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time for EOF/PC calculation: 6.799 s\n" + ] + } + ], + "source": [ + "print(f\"Time for EOF/PC calculation: {elapsed:.3f} s\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e072865e-802a-4cce-baf4-0daaa27917b6", + "metadata": {}, + "outputs": [], + "source": [ + "# notice memory went from 480MB to 810MB\n", + "# utilization barely moved." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/source/guides/debbuging-performance/cupy_optimal.ipynb b/source/guides/debbuging-performance/cupy_optimal.ipynb new file mode 100644 index 00000000..879b1fa6 --- /dev/null +++ b/source/guides/debbuging-performance/cupy_optimal.ipynb @@ -0,0 +1,107 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "13f87ff2-5ce9-4954-918d-be5d3eea36b1", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "import cupy as cp\n", + "import numpy as np\n", + "import xarray as xr" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1eb0759a-0a92-423d-9c4b-264507e1283a", + "metadata": {}, + "outputs": [], + "source": [ + "ds = xr.open_dataset(\"air.sig995.2025.nc\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "15b6a0c9-4206-4702-9580-05a1c37b4869", + "metadata": {}, + "outputs": [], + "source": [ + "t0 = time.perf_counter()\n", + "\n", + "air = ds[\"air\"].cupy.as_cupy()\n", + "T = air.data\n", + "ntime, nlat, nlon = T.shape\n", + "\n", + "# --- Build X = anomalies (time × space) ---\n", + "X = T.reshape(ntime, nlat * nlon)\n", + "X = X - X.mean(axis=0, keepdims=True) # remove 2025 mean at each grid point\n", + "\n", + "# --- EOF via SVD ---\n", + "U, S, Vt = np.linalg.svd(X, full_matrices=False)\n", + "\n", + "# First mode\n", + "eof1 = Vt[0, :].reshape(nlat, nlon) # spatial pattern\n", + "pc1 = U[:, 0] * S[0] # time series\n", + "var_frac1 = (S[0] ** 2) / np.sum(S**2) # variance fraction (0–1)\n", + "\n", + "cp.cuda.Stream.null.synchronize() # wait for cupy to finish the computation\n", + "\n", + "elapsed = time.perf_counter() - t0" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3b965656-ddc6-4117-b025-04ca8b8ce017", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time for EOF/PC calculation: 1.081 s\n" + ] + } + ], + "source": [ + "print(f\"Time for EOF/PC calculation: {elapsed:.3f} s\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "30e67178-7273-4e36-acde-a80d3de65943", + "metadata": {}, + "outputs": [], + "source": [ + "# noticed memory usage and utilization" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/source/guides/debbuging-performance/env.yaml b/source/guides/debbuging-performance/env.yaml new file mode 100644 index 00000000..0cd5d600 --- /dev/null +++ b/source/guides/debbuging-performance/env.yaml @@ -0,0 +1,14 @@ +name: xarray-example +channels: + - conda-forge + - rapidsai +dependencies: + - python>=3.12 + - xarray + - netCDF4 + - bottleneck + - numpy + - cupy-xarray + - ipykernel # needed on brev to enable kernel + # - matplotlib + # - cartopy diff --git a/source/guides/debbuging-performance/numpy-version.ipynb b/source/guides/debbuging-performance/numpy-version.ipynb new file mode 100644 index 00000000..b5dcf993 --- /dev/null +++ b/source/guides/debbuging-performance/numpy-version.ipynb @@ -0,0 +1,751 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "178003a6-2fa8-48e5-956f-bd116c59c370", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "import numpy as np\n", + "import xarray as xr" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "387d6cb5-70c1-42bf-8556-4cd29a65d179", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2026-03-13 22:28:12-- https://downloads.psl.noaa.gov/Datasets/ncep.reanalysis/surface/air.sig995.2025.nc\n", + "Resolving downloads.psl.noaa.gov (downloads.psl.noaa.gov)... 140.172.38.87\n", + "Connecting to downloads.psl.noaa.gov (downloads.psl.noaa.gov)|140.172.38.87|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 22115537 (21M) [application/x-netcdf]\n", + "Saving to: ‘air.sig995.2025.nc.1’\n", + "\n", + "air.sig995.2025.nc. 100%[===================>] 21.09M 15.0MB/s in 1.4s \n", + "\n", + "2026-03-13 22:28:13 (15.0 MB/s) - ‘air.sig995.2025.nc.1’ saved [22115537/22115537]\n", + "\n" + ] + } + ], + "source": [ + "#!wget \"https://downloads.psl.noaa.gov/Datasets/ncep.reanalysis/surface/air.sig995.2025.nc\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cc9bde94-eec8-491e-bfc4-33527019001e", + "metadata": {}, + "outputs": [], + "source": [ + "ds = xr.open_dataset(\"air.sig995.2025.nc\") # 4x daily, sigma 0.995" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2c9837fe-d1bd-454b-abdf-230fea24af8b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 61MB\n",
+       "Dimensions:  (time: 1460, lat: 73, lon: 144)\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 12kB 2025-01-01 ... 2025-12-31T18:00:00\n",
+       "  * lat      (lat) float32 292B 90.0 87.5 85.0 82.5 ... -82.5 -85.0 -87.5 -90.0\n",
+       "  * lon      (lon) float32 576B 0.0 2.5 5.0 7.5 10.0 ... 350.0 352.5 355.0 357.5\n",
+       "Data variables:\n",
+       "    air      (time, lat, lon) float32 61MB ...\n",
+       "Attributes:\n",
+       "    Conventions:    COARDS\n",
+       "    title:          4x daily NMC reanalysis (2014)\n",
+       "    history:        created 2022/12 by Hoop (netCDF2.3)\n",
+       "    description:    Data is from NMC initialized reanalysis\\n(4x/day).  These...\n",
+       "    platform:       Model\n",
+       "    dataset_title:  NCEP-NCAR Reanalysis 1\n",
+       "    References:     http://www.psl.noaa.gov/data/gridded/data.ncep.reanalysis...
" + ], + "text/plain": [ + " Size: 61MB\n", + "Dimensions: (time: 1460, lat: 73, lon: 144)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 12kB 2025-01-01 ... 2025-12-31T18:00:00\n", + " * lat (lat) float32 292B 90.0 87.5 85.0 82.5 ... -82.5 -85.0 -87.5 -90.0\n", + " * lon (lon) float32 576B 0.0 2.5 5.0 7.5 10.0 ... 350.0 352.5 355.0 357.5\n", + "Data variables:\n", + " air (time, lat, lon) float32 61MB ...\n", + "Attributes:\n", + " Conventions: COARDS\n", + " title: 4x daily NMC reanalysis (2014)\n", + " history: created 2022/12 by Hoop (netCDF2.3)\n", + " description: Data is from NMC initialized reanalysis\\n(4x/day). These...\n", + " platform: Model\n", + " dataset_title: NCEP-NCAR Reanalysis 1\n", + " References: http://www.psl.noaa.gov/data/gridded/data.ncep.reanalysis..." + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "42f5df4e-ff0e-4a97-8eab-df2a4a9e412b", + "metadata": {}, + "outputs": [], + "source": [ + "t0 = time.perf_counter()\n", + "\n", + "air = ds[\"air\"]\n", + "T = np.asarray(air)\n", + "ntime, nlat, nlon = T.shape\n", + "\n", + "# --- Build X = anomalies (time × space) ---\n", + "X = T.reshape(ntime, nlat * nlon)\n", + "X = X - X.mean(axis=0, keepdims=True) # remove 2025 mean at each grid point\n", + "\n", + "# --- EOF via SVD ---\n", + "U, S, Vt = np.linalg.svd(X, full_matrices=False)\n", + "\n", + "# First mode\n", + "eof1 = Vt[0, :].reshape(nlat, nlon) # spatial pattern\n", + "pc1 = U[:, 0] * S[0] # time series\n", + "var_frac1 = (S[0] ** 2) / np.sum(S**2) # variance fraction (0–1)\n", + "\n", + "elapsed = time.perf_counter() - t0" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a708fa5d-41a3-4bca-afe2-c8bd9b5db92d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time for EOF/PC calculation: 6.214 s\n" + ] + } + ], + "source": [ + "print(f\"Time for EOF/PC calculation: {elapsed:.3f} s\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7437de2c-10a6-4628-a0cd-698faf513deb", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/source/guides/debbuging-performance/pyproject.toml b/source/guides/debbuging-performance/pyproject.toml new file mode 100644 index 00000000..0bf38c24 --- /dev/null +++ b/source/guides/debbuging-performance/pyproject.toml @@ -0,0 +1,14 @@ +[project] + name = "xarray-uv-example" + version = "0.1.0" + requires-python = "==3.13.*" + dependencies = [ + "xarray", + "netCDF4", + "bottleneck", + "numpy", + "cupy-cuda12x[ctk]", + "cupy-xarray @ git+https://github.com/xarray-contrib/cupy-xarray.git", + "jupyterlab-nvdashboard", + "ipykernel", + ] \ No newline at end of file diff --git a/source/guides/debbuging-performance/scripts/cupy-naive.py b/source/guides/debbuging-performance/scripts/cupy-naive.py new file mode 100644 index 00000000..f5452ee3 --- /dev/null +++ b/source/guides/debbuging-performance/scripts/cupy-naive.py @@ -0,0 +1,30 @@ +import time + +import cupy as cp +import numpy as np +import xarray as xr + +ds = xr.open_dataset("air.sig995.2025.nc") + + +t0 = time.perf_counter() +air = ds["air"] +T = cp.asarray(air) +# breakpoint() +ntime, nlat, nlon = T.shape + +# --- Build X = anomalies (time × space) --- +X = T.reshape(ntime, nlat * nlon) +X = X - X.mean(axis=0, keepdims=True) # remove 2025 mean at each grid point + +X = X.get() # get to numpy for np linalg.svd +# --- EOF via SVD --- +U, S, Vt = np.linalg.svd(X, full_matrices=False) + +# First mode +eof1 = Vt[0, :].reshape(nlat, nlon) # spatial pattern +pc1 = U[:, 0] * S[0] # time series +var_frac1 = (S[0] ** 2) / np.sum(S**2) # variance fraction (0–1) + +elapsed = time.perf_counter() - t0 +print(f"Time for EOF/PC calculation: {elapsed:.3f} s") diff --git a/source/guides/debbuging-performance/scripts/cupy-optimal.py b/source/guides/debbuging-performance/scripts/cupy-optimal.py new file mode 100644 index 00000000..87e589e4 --- /dev/null +++ b/source/guides/debbuging-performance/scripts/cupy-optimal.py @@ -0,0 +1,32 @@ +import time + +import cupy as cp +import numpy as np +import xarray as xr + +ds = xr.open_dataset("air.sig995.2025.nc") + + +t0 = time.perf_counter() + +air = ds["air"].cupy.as_cupy() +T = air.data +ntime, nlat, nlon = T.shape + +# --- Build X = anomalies (time × space) --- +X = T.reshape(ntime, nlat * nlon) +X = X - X.mean(axis=0, keepdims=True) # remove 2025 mean at each grid point + +# --- EOF via SVD --- +U, S, Vt = np.linalg.svd(X, full_matrices=False) + +# First mode +eof1 = Vt[0, :].reshape(nlat, nlon) # spatial pattern +pc1 = U[:, 0] * S[0] # time series +var_frac1 = (S[0] ** 2) / np.sum(S**2) # variance fraction (0–1) + +cp.cuda.Stream.null.synchronize() # wait for cupy to finish the computation + +elapsed = time.perf_counter() - t0 + +print(f"Time for EOF/PC calculation: {elapsed:.3f} s") diff --git a/source/guides/debbuging-performance/scripts/eof-analysis.ipynb b/source/guides/debbuging-performance/scripts/eof-analysis.ipynb new file mode 100644 index 00000000..4cfa1ffe --- /dev/null +++ b/source/guides/debbuging-performance/scripts/eof-analysis.ipynb @@ -0,0 +1,279 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cell-00", + "metadata": {}, + "source": [ + "# EOF Analysis of Near-Surface Air Temperature (2025)\n", + "\n", + "This notebook computes and visualizes the **first Empirical Orthogonal Function (EOF)** of global near-surface air temperature anomalies using NCEP/NCAR reanalysis data.\n", + "\n", + "EOF analysis decomposes a spatiotemporal field into orthogonal spatial patterns ranked by how much variance they explain. The first EOF is the single spatial pattern that best summarizes the dominant mode of variability in the dataset.\n", + "\n", + "## Dataset\n", + "\n", + "- **Variable**: Air temperature at sigma level 0.995 (near the surface, ~50 m above ground)\n", + "- **Temporal resolution**: 4x daily (every 6 hours) throughout 2025 (~1460 timesteps)\n", + "- **Source**: `air.sig995.2025.nc` — NCEP/NCAR reanalysis\n", + "- **Climatology**: `air.sig995.4Xday.1981-2010.ltm.nc` — NOAA PSL 1981–2010 long-term mean\n", + "- **Coverage**: Global grid" + ] + }, + { + "cell_type": "markdown", + "id": "cell-01", + "metadata": {}, + "source": [ + "## 1. Imports and data loading" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cell-02", + "metadata": {}, + "outputs": [], + "source": [ + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import xarray as xr" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f3a65d0e", + "metadata": {}, + "outputs": [], + "source": [ + "ds = xr.open_dataset(\"air.sig995.2025.nc\")\n", + "clim = xr.open_dataset(\n", + " \"air.sig995.4Xday.1981-2010.ltm.nc\",\n", + " decode_times=xr.coders.CFDatetimeCoder(use_cftime=True),\n", + ")[\"air\"]" + ] + }, + { + "cell_type": "markdown", + "id": "cell-03", + "metadata": {}, + "source": [ + "## 2. Compute anomalies using the 1981-2010 climatology\n", + "\n", + "We subtract the **long-term climatological mean** for each 6-hourly slot of the year rather than the 2025 time-mean. This removes the expected seasonal cycle and leaves only *departures from normal* — the anomalies that represent actual climate variability.\n", + "\n", + "Each 2025 timestep is matched to its corresponding climatological slot using the day-of-year and hour-of-day, preserving the diurnal cycle." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "cell-04", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Anomaly array shape: 1460 x 73 x 144\n", + "Range: -44.97 K to 37.09 K\n" + ] + } + ], + "source": [ + "clim_indexed = clim.assign_coords(time=np.arange(len(clim.time)))\n", + "\n", + "doy = ds[\"air\"].time.dt.dayofyear.values - 1\n", + "hod = ds[\"air\"].time.dt.hour.values // 6\n", + "time_idx = (doy * 4 + hod).astype(int)\n", + "\n", + "clim_matched = clim_indexed.isel(time=time_idx).assign_coords(time=ds[\"air\"].time)\n", + "anomalies = ds[\"air\"] - clim_matched\n", + "\n", + "T = np.asarray(anomalies)\n", + "ntime, nlat, nlon = T.shape" + ] + }, + { + "cell_type": "markdown", + "id": "cell-05", + "metadata": {}, + "source": [ + "## 3. Area weighting and SVD\n", + "\n", + "On a regular latitude-longitude grid, cells near the poles are much smaller than those near the equator. Without correction, the SVD gives undue weight to polar variability simply because there are more grid points per unit area there.\n", + "\n", + "We multiply each spatial column by sqrt(cos(lat)) before the SVD, then divide the resulting EOF patterns by the same weights to recover physically interpretable spatial patterns." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "cell-06", + "metadata": {}, + "outputs": [], + "source": [ + "lats = ds.lat.values\n", + "lons = ds.lon.values\n", + "\n", + "w = np.tile(\n", + " np.sqrt(np.maximum(np.cos(np.deg2rad(lats)), 0))[:, np.newaxis], (1, nlon)\n", + ").reshape(-1)\n", + "\n", + "X = T.reshape(ntime, nlat * nlon)\n", + "Xw = X * w[np.newaxis, :]\n", + "\n", + "U, S, Vt = np.linalg.svd(Xw, full_matrices=False)" + ] + }, + { + "cell_type": "markdown", + "id": "cell-07", + "metadata": {}, + "source": [ + "## 4. Extract EOF1 and plot\n", + "\n", + "### How to read this map\n", + "\n", + "- **Red regions** (positive loadings) and **blue regions** (negative loadings) vary in *opposition*: when red areas are anomalously warm, blue areas are anomalously cool, and vice versa.\n", + "- **Near-zero loadings** (white) — those locations are largely unrelated to this mode.\n", + "- The **sign convention is arbitrary** — what matters is the relative sign between regions.\n", + "\n", + "### What to expect\n", + "\n", + "With the seasonal cycle removed, EOF1 captures the **leading pattern of anomalous temperature variability in 2025** relative to the 1981-2010 baseline. For 2025, this is likely to show a structure linked to ENSO — a large-scale warm or cool anomaly in the tropical Pacific propagating into the extratropics. Land areas show larger loadings than ocean because land temperature anomalies are more volatile." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "cell-08", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "EOF1 explains 13.2% of total anomaly variance\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "eof1 = np.where(w > 0, Vt[0, :] / np.where(w > 0, w, 1), np.nan).reshape(nlat, nlon)\n", + "var_frac1 = (S[0] ** 2) / np.sum(S**2)\n", + "print(f\"EOF1 explains {var_frac1 * 100:.1f}% of total anomaly variance\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(14, 6), subplot_kw={\"projection\": ccrs.Robinson()})\n", + "\n", + "vmax = np.nanmax(\n", + " np.abs(eof1)\n", + ") # use nanmax to ignore NaN at poles (w=0 → divide by zero)\n", + "cf = ax.contourf(\n", + " lons,\n", + " lats,\n", + " eof1,\n", + " levels=21,\n", + " cmap=\"RdBu_r\",\n", + " vmin=-vmax,\n", + " vmax=vmax,\n", + " transform=ccrs.PlateCarree(),\n", + ")\n", + "ax.add_feature(cfeature.COASTLINE, linewidth=0.6)\n", + "ax.add_feature(cfeature.BORDERS, linewidth=0.3, linestyle=\":\")\n", + "ax.gridlines(draw_labels=True, linewidth=0.3, color=\"gray\", alpha=0.5)\n", + "plt.colorbar(\n", + " cf,\n", + " ax=ax,\n", + " orientation=\"horizontal\",\n", + " pad=0.05,\n", + " label=\"EOF1 loading (K / unit PC amplitude)\",\n", + ")\n", + "ax.set_title(\n", + " f\"EOF1 — dominant temperature anomaly pattern relative to 1981-2010 ({var_frac1*100:.1f}% of variance)\",\n", + " fontsize=13,\n", + ")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7zyeu1hl4dp", + "metadata": {}, + "source": [ + "## 5. Mean anomaly map\n", + "\n", + "To put EOF1 in context, it helps to also look at the **2025 annual mean anomaly** — the average temperature departure from the 1981-2010 climatology across all timesteps.\n", + "\n", + "This is a different question from what EOF1 answers:\n", + "\n", + "- **Mean anomaly map** — *Where* was 2025 warm or cool compared to the 1981-2010 baseline? This is a single snapshot summarizing the background state of the whole year.\n", + "- **EOF1 map** — *How* did temperatures fluctuate throughout 2025, and in what spatial pattern? This captures the dominant mode of variability on top of that background state.\n", + "\n", + "Think of it this way: the mean anomaly map tells you the starting position; the EOF1 map tells you the direction in which things moved most often.\n", + "\n", + "The two maps are complementary. The mean anomaly is expected to be almost entirely positive (red) because 2025 was globally much warmer than the 1981-2010 baseline. EOF1 then shows the spatial shape of the biggest fluctuations *around* that already-warm mean — which is why it appears mostly blue (negative loadings): the dominant fluctuation pattern is one where most of the world temporarily cools relative to the 2025 mean, while a few regions (e.g. parts of Central Asia, Patagonia) warm." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "577a5cca", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mean_anom = anomalies.mean(dim=\"time\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(14, 6), subplot_kw={\"projection\": ccrs.Robinson()})\n", + "vmax = float(np.abs(mean_anom).max())\n", + "cf = ax.contourf(\n", + " lons,\n", + " lats,\n", + " mean_anom.values,\n", + " levels=21,\n", + " cmap=\"RdBu_r\",\n", + " vmin=-vmax,\n", + " vmax=vmax,\n", + " transform=ccrs.PlateCarree(),\n", + ")\n", + "ax.add_feature(cfeature.COASTLINE, linewidth=0.6)\n", + "ax.gridlines(draw_labels=True, linewidth=0.3, color=\"gray\", alpha=0.5)\n", + "plt.colorbar(cf, ax=ax, orientation=\"horizontal\", pad=0.05, label=\"Mean anomaly (K)\")\n", + "ax.set_title(\"2025 mean temperature anomaly relative to 1981-2010\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/source/guides/debbuging-performance/scripts/numpy-version.py b/source/guides/debbuging-performance/scripts/numpy-version.py new file mode 100644 index 00000000..6eb358a5 --- /dev/null +++ b/source/guides/debbuging-performance/scripts/numpy-version.py @@ -0,0 +1,44 @@ +# Simplified EOF analysis for benchmarking purposes. +# +# This script is a deliberate simplification of the full analysis in eof-analysis.ipynb. +# It exists to isolate and time the core SVD computation without the overhead of +# data preparation steps. Two key shortcuts are taken: +# +# 1. No climatology subtraction — anomalies are computed by removing the 2025 +# time-mean at each grid point instead of subtracting the 1981-2010 long-term +# climatology.It mixes the seasonal cycle into the anomalies, so the +# resulting EOF patterns are not physically meaningful. +# +# 2. No area weighting — latitude weights (sqrt(cos(lat))) are omitted, so polar +# grid cells are treated as equal in area to tropical ones. This inflates the +# contribution of high-latitude variability to the SVD. +# +# For more meaningful results, check eof-analysis.ipynb. + +import time + +import numpy as np +import xarray as xr + +ds = xr.open_dataset("air.sig995.2025.nc") # 4x daily, sigma 0.995 + +t0 = time.perf_counter() + +air = ds["air"] +T = np.asarray(air) +ntime, nlat, nlon = T.shape + +# --- Build X = anomalies (time × space) --- +X = T.reshape(ntime, nlat * nlon) +X = X - X.mean(axis=0, keepdims=True) # remove 2025 mean at each grid point + +# --- EOF via SVD --- +U, S, Vt = np.linalg.svd(X, full_matrices=False) + +# First mode +eof1 = Vt[0, :].reshape(nlat, nlon) # spatial pattern +pc1 = U[:, 0] * S[0] # time series +var_frac1 = (S[0] ** 2) / np.sum(S**2) # variance fraction (0–1) + +elapsed = time.perf_counter() - t0 +print(f"Time for EOF/PC calculation: {elapsed:.3f} s") diff --git a/source/guides/debbuging-performance/xarray-example.md b/source/guides/debbuging-performance/xarray-example.md new file mode 100644 index 00000000..01a802e3 --- /dev/null +++ b/source/guides/debbuging-performance/xarray-example.md @@ -0,0 +1,46 @@ +# Xarray example debugging + +Get data + +```bash +wget "https://downloads.psl.noaa.gov/Datasets/ncep.reanalysis/surface/air.sig995.2025.nc" +``` + +and + +```bash +wget https://downloads.psl.noaa.gov/Datasets/ncep.reanalysis.derived/surface/air.sig995.4Xday.1981-2010.ltm.nc +``` + +- More of a real example in notebook +- scripts are adapted to look at performance +- run on brev + - install env, + - update kernel + - install nvdashboard + - think of numpy version in a notebook. convert to script with nbconvert. + +One of the things we can do is look at nv dashboard + +For conda, look st this common setup + +On brev + +```bash +uv pip install jupyterlab_nvdashboard + +sudo systemctl restart jupyter.service +``` + +Install conda + +```bash +curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh" + +bash Miniforge3-$(uname)-$(uname -m).sh # Follow the prompts and choose yes to update your shell profile to automatically initialize conda +``` + +```bash +source ~/.bashrc + +```