Datasets:

nikhilr01
/

sen-bridge

# Copyright 2026 Nikhil Raghavendra
# SPDX-License-Identifier: Apache-2.0
"""Reference evaluation for SEN-Bridge.
Usage::
    python scripts/evaluate.py SAMPLES.npy --data DATASET_DIR_OR_REPO
        [--split test] [--fid-stats stats/fid_test.npz] [--framework torch|jax]
        [--bootstrap 1000] [--out results.json]
``SAMPLES.npy`` holds one generated optical image per example of the split, in
dataset order: uint8 ``[N, 128, 128, 3]`` or float in [-1, 1]. The script reports
FID (against the statistics file, or against the split's targets if none is given)
and per-image PSNR, SSIM and LPIPS as mean and std, with 95% bootstrap intervals
resampled by geographic cluster. Never use the test split to choose models.
"""

from __future__ import annotations

import argparse
import json
from pathlib import Path
from typing import TYPE_CHECKING, Any, Protocol

import numpy as np
from datasets import load_dataset

if TYPE_CHECKING:
    from numpy.typing import NDArray

_HALF_RANGE = 127.5
_METRICS = ("psnr", "ssim", "lpips")
_CI = (2.5, 97.5)


class Backend(Protocol):
    """A metrics backend (PyTorch or JAX) behind a common interface."""

    def paired(
        self, gen: NDArray[Any], tgt: NDArray[Any]
    ) -> tuple[NDArray[Any], NDArray[Any], NDArray[Any]]:
        """Score generated images against targets.
        Args:
            gen: Generated images, uint8 or float in [-1, 1], ``[B, H, W, 3]``.
            tgt: Target images, same shape.
        Returns:
            PSNR, SSIM and LPIPS for each image.
        """
        ...

    def feed(self, images: NDArray[Any], *, real: bool) -> None:
        """Add images to the FID accumulator.
        Args:
            images: Images, uint8 or float in [-1, 1], ``[B, H, W, 3]``.
            real: Whether they are real targets.
        """
        ...

    def fid(self) -> float:
        """Compute the FID.
        Returns:
            The Frechet Inception Distance.
        """
        ...


def to_float(x: NDArray[Any]) -> NDArray[np.float32]:
    """Map images to float32 in [-1, 1].
    Args:
        x: uint8 images, or floats that are already in [-1, 1].
    Returns:
        Float32 images in [-1, 1].
    """
    if x.dtype == np.uint8:
        return x.astype(np.float32) / _HALF_RANGE - 1
    return x.astype(np.float32)


class TorchBackend:
    """Metrics from ``sen_bridge.torch``."""

    def __init__(self, stats: Path | None) -> None:
        """Create the backend.
        Args:
            stats: Real-target statistics file, or ``None`` to featurise the
                targets.
        """
        # torch is an optional dependency, imported only when selected.
        import torch  # ruff: ignore[import-outside-top-level]

        # Same optional dependency as the import above.
        from sen_bridge import torch as sb  # ruff: ignore[import-outside-top-level]

        self._torch, self._sb = torch, sb
        self._fid = sb.FID.from_stats(stats) if stats else sb.FID()

    # Returns a framework tensor, which has no common static type.
    def _prep(self, x: NDArray[Any]) -> Any:  # ruff: ignore[any-type]
        batch = self._torch.from_numpy(to_float(x)).permute(0, 3, 1, 2)
        return batch.to(
            self._fid.device
        )  # LPIPS-VGG on 30k pairs is far too slow on CPU

    def paired(
        self, gen: NDArray[Any], tgt: NDArray[Any]
    ) -> tuple[NDArray[Any], NDArray[Any], NDArray[Any]]:
        """Score generated images against targets.
        Args:
            gen: Generated images, ``[B, H, W, 3]``.
            tgt: Target images, same shape.
        Returns:
            PSNR, SSIM and LPIPS for each image.
        """
        a, b = self._prep(gen), self._prep(tgt)
        return (
            self._sb.psnr(a, b).cpu().numpy(),
            self._sb.ssim(a, b).cpu().numpy(),
            self._sb.lpips(a, b).cpu().numpy(),
        )

    def feed(self, images: NDArray[Any], *, real: bool) -> None:
        """Add images to the FID accumulator.
        Args:
            images: Images, ``[B, H, W, 3]``.
            real: Whether they are real targets.
        """
        self._fid.update(self._prep(images), real=real)

    def fid(self) -> float:
        """Compute the FID.
        Returns:
            The Frechet Inception Distance.
        """
        return self._fid.compute()


