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)