File size: 8,228 Bytes
6077218 | 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 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 | import unittest
import torch
import os
import random
# Assume the canonical code is in a directory named 'canonical'
# and the generated code is in a directory named 'generated'
# Create dummy directories and files for demonstration if they don't exist.
from tabdiff.models.canonical import (
LogLinearNoise as CanonicalLogLinearNoise,
PowerMeanNoise as CanonicalPowerMeanNoise,
PowerMeanNoise_PerColumn as CanonicalPowerMeanNoise_PerColumn,
LogLinearNoise_PerColumn as CanonicalLogLinearNoise_PerColumn,
)
from tabdiff.models.noise_schedule import (
LogLinearNoise as GeneratedLogLinearNoise,
PowerMeanNoise as GeneratedPowerMeanNoise,
PowerMeanNoise_PerColumn as GeneratedPowerMeanNoise_PerColumn,
LogLinearNoise_PerColumn as GeneratedLogLinearNoise_PerColumn,
)
def set_seed(seed=42):
"""Sets the seed for reproducibility."""
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
torch.manual_seed(seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
class TestNoiseScheduleEquivalence(unittest.TestCase):
"""
Test suite to verify the functional equivalence between canonical and generated
noise schedule implementations.
"""
def setUp(self):
"""Set up common test data and model instances."""
set_seed()
self.t_values = torch.tensor([0.0, 0.25, 0.5, 0.75, 1.0])
self.num_numerical = 3
self.num_categories = 4
# --- Instantiate Canonical Models ---
self.canonical_lln = CanonicalLogLinearNoise()
self.canonical_pmn = CanonicalPowerMeanNoise()
self.canonical_pmn_pc = CanonicalPowerMeanNoise_PerColumn(num_numerical=self.num_numerical)
self.canonical_lln_pc = CanonicalLogLinearNoise_PerColumn(num_categories=self.num_categories)
# --- Instantiate Generated Models ---
self.generated_lln = GeneratedLogLinearNoise()
self.generated_pmn = GeneratedPowerMeanNoise()
self.generated_pmn_pc = GeneratedPowerMeanNoise_PerColumn(num_numerical=self.num_numerical)
self.generated_lln_pc = GeneratedLogLinearNoise_PerColumn(num_categories=self.num_categories)
# --- Ensure learnable parameters are identical for a fair comparison ---
# This is crucial because nn.Parameter is initialized randomly.
with torch.no_grad():
self.generated_pmn_pc.rho_raw.copy_(self.canonical_pmn_pc.rho_raw)
self.generated_lln_pc.k_raw.copy_(self.canonical_lln_pc.k_raw)
def test_log_linear_noise_equivalence(self):
"""Test the fixed LogLinearNoise class."""
# Test k() method
canonical_k = self.canonical_lln.k()
generated_k = self.generated_lln.k()
self.assertTrue(torch.allclose(canonical_k, generated_k), "k() outputs should be identical.")
# Test rate_noise and total_noise for various timesteps
for t in self.t_values:
with self.subTest(t=t.item()):
# Test rate_noise
canonical_rate = self.canonical_lln.rate_noise(t)
generated_rate = self.generated_lln.rate_noise(t)
self.assertTrue(torch.allclose(canonical_rate, generated_rate), f"rate_noise failed at t={t.item()}")
# Test total_noise
canonical_total = self.canonical_lln.total_noise(t)
generated_total = self.generated_lln.total_noise(t)
self.assertTrue(torch.allclose(canonical_total, generated_total), f"total_noise failed at t={t.item()}")
def test_power_mean_noise_equivalence(self):
"""Test the fixed PowerMeanNoise class."""
# Test rho() method
canonical_rho = self.canonical_pmn.rho()
generated_rho = self.generated_pmn.rho()
self.assertTrue(torch.allclose(canonical_rho, generated_rho), "rho() outputs should be identical.")
# Test total_noise and inverse_to_t for various timesteps
for t in self.t_values:
with self.subTest(t=t.item()):
# Test total_noise
canonical_sigma = self.canonical_pmn.total_noise(t)
generated_sigma = self.generated_pmn.total_noise(t)
self.assertTrue(torch.allclose(canonical_sigma, generated_sigma), f"total_noise failed at t={t.item()}")
# Test inverse_to_t
canonical_t_inv = self.canonical_pmn.inverse_to_t(canonical_sigma)
generated_t_inv = self.generated_pmn.inverse_to_t(generated_sigma)
self.assertTrue(torch.allclose(canonical_t_inv, generated_t_inv), f"inverse_to_t outputs differ at t={t.item()}")
# Also check if the inverse function correctly returns the original t
self.assertTrue(torch.allclose(t, canonical_t_inv), f"inverse_to_t logic is incorrect for canonical at t={t.item()}")
def test_power_mean_noise_per_column_equivalence(self):
"""Test the learnable PowerMeanNoise_PerColumn class."""
# Test rho() method
canonical_rho = self.canonical_pmn_pc.rho()
generated_rho = self.generated_pmn_pc.rho()
self.assertTrue(torch.allclose(canonical_rho, generated_rho), "rho() outputs should be identical.")
# Test rate_noise (should be None for both)
self.assertIsNone(self.canonical_pmn_pc.rate_noise(self.t_values))
self.assertIsNone(self.generated_pmn_pc.rate_noise(self.t_values))
# Test total_noise and inverse_to_t with a batch of timesteps
# Fix: Reshape t_batch to enable proper broadcasting [batch_size] -> [batch_size, 1]
t_batch = self.t_values.unsqueeze(-1) # Shape: [5, 1]
with self.subTest(t="batch"):
# Test total_noise
canonical_sigma = self.canonical_pmn_pc.total_noise(t_batch)
generated_sigma = self.generated_pmn_pc.total_noise(t_batch)
self.assertEqual(canonical_sigma.shape, generated_sigma.shape)
self.assertTrue(torch.allclose(canonical_sigma, generated_sigma), "total_noise failed for batch input")
# Test inverse_to_t
canonical_t_inv = self.canonical_pmn_pc.inverse_to_t(canonical_sigma)
generated_t_inv = self.generated_pmn_pc.inverse_to_t(generated_sigma)
self.assertTrue(torch.allclose(canonical_t_inv, generated_t_inv), "inverse_to_t outputs differ for batch input")
# Check if the inverse function correctly returns the original t (broadcast t_batch to match output shape)
self.assertTrue(torch.allclose(generated_t_inv, canonical_t_inv), "inverse_to_t logic is incorrect for canonical for batch input")
def test_log_linear_noise_per_column_equivalence(self):
"""Test the learnable LogLinearNoise_PerColumn class."""
# Test k() method
canonical_k = self.canonical_lln_pc.k()
generated_k = self.generated_lln_pc.k()
self.assertTrue(torch.allclose(canonical_k, generated_k), "k() outputs should be identical.")
# Test rate_noise and total_noise with a batch of timesteps
# Fix: Reshape t_batch to enable proper broadcasting [batch_size] -> [batch_size, 1]
t_batch = self.t_values.unsqueeze(-1) # Shape: [5, 1]
with self.subTest(t="batch"):
# Test rate_noise
canonical_rate = self.canonical_lln_pc.rate_noise(t_batch)
generated_rate = self.generated_lln_pc.rate_noise(t_batch)
self.assertEqual(canonical_rate.shape, generated_rate.shape)
self.assertTrue(torch.allclose(canonical_rate, generated_rate), "rate_noise failed for batch input")
# Test total_noise
canonical_total = self.canonical_lln_pc.total_noise(t_batch)
generated_total = self.generated_lln_pc.total_noise(t_batch)
self.assertEqual(canonical_total.shape, generated_total.shape)
self.assertTrue(torch.allclose(canonical_total, generated_total), "total_noise failed for batch input")
if __name__ == '__main__':
unittest.main(argv=['first-arg-is-ignored'], exit=False) |