Update README.md

README.md

@@ -1,3 +1,466 @@
----
-license: apache-2.0
----
+---
+license: apache-2.0
+language:
+- en
+pretty_name: Population
+---
+# 🌍 LandScan Global Population Dataset — `pop_2000-23.h5`
+
+[![License](https://img.shields.io/badge/License-CC%20BY%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by/4.0/)
+[![Source](https://img.shields.io/badge/Source-Oak%20Ridge%20National%20Laboratory-blue)](https://landscan.ornl.gov/)
+[![Resolution](https://img.shields.io/badge/Resolution-1%20km-green)]()
+[![Years](https://img.shields.io/badge/Years-2000--2023-orange)]()
+[![Format](https://img.shields.io/badge/Format-HDF5-red)]()
+
+A production-ready, chunked HDF5 tensor of **LandScan Global** annual population estimates from **2000 to 2023** — packaged for efficient use in deep learning, geospatial analysis, and HPC workflows. No more downloading 24 separate GeoTIFFs.
+
+---
+
+## 📦 Dataset at a Glance
+
+| Property | Value |
+|---|---|
+| **Source** | LandScan Global — Oak Ridge National Laboratory (ORNL) |
+| **Years covered** | 2000 – 2023 (24 time steps) |
+| **Spatial resolution** | ~1 km (30 arc-seconds) |
+| **Spatial extent** | Global (180°W–180°E, 90°S–90°N) |
+| **Master grid** | 21,600 rows × 43,200 columns |
+| **CRS** | WGS84 / EPSG:4326 |
+| **Unit** | Ambient population count per pixel |
+| **Data type** | float32 |
+| **Format** | HDF5 (chunked + GZIP compressed) |
+| **Chunk shape** | (1, 256, 256) — time × lat × lon |
+
+> **What is LandScan?**
+> LandScan represents ambient population — the average number of people present in a location over 24 hours — rather than residential census counts. It integrates census data, land cover, roads, slope, and remote sensing to model where people actually are, not just where they live.
+
+---
+
+## 🗂️ File Structure
+
+```
+pop_2000-23.h5
+│
+├── /population              float32  (24, 21600, 43200)    ← main data tensor
+│       dim[0] → time        24 annual steps (2000–2023)
+│       dim[1] → lat         21,600 latitude  rows  (90°N → 90°S)
+│       dim[2] → lon         43,200 longitude cols  (180°W → 180°E)
+│
+├── /coords
+│   ├── years                int32    (24,)     [2000, 2001, …, 2023]
+│   ├── lat                  float64  (21600,)  centre latitude  of each row (°N)
+│   └── lon                  float64  (43200,)  centre longitude of each col (°E)
+│
+├── /native_extent
+│   ├── years                int32    (24,)     year index
+│   ├── n_rows               int32    (24,)     native row count per year
+│   └── n_cols               int32    (24,)     native col count per year
+│
+└── /stats
+    ├── mean                 float32  (24,)     mean over inhabited pixels
+    ├── std                  float32  (24,)     std  over inhabited pixels
+    ├── max                  float32  (24,)     max  pixel value per year
+    ├── total_pop            float32  (24,)     global population sum per year
+    └── nan_fraction         float32  (24,)     fraction of NaN pixels per year
+```
+
+### NaN semantics
+
+There are two distinct sources of `NaN` in this dataset:
+
+| NaN type | Meaning |
+|---|---|
+| Within native extent, flagged as nodata | Ocean, permanent ice, or uninhabited area |
+| Beyond native extent | That LandScan release had a smaller grid (2001–2012 were 20,880 rows) — data simply did not exist |
+
+The `/native_extent` group tells you exactly how many rows and columns contained real data for each year, so your code can mask accordingly.
+
+---
+
+## ⚡ Quickstart — Partial Reads (No Full Download Needed)
+
+HuggingFace supports [HTTP range requests](https://huggingface.co/docs/hub/datasets-adding#large-files) on `.h5` files. The HDF5 chunked layout `(1, 256, 256)` means **only the chunks you touch are transferred over the network** — you never need to download the full file.
+
+### Install dependencies
+
+```bash
+pip install h5py numpy fsspec huggingface_hub
+```
+
+### Open the file remotely
+
+```python
+import h5py
+import numpy as np
+from huggingface_hub import hf_hub_url
+
+# Stream directly from HuggingFace — no full download
+url = hf_hub_url(
+    repo_id   = "Daksh17440/landscan-global-population",
+    filename  = "pop_2000-23.h5",
+    repo_type = "dataset",
+)
+
+# ROS3 driver = HTTP range-request backend for HDF5
+f = h5py.File(url, "r", driver="ros3")
+
+pop  = f["population"]      # shape (24, 21600, 43200) — not yet loaded
+lat  = f["coords/lat"][:]
+lon  = f["coords/lon"][:]
+yrs  = f["coords/years"][:] # [2000, 2001, …, 2023]
+```
+
+> **Tip:** Install `hdf5` with ROS3 support: `conda install -c conda-forge h5py` (includes it by default). For pip: `pip install h5py[ros3]`.
+
+---
+
+## 🔍 Usage Examples
+
+### 1. Read a single year
+
+```python
+# Year 2020 is at index 20  (2020 - 2000 = 20)
+pop_2020 = f["population"][20, :, :]    # shape (21600, 43200)
+# Only ~3.4 GB RAM; only touched chunks downloaded over network
+```
+
+### 2. Look up the index for any year
+
+```python
+years = f["coords/years"][:]
+
+def year_idx(y):
+    idx = np.where(years == y)[0]
+    if len(idx) == 0:
+        raise ValueError(f"Year {y} not in dataset")
+    return int(idx[0])
+
+pop_2015 = f["population"][year_idx(2015), :, :]
+```
+
+### 3. Spatial crop — bounding box query
+
+```python
+lat = f["coords/lat"][:]
+lon = f["coords/lon"][:]
+
+def bbox_slice(lat_min, lat_max, lon_min, lon_max):
+    """Return numpy index slices for a lat/lon bounding box."""
+    row = np.where((lat >= lat_min) & (lat <= lat_max))[0]
+    col = np.where((lon >= lon_min) & (lon <= lon_max))[0]
+    return slice(row[0], row[-1]+1), slice(col[0], col[-1]+1)
+
+# South Asia:  5–35°N,  65–95°E
+rs, cs = bbox_slice(5, 35, 65, 95)
+
+# Single year crop — minimal network transfer
+south_asia_2023 = f["population"][23, rs, cs]
+
+# All years crop — full time series for the region
+south_asia_all  = f["population"][:, rs, cs]   # shape (24, ~3334, ~3334)
+```
+
+### 4. Time-range + spatial crop together
+
+```python
+# India, 2010–2020
+years   = f["coords/years"][:]
+t_mask  = np.where((years >= 2010) & (years <= 2020))[0]
+rs, cs  = bbox_slice(8, 37, 68, 97)
+
+india_decade = f["population"][t_mask[0]:t_mask[-1]+1, rs, cs]
+# shape: (11, H_india, W_india)
+```
+
+### 5. Country / region centroids — point time series
+
+```python
+# Population at a single point over all years (full time series)
+# New Delhi: 28.6°N, 77.2°E
+lat_idx = int(np.argmin(np.abs(lat - 28.6)))
+lon_idx = int(np.argmin(np.abs(lon - 77.2)))
+
+delhi_series = f["population"][:, lat_idx, lon_idx]   # shape (24,)
+# Extremely fast — 24 single-pixel reads
+```
+
+### 6. Global population trend (no pixel reads needed)
+
+```python
+# Pre-computed — instant, no pixel data transferred
+total_pop = f["stats/total_pop"][:]
+years     = f["coords/years"][:]
+
+for yr, pop in zip(years, total_pop):
+    print(f"  {yr}: {pop/1e9:.3f} billion")
+```
+
+### 7. Use with xarray (NetCDF-style labelled arrays)
+
+```python
+import xarray as xr
+import h5py
+import numpy as np
+
+with h5py.File("pop_2000-23.h5", "r") as f:
+    # Load a region into an xarray DataArray with named coords
+    rs, cs = bbox_slice(5, 35, 65, 95)
+    data   = f["population"][:, rs, cs]
+    years  = f["coords/years"][:]
+    lats   = f["coords/lat"][rs]
+    lons   = f["coords/lon"][cs]
+
+da = xr.DataArray(
+    data,
+    dims   = ["time", "lat", "lon"],
+    coords = {"time": years, "lat": lats, "lon": lons},
+    name   = "population",
+    attrs  = {"units": "persons per pixel", "source": "LandScan Global"}
+)
+
+# Now use xarray operations
+annual_mean = da.mean(dim=["lat", "lon"])
+trend       = da.sel(time=slice(2010, 2020))
+```
+
+### 8. PyTorch — lazy streaming Dataset
+
+```python
+import h5py
+import numpy as np
+import torch
+from torch.utils.data import Dataset
+
+class LandScanDataset(Dataset):
+    """
+    Streams spatial patches on demand.
+    Never loads the full tensor into RAM.
+
+    Parameters
+    ----------
+    h5_path    : local path or remote ROS3 URL
+    year_range : (start_year, end_year) inclusive, e.g. (2010, 2020)
+    bbox       : (lat_min, lat_max, lon_min, lon_max) or None for global
+    patch_size : spatial size of each returned patch (pixels)
+    stride     : step between patch centres
+    """
+    def __init__(self, h5_path, year_range=(2000, 2023),
+                 bbox=None, patch_size=256, stride=128):
+        self.f    = h5py.File(h5_path, "r")
+        self.pop  = self.f["population"]
+        years     = self.f["coords/years"][:]
+        lat       = self.f["coords/lat"][:]
+        lon       = self.f["coords/lon"][:]
+
+        # Time axis
+        t_mask    = np.where((years >= year_range[0]) & (years <= year_range[1]))[0]
+        self.t0, self.t1 = int(t_mask[0]), int(t_mask[-1]) + 1
+        self.T    = self.t1 - self.t0
+
+        # Spatial axis
+        if bbox:
+            lat_m = np.where((lat >= bbox[0]) & (lat <= bbox[1]))[0]
+            lon_m = np.where((lon >= bbox[2]) & (lon <= bbox[3]))[0]
+            self.r0, self.r1 = int(lat_m[0]),  int(lat_m[-1])  + 1
+            self.c0, self.c1 = int(lon_m[0]),  int(lon_m[-1])  + 1
+        else:
+            self.r0, self.r1 = 0, self.pop.shape[1]
+            self.c0, self.c1 = 0, self.pop.shape[2]
+
+        H, W = self.r1 - self.r0, self.c1 - self.c0
+        self.ps = patch_size
+
+        # All valid patch top-left corners
+        self.patches = [
+            (r, c)
+            for r in range(0, H - patch_size, stride)
+            for c in range(0, W - patch_size, stride)
+        ]
+
+    def __len__(self):
+        return len(self.patches) * self.T
+
+    def __getitem__(self, idx):
+        t_rel  = idx % self.T
+        p_idx  = idx // self.T
+        r, c   = self.patches[p_idx]
+
+        t  = self.t0 + t_rel
+        r_abs, c_abs = self.r0 + r, self.c0 + c
+
+        patch = self.pop[t, r_abs:r_abs+self.ps, c_abs:c_abs+self.ps]
+        patch = patch.astype(np.float32)
+
+        # Replace NaN with 0 for model input (or use a mask)
+        nan_mask = np.isnan(patch)
+        patch    = np.nan_to_num(patch, nan=0.0)
+
+        return {
+            "population" : torch.from_numpy(patch[None]),     # (1, ps, ps)
+            "nan_mask"   : torch.from_numpy(nan_mask[None]),  # (1, ps, ps)
+            "year"       : torch.tensor(self.t0 + t_rel + 2000 - self.t0),
+        }
+
+    def __del__(self):
+        self.f.close()
+
+
+# ── Example usage ─────────────────────────────────────────────────────────────
+from torch.utils.data import DataLoader
+
+ds = LandScanDataset(
+    h5_path    = "pop_2000-23.h5",
+    year_range = (2015, 2023),
+    bbox       = (5, 35, 65, 95),   # South Asia
+    patch_size = 256,
+    stride     = 128,
+)
+loader = DataLoader(ds, batch_size=8, shuffle=True, num_workers=4)
+
+for batch in loader:
+    x    = batch["population"]    # (8, 1, 256, 256)
+    mask = batch["nan_mask"]      # (8, 1, 256, 256)
+    yr   = batch["year"]
+    break
+```
+
+### 9. Normalize using pre-computed stats
+
+```python
+with h5py.File("pop_2000-23.h5", "r") as f:
+    means = f["stats/mean"][:]         # (24,) — per year
+    stds  = f["stats/std"][:]          # (24,)
+    years = f["coords/years"][:]
+
+# Normalize a patch for year 2018
+t = int(np.where(years == 2018)[0])
+pop_2018_patch = f["population"][t, 5000:5256, 8000:8256]
+normalized     = (pop_2018_patch - means[t]) / (stds[t] + 1e-8)
+```
+
+### 10. HPC / MPI parallel reads
+
+```python
+# h5py supports MPI-IO for multi-node HPC jobs
+# Launch with: mpirun -n 8 python script.py
+
+from mpi4py import MPI
+import h5py
+import numpy as np
+
+comm = MPI.COMM_WORLD
+rank = comm.Get_rank()
+size = comm.Get_size()
+
+with h5py.File("pop_2000-23.h5", "r", driver="mpio", comm=comm) as f:
+    T         = f["population"].shape[0]
+    my_years  = np.array_split(np.arange(T), size)[rank]
+
+    for t in my_years:
+        slab = f["population"][t, :, :]
+        # Each rank independently processes its years — no contention
+        result = slab[~np.isnan(slab)].sum()
+        print(f"  rank={rank}  t={t}  total={result/1e9:.3f}B")
+```
+
+---
+
+## 🗺️ Native Extent per Year
+
+Years 2001–2012 have fewer rows than the master grid because older LandScan releases used a slightly cropped polar extent. Pixels beyond the native extent are `NaN`.
+
+```python
+with h5py.File("pop_2000-23.h5", "r") as f:
+    ext_years = f["native_extent/years"][:]
+    n_rows    = f["native_extent/n_rows"][:]
+    n_cols    = f["native_extent/n_cols"][:]
+
+for yr, h, w in zip(ext_years, n_rows, n_cols):
+    flag = " ← cropped" if h < 21600 else ""
+    print(f"  {yr}: {h} × {w}{flag}")
+```
+
+Expected output:
+```
+  2000: 21600 × 43200
+  2001: 20880 × 43200  ← cropped
+  ...
+  2012: 20880 × 43200  ← cropped
+  2013: 21600 × 43200
+  ...
+  2023: 21600 × 43200
+```
+
+---
+
+## 🧮 Global Population Trend
+
+| Year | Global Population |
+|------|------------------|
+| 2000 | ~6.09 billion |
+| 2005 | ~6.45 billion |
+| 2010 | ~6.85 billion |
+| 2015 | ~7.28 billion |
+| 2020 | ~7.79 billion |
+| 2023 | ~8.1 billion |
+
+---
+
+## 📐 Coordinate Reference
+
+```
+Top-left pixel centre  :  89.9917°N,  179.9917°W
+Bottom-right pixel centre: 89.9917°S,  179.9917°E
+Pixel size             :  0.008333°  (~0.926 km at equator, ~1 km average)
+```
+
+```python
+# Convert lat/lon to row/col index
+def latlon_to_idx(lat_val, lon_val, lat_arr, lon_arr):
+    row = int(np.argmin(np.abs(lat_arr - lat_val)))
+    col = int(np.argmin(np.abs(lon_arr - lon_val)))
+    return row, col
+```
+
+---
+
+## ⚠️ Known Issues & Limitations
+
+- **2001–2012 polar crop**: 720 rows missing at the poles (≥ ~83.5°N / ≤ ~83.5°S). These are ocean/ice — NaN fill has no impact on population analysis.
+- **NaN ≠ zero population**: Do not fill NaN with 0 indiscriminately — ocean pixels and missing-extent pixels are both NaN but have different meanings. Use `/native_extent` to distinguish them if needed.
+- **Ambient vs residential**: LandScan is *ambient* population. It differs from census residential counts — commuters, transit zones, and commercial areas inflate daytime values.
+- **Population redistribution, not growth only**: Year-to-year changes reflect both demographic change and model improvements across LandScan releases.
+
+---
+
+## 📄 Citation
+
+If you use this dataset, please cite the original LandScan source:
+
+```bibtex
+@dataset{landscan_global,
+  author    = {Oak Ridge National Laboratory},
+  title     = {LandScan Global Population Database},
+  year      = {2023},
+  publisher = {Oak Ridge National Laboratory},
+  url       = {https://landscan.ornl.gov},
+  note      = {Annual releases 2000--2023}
+}
+```
+
+---
+
+## 🔗 Links
+
+- [LandScan Global — ORNL](https://landscan.ornl.gov)
+- [LandScan Methodology](https://landscan.ornl.gov/landscan-datasets)
+- [HDF5 Chunking Guide](https://docs.h5py.org/en/stable/high/dataset.html#chunked-storage)
+- [h5py ROS3 (remote streaming)](https://docs.h5py.org/en/stable/high/file.html#ros3)
+
+---
+
+## 📜 License
+
+The original LandScan Global data is made available under the [Creative Commons Attribution 4.0 International License (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/).
+Attribution: *UT-Battelle, LLC, Oak Ridge National Laboratory*.
+This HDF5 repackaging does not alter the underlying data.