File size: 4,354 Bytes
10979b5 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 | from __future__ import annotations
import numpy as np
import pytest
import torch
from gmnet.spectral.metrics import measure_spectrum
from gmnet.spectral.streaming import RadialPSDAccumulator, torch_fft_lowpass
from gmnet.spectral.transforms import (
dct_coefficients,
dct_reconstruct,
fft_coefficients,
fft_reconstruct,
hard_band_reconstruction,
haar_decompose2d,
haar_reconstruct2d,
relative_l2_error,
)
@pytest.mark.parametrize("shape", [(2, 3, 32, 32), (1, 1, 16, 24)])
def test_transforms_are_numerically_invertible(shape: tuple[int, ...]) -> None:
x = np.random.default_rng(7).standard_normal(shape)
fft_result = fft_reconstruct(fft_coefficients(x))
dct_result = dct_reconstruct(dct_coefficients(x))
haar_result = haar_reconstruct2d(haar_decompose2d(x, levels=3))
assert relative_l2_error(x, fft_result) < 1e-12
assert relative_l2_error(x, dct_result) < 1e-12
assert relative_l2_error(x, haar_result) < 1e-12
assert relative_l2_error(
x, hard_band_reconstruction(x, "fft", (0.0, 0.25, 0.5, 1.0))
) < 1e-12
assert relative_l2_error(
x, hard_band_reconstruction(x, "dct", (0.0, 0.25, 0.5, 1.0))
) < 1e-12
def test_parseval_energy_is_preserved() -> None:
x = np.random.default_rng(11).standard_normal((2, 2, 32, 32))
reference = float(np.square(x).sum())
assert np.isclose(np.square(np.abs(fft_coefficients(x))).sum(), reference)
assert np.isclose(np.square(dct_coefficients(x)).sum(), reference)
wavelet = haar_decompose2d(x, levels=3)
wavelet_energy = np.square(wavelet.approximation).sum() + sum(
np.square(detail).sum() for level in wavelet.details for detail in level
)
assert np.isclose(wavelet_energy, reference)
def test_high_frequency_tone_scores_above_low_frequency_tone() -> None:
grid = np.arange(64)
low = np.sin(2 * np.pi * 2 * grid / 64)[None, None, None, :]
high = np.sin(2 * np.pi * 24 * grid / 64)[None, None, None, :]
low = np.broadcast_to(low, (1, 1, 64, 64))
high = np.broadcast_to(high, (1, 1, 64, 64))
for method in ("fft", "dct", "haar"):
assert measure_spectrum(high, method).frequency_auc > measure_spectrum(
low, method
).frequency_auc
def test_invalid_haar_shape_is_rejected() -> None:
with pytest.raises(ValueError, match="divisible"):
haar_decompose2d(np.ones((10, 10)), levels=2)
def test_streaming_psd_orders_low_and_high_tones() -> None:
grid = torch.arange(32, dtype=torch.float32)
low = torch.sin(2 * torch.pi * 2 * grid / 32)[None, None, None, :]
high = torch.sin(2 * torch.pi * 12 * grid / 32)[None, None, None, :]
low = low.expand(2, 3, 32, 32)
high = high.expand(2, 3, 32, 32)
low_accumulator = RadialPSDAccumulator()
high_accumulator = RadialPSDAccumulator()
low_accumulator.update(low[:1])
low_accumulator.update(low[1:])
high_accumulator.update(high)
low_result = low_accumulator.compute()
high_result = high_accumulator.compute()
assert low_result.valid and high_result.valid
assert high_result.spectral_centroid > low_result.spectral_centroid
assert high_result.high_low_ratio > low_result.high_low_ratio
def test_streaming_psd_marks_one_by_one_features_invalid() -> None:
accumulator = RadialPSDAccumulator()
accumulator.update(torch.randn(2, 4, 1, 1))
result = accumulator.compute()
assert not result.valid
assert result.spectral_centroid is None
def test_streaming_psd_rejects_constant_roundoff_and_degenerate_split() -> None:
constant = RadialPSDAccumulator()
constant.update(torch.ones(2, 3, 32, 32) * 0.3)
assert not constant.compute().valid
tiny_grid = RadialPSDAccumulator()
tiny_grid.update(torch.randn(2, 3, 2, 2))
result = tiny_grid.compute()
assert result.valid
assert not result.high_low_valid
assert result.high_low_ratio is None
def test_torch_lowpass_endpoints_and_attenuation() -> None:
images = torch.randn(2, 3, 32, 32)
dc = torch_fft_lowpass(images, 0.0)
identity = torch_fft_lowpass(images, 1.0)
filtered = torch_fft_lowpass(images, 0.25)
assert torch.allclose(dc, images.mean(dim=(-2, -1), keepdim=True).expand_as(images))
assert identity.data_ptr() == images.data_ptr()
assert filtered.square().mean() < images.square().mean()
|