class JaxBackend:
    """Metrics from ``sen_bridge.jax``."""

    def __init__(self, stats: Path | None) -> None:
        """Create the backend.
        Args:
            stats: Real-target statistics file, or ``None`` to featurise the
                targets.
        """
        # jax is an optional dependency, imported only when selected.
        import jax  # ruff: ignore[import-outside-top-level]

        # Same optional dependency as the import above.
        import jax.numpy as jnp  # ruff: ignore[import-outside-top-level]

        # Same optional dependency as the import above.
        from sen_bridge import jax as sb  # ruff: ignore[import-outside-top-level]

        self._jnp = jnp
        self._fns = [jax.jit(jax.vmap(f)) for f in (sb.psnr, sb.ssim, sb.lpips)]
        self._fid = sb.FID.from_stats(stats) if stats else sb.FID()

    def paired(
        self, gen: NDArray[Any], tgt: NDArray[Any]
    ) -> tuple[NDArray[Any], NDArray[Any], NDArray[Any]]:
        """Score generated images against targets.
        Args:
            gen: Generated images, ``[B, H, W, 3]``.
            tgt: Target images, same shape.
        Returns:
            PSNR, SSIM and LPIPS for each image.
        """
        a, b = self._jnp.asarray(to_float(gen)), self._jnp.asarray(to_float(tgt))
        psnr, ssim, lpips = (np.asarray(f(a, b)) for f in self._fns)
        return psnr, ssim, lpips

    def feed(self, images: NDArray[Any], *, real: bool) -> None:
        """Add images to the FID accumulator.
        Args:
            images: Images, ``[B, H, W, 3]``.
            real: Whether they are real targets.
        """
        self._fid.update(self._jnp.asarray(to_float(images)), real=real)

    def fid(self) -> float:
        """Compute the FID.
        Returns:
            The Frechet Inception Distance.
        """
        return self._fid.compute()


def cluster_bootstrap(
    values: dict[str, NDArray[Any]],
    clusters: NDArray[Any],
    n: int,
) -> dict[str, tuple[float, float]]:
    """Bootstrap 95% intervals of per-image means, resampling whole clusters.
    Args:
        values: Per-image scores by metric name.
        clusters: Cluster id of each image.
        n: Number of bootstrap resamples.
    Returns:
        The lower and upper bound for each metric.
    """
    unique = np.unique(clusters)
    members = {c: np.flatnonzero(clusters == c) for c in unique}
    rng = np.random.default_rng(0)
    draws = []
    for _ in range(n):
        picked = np.concatenate([
            members[c] for c in rng.choice(unique, len(unique))
        ])
        draws.append([v[picked].mean() for v in values.values()])
    low, high = np.percentile(draws, _CI, axis=0)
    return {
        k: (float(a), float(b)) for k, a, b in zip(values, low, high, strict=True)
    }


def main() -> None:
    """Evaluate a set of generated samples and print the metrics as JSON.
    Raises:
        SystemExit: If the number of samples differs from the split size.
    """
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("samples", type=Path)
    parser.add_argument("--data", required=True)
    parser.add_argument("--split", default="test")
    parser.add_argument("--fid-stats", type=Path)
    parser.add_argument("--framework", choices=["torch", "jax"], default="torch")
    parser.add_argument("--bootstrap", type=int, default=1000)
    parser.add_argument("--batch", type=int, default=100)
    parser.add_argument("--out", type=Path)
    args = parser.parse_args()

    ds = load_dataset(args.data, split=args.split)
    generated = np.load(args.samples)
    if len(generated) != len(ds):
        msg = f"{len(generated)} samples for {len(ds)} examples"
        raise SystemExit(msg)
    backend: Backend = (
        TorchBackend(args.fid_stats)
        if args.framework == "torch"
        else JaxBackend(args.fid_stats)
    )

    scores: dict[str, list[NDArray[Any]]] = {m: [] for m in _METRICS}
    for start in range(0, len(ds), args.batch):
        stop = min(start + args.batch, len(ds))
        targets = np.stack([
            np.asarray(r["optical"]) for r in ds.select(range(start, stop))
        ])
        gen = generated[start:stop]
        for name, value in zip(_METRICS, backend.paired(gen, targets), strict=True):
            scores[name].append(value)
        backend.feed(gen, real=False)
        if args.fid_stats is None:
            backend.feed(targets, real=True)
    per_image = {k: np.concatenate(v) for k, v in scores.items()}

    intervals = cluster_bootstrap(
        per_image, np.asarray(ds["cluster_id"]), args.bootstrap
    )
    result: dict[str, Any] = {"n": len(ds), "fid": backend.fid()}
    for name, values in per_image.items():
        result[name] = {
            "mean": float(values.mean()),
            "std": float(values.std()),
            "ci95_cluster_bootstrap": list(intervals[name]),
        }
    print(json.dumps(result, indent=2))
    if args.out:
        args.out.write_text(json.dumps(result, indent=2), encoding="utf-8")


if __name__ == "__main__":
    main()

	# Copyright 2026 Nikhil Raghavendra
	# SPDX-License-Identifier: Apache-2.0
	"""Reference evaluation for SEN-Bridge.

	Usage::

	python scripts/evaluate.py SAMPLES.npy --data DATASET_DIR_OR_REPO
	[--split test] [--fid-stats stats/fid_test.npz] [--framework torch\|jax]
	[--bootstrap 1000] [--out results.json]

	``SAMPLES.npy`` holds one generated optical image per example of the split, in
	dataset order: uint8 ``[N, 128, 128, 3]`` or float in [-1, 1]. The script reports
	FID (against the statistics file, or against the split's targets if none is given)
	and per-image PSNR, SSIM and LPIPS as mean and std, with 95% bootstrap intervals
	resampled by geographic cluster. Never use the test split to choose models.
	"""

	from __future__ import annotations

	import argparse
	import json
	from pathlib import Path
	from typing import TYPE_CHECKING, Any, Protocol

	import numpy as np
	from datasets import load_dataset

	if TYPE_CHECKING:
	from numpy.typing import NDArray

	_HALF_RANGE = 127.5
	_METRICS = ("psnr", "ssim", "lpips")
	_CI = (2.5, 97.5)


	class Backend(Protocol):
	"""A metrics backend (PyTorch or JAX) behind a common interface."""

	def paired(
	self, gen: NDArray[Any], tgt: NDArray[Any]
	) -> tuple[NDArray[Any], NDArray[Any], NDArray[Any]]:
	"""Score generated images against targets.

	Args:
	gen: Generated images, uint8 or float in [-1, 1], ``[B, H, W, 3]``.
	tgt: Target images, same shape.

	Returns:
	PSNR, SSIM and LPIPS for each image.
	"""
	...

	def feed(self, images: NDArray[Any], *, real: bool) -> None:
	"""Add images to the FID accumulator.

	Args:
	images: Images, uint8 or float in [-1, 1], ``[B, H, W, 3]``.
	real: Whether they are real targets.
	"""
	...

	def fid(self) -> float:
	"""Compute the FID.

	Returns:
	The Frechet Inception Distance.
	"""
	...


	def to_float(x: NDArray[Any]) -> NDArray[np.float32]:
	"""Map images to float32 in [-1, 1].

	Args:
	x: uint8 images, or floats that are already in [-1, 1].

	Returns:
	Float32 images in [-1, 1].
	"""
	if x.dtype == np.uint8:
	return x.astype(np.float32) / _HALF_RANGE - 1
	return x.astype(np.float32)


	class TorchBackend:
	"""Metrics from ``sen_bridge.torch``."""

	def __init__(self, stats: Path \| None) -> None:
	"""Create the backend.

	Args:
	stats: Real-target statistics file, or ``None`` to featurise the
	targets.
	"""
	# torch is an optional dependency, imported only when selected.
	import torch # ruff: ignore[import-outside-top-level]

	# Same optional dependency as the import above.
	from sen_bridge import torch as sb # ruff: ignore[import-outside-top-level]

	self._torch, self._sb = torch, sb
	self._fid = sb.FID.from_stats(stats) if stats else sb.FID()

	# Returns a framework tensor, which has no common static type.
	def _prep(self, x: NDArray[Any]) -> Any: # ruff: ignore[any-type]
	batch = self._torch.from_numpy(to_float(x)).permute(0, 3, 1, 2)
	return batch.to(
	self._fid.device
	) # LPIPS-VGG on 30k pairs is far too slow on CPU

	def paired(
	self, gen: NDArray[Any], tgt: NDArray[Any]
	) -> tuple[NDArray[Any], NDArray[Any], NDArray[Any]]:
	"""Score generated images against targets.

	Args:
	gen: Generated images, ``[B, H, W, 3]``.
	tgt: Target images, same shape.

	Returns:
	PSNR, SSIM and LPIPS for each image.
	"""
	a, b = self._prep(gen), self._prep(tgt)
	return (
	self._sb.psnr(a, b).cpu().numpy(),
	self._sb.ssim(a, b).cpu().numpy(),
	self._sb.lpips(a, b).cpu().numpy(),
	)

	def feed(self, images: NDArray[Any], *, real: bool) -> None:
	"""Add images to the FID accumulator.

	Args:
	images: Images, ``[B, H, W, 3]``.
	real: Whether they are real targets.
	"""
	self._fid.update(self._prep(images), real=real)

	def fid(self) -> float:
	"""Compute the FID.

	Returns:
	The Frechet Inception Distance.
	"""
	return self._fid.compute()


	class JaxBackend:
	"""Metrics from ``sen_bridge.jax``."""

	def __init__(self, stats: Path \| None) -> None:
	"""Create the backend.

	Args:
	stats: Real-target statistics file, or ``None`` to featurise the
	targets.
	"""
	# jax is an optional dependency, imported only when selected.
	import jax # ruff: ignore[import-outside-top-level]

	# Same optional dependency as the import above.
	import jax.numpy as jnp # ruff: ignore[import-outside-top-level]

	# Same optional dependency as the import above.
	from sen_bridge import jax as sb # ruff: ignore[import-outside-top-level]

	self._jnp = jnp
	self._fns = [jax.jit(jax.vmap(f)) for f in (sb.psnr, sb.ssim, sb.lpips)]
	self._fid = sb.FID.from_stats(stats) if stats else sb.FID()

	def paired(
	self, gen: NDArray[Any], tgt: NDArray[Any]
	) -> tuple[NDArray[Any], NDArray[Any], NDArray[Any]]:
	"""Score generated images against targets.

	Args:
	gen: Generated images, ``[B, H, W, 3]``.
	tgt: Target images, same shape.

	Returns:
	PSNR, SSIM and LPIPS for each image.
	"""
	a, b = self._jnp.asarray(to_float(gen)), self._jnp.asarray(to_float(tgt))
	psnr, ssim, lpips = (np.asarray(f(a, b)) for f in self._fns)
	return psnr, ssim, lpips

	def feed(self, images: NDArray[Any], *, real: bool) -> None:
	"""Add images to the FID accumulator.

	Args:
	images: Images, ``[B, H, W, 3]``.
	real: Whether they are real targets.
	"""
	self._fid.update(self._jnp.asarray(to_float(images)), real=real)

	def fid(self) -> float:
	"""Compute the FID.

	Returns:
	The Frechet Inception Distance.
	"""
	return self._fid.compute()


	def cluster_bootstrap(
	values: dict[str, NDArray[Any]],
	clusters: NDArray[Any],
	n: int,
	) -> dict[str, tuple[float, float]]:
	"""Bootstrap 95% intervals of per-image means, resampling whole clusters.

	Args:
	values: Per-image scores by metric name.
	clusters: Cluster id of each image.
	n: Number of bootstrap resamples.

	Returns:
	The lower and upper bound for each metric.
	"""
	unique = np.unique(clusters)
	members = {c: np.flatnonzero(clusters == c) for c in unique}
	rng = np.random.default_rng(0)
	draws = []
	for _ in range(n):
	picked = np.concatenate([
	members[c] for c in rng.choice(unique, len(unique))
	])
	draws.append([v[picked].mean() for v in values.values()])
	low, high = np.percentile(draws, _CI, axis=0)
	return {
	k: (float(a), float(b)) for k, a, b in zip(values, low, high, strict=True)
	}


	def main() -> None:
	"""Evaluate a set of generated samples and print the metrics as JSON.

	Raises:
	SystemExit: If the number of samples differs from the split size.
	"""
	parser = argparse.ArgumentParser(description=__doc__)
	parser.add_argument("samples", type=Path)
	parser.add_argument("--data", required=True)
	parser.add_argument("--split", default="test")
	parser.add_argument("--fid-stats", type=Path)
	parser.add_argument("--framework", choices=["torch", "jax"], default="torch")
	parser.add_argument("--bootstrap", type=int, default=1000)
	parser.add_argument("--batch", type=int, default=100)
	parser.add_argument("--out", type=Path)
	args = parser.parse_args()

	ds = load_dataset(args.data, split=args.split)
	generated = np.load(args.samples)
	if len(generated) != len(ds):
	msg = f"{len(generated)} samples for {len(ds)} examples"
	raise SystemExit(msg)
	backend: Backend = (
	TorchBackend(args.fid_stats)
	if args.framework == "torch"
	else JaxBackend(args.fid_stats)
	)

	scores: dict[str, list[NDArray[Any]]] = {m: [] for m in _METRICS}
	for start in range(0, len(ds), args.batch):
	stop = min(start + args.batch, len(ds))
	targets = np.stack([
	np.asarray(r["optical"]) for r in ds.select(range(start, stop))
	])
	gen = generated[start:stop]
	for name, value in zip(_METRICS, backend.paired(gen, targets), strict=True):
	scores[name].append(value)
	backend.feed(gen, real=False)
	if args.fid_stats is None:
	backend.feed(targets, real=True)
	per_image = {k: np.concatenate(v) for k, v in scores.items()}

	intervals = cluster_bootstrap(
	per_image, np.asarray(ds["cluster_id"]), args.bootstrap
	)
	result: dict[str, Any] = {"n": len(ds), "fid": backend.fid()}
	for name, values in per_image.items():
	result[name] = {
	"mean": float(values.mean()),
	"std": float(values.std()),
	"ci95_cluster_bootstrap": list(intervals[name]),
	}
	print(json.dumps(result, indent=2))
	if args.out:
	args.out.write_text(json.dumps(result, indent=2), encoding="utf-8")


	if __name__ == "__main__":
	main()