mcy98's picture
Upload folder using huggingface_hub
2d13eb2 verified
Raw History Blame Contribute Delete
13.8 kB
import unittest
import inspect
from unittest.mock import patch
import jax
import jax.numpy as jnp
import jax.random as jrandom
import jax.tree_util as jtu
import numpy as np
# Import algorithm helpers to patch gen_basis and for LeafTuple typing
import algorithm
# Canonical impls
from canonical import nf_relu as canonical_nf_relu
from canonical import UNFSequential as CanonicalUNFSequential
from canonical import UNFLayer as CanonicalUNFLayer
from canonical import BatchUNFLayer as CanonicalBatchUNFLayer
# Generated impls
from layers import nf_relu as generated_nf_relu
from layers import UNFSequential as GeneratedUNFSequential
from layers import UNFLayer as GeneratedUNFLayer
from layers import BatchUNFLayer as GeneratedBatchUNFLayer
# --------------------------
# Helpers
# --------------------------
def _same_structure_and_shapes(a, b):
"""Assert two pytrees share identical structure and leaf shapes."""
assert jtu.tree_structure(a) == jtu.tree_structure(b), "Tree structures differ"
for x, y in zip(jtu.tree_leaves(a), jtu.tree_leaves(b)):
assert hasattr(x, "shape") and hasattr(y, "shape")
assert x.shape == y.shape, f"Leaf shape mismatch: {x.shape} != {y.shape}"
def _copy_params(src_vars, dst_vars):
"""Copy params from src flax variables to dst (matching tree structure)."""
return jax.tree.map(lambda s, _: s, src_vars, dst_vars)
# Deterministic mock for algorithm.gen_basis that works with both modules.
# Signature expected by canonical code (and generated code) is:
# gen_basis(out_spec, in_spec, out_shape, in_param_slice)
# We vmapped over the last axis of input param (c_in), out_axes=-1.
# This returns a tensor with shape `out_shape[:-1]` per input channel,
# which vmap stacks into `out_shape[:-1] + (c_in,)`, enabling `@` with
# a (c_in, c_out) theta.
def _mock_gen_basis(out_spec, in_spec, out_shape, in_slice):
# Use the mean of the input slice so the result isn't trivial
# Shape: out_shape[:-1]
scale = jnp.asarray(jnp.mean(in_slice))
return jnp.ones(out_shape[:-1]) * scale
# --------------------------
# Tests
# --------------------------
class TestNFReLUEquivalence(unittest.TestCase):
"""Existing nf_relu tests + a few extras."""
def setUp(self):
self.key = jrandom.PRNGKey(42)
self.c_in = 4
self.params = {
'weight1': jrandom.normal(self.key, (3, 4, self.c_in)),
'weight2': jrandom.normal(jrandom.fold_in(self.key, 1), (5, 2, self.c_in))
}
def test_nf_relu_output_structure(self):
canonical_output = canonical_nf_relu(self.params)
generated_output = generated_nf_relu(self.params)
self.assertEqual(
jtu.tree_structure(canonical_output),
jtu.tree_structure(generated_output),
)
self.assertEqual(
jtu.tree_structure(self.params),
jtu.tree_structure(canonical_output),
)
def test_nf_relu_shape_preservation(self):
canonical_output = canonical_nf_relu(self.params)
generated_output = generated_nf_relu(self.params)
for c_leaf, g_leaf, in_leaf in zip(
jtu.tree_leaves(canonical_output),
jtu.tree_leaves(generated_output),
jtu.tree_leaves(self.params),
):
self.assertEqual(c_leaf.shape, g_leaf.shape)
self.assertEqual(c_leaf.shape, in_leaf.shape)
def test_nf_relu_numerical_equivalence(self):
canonical_output = canonical_nf_relu(self.params)
generated_output = generated_nf_relu(self.params)
for c_leaf, g_leaf in zip(jtu.tree_leaves(canonical_output),
jtu.tree_leaves(generated_output)):
np.testing.assert_allclose(c_leaf, g_leaf, rtol=1e-5, atol=1e-8)
def test_nf_relu_negative_values(self):
negative_params = jtu.tree_map(lambda x: x - 0.5, self.params)
canonical_output = canonical_nf_relu(negative_params)
generated_output = generated_nf_relu(negative_params)
for c_leaf, g_leaf in zip(jtu.tree_leaves(canonical_output),
jtu.tree_leaves(generated_output)):
np.testing.assert_allclose(c_leaf, g_leaf, rtol=1e-5, atol=1e-8)
for leaf in jtu.tree_leaves(canonical_output):
self.assertTrue((leaf >= 0).all())
for leaf in jtu.tree_leaves(generated_output):
self.assertTrue((leaf >= 0).all())
def test_nf_relu_mixed_values(self):
mixed_params = jtu.tree_map(
lambda x: x * jrandom.normal(jrandom.fold_in(self.key, 10), x.shape),
self.params
)
canonical_output = canonical_nf_relu(mixed_params)
generated_output = generated_nf_relu(mixed_params)
for c_leaf, g_leaf in zip(jtu.tree_leaves(canonical_output),
jtu.tree_leaves(generated_output)):
np.testing.assert_allclose(c_leaf, g_leaf, rtol=1e-5, atol=1e-8)
for leaf in jtu.tree_leaves(canonical_output):
self.assertTrue((leaf >= 0).all())
found_zeros = False
for in_leaf, out_leaf in zip(jtu.tree_leaves(mixed_params),
jtu.tree_leaves(canonical_output)):
if ((in_leaf < 0) & (out_leaf == 0)).any():
found_zeros = True
break
self.assertTrue(found_zeros, "ReLU did not zero any negatives")
def test_nf_relu_dtype_preservation(self):
fp16_params = jtu.tree_map(lambda x: jnp.asarray(x, jnp.float16), self.params)
c_out = canonical_nf_relu(fp16_params)
g_out = generated_nf_relu(fp16_params)
for c_leaf, g_leaf in zip(jtu.tree_leaves(c_out), jtu.tree_leaves(g_out)):
self.assertEqual(c_leaf.dtype, jnp.float16)
self.assertEqual(g_leaf.dtype, jnp.float16)
class TestStructureCornerCases(unittest.TestCase):
def setUp(self):
self.key = jrandom.PRNGKey(0)
self.c_in = 3
def test_empty_structure(self):
empty = {}
self.assertEqual(canonical_nf_relu(empty), generated_nf_relu(empty))
self.assertEqual(empty, canonical_nf_relu(empty))
def test_zero_sized_arrays(self):
zero_params = {
'w1': jnp.zeros((0, 2, self.c_in)),
'w2': jnp.zeros((2, 0, self.c_in)),
}
c = canonical_nf_relu(zero_params)
g = generated_nf_relu(zero_params)
_same_structure_and_shapes(c, g)
_same_structure_and_shapes(zero_params, c)
def test_nested_mixed_types(self):
mixed = {
'w': jrandom.normal(self.key, (2, 2, self.c_in)),
'scalar': 3.14,
'nested': {'v': 2.71}
}
wrapped = jtu.tree_map(lambda x: jnp.array([x]) if isinstance(x, (int, float)) else x, mixed)
try:
c = canonical_nf_relu(wrapped)
g = generated_nf_relu(wrapped)
for cl, gl in zip(jtu.tree_leaves(c), jtu.tree_leaves(g)):
np.testing.assert_allclose(cl, gl, rtol=1e-5, atol=1e-8)
except Exception:
self.skipTest("Mixed scalar handling unsupported; parity preserved")
def _make_params_and_spec(key, c_in):
params = {
'a': jrandom.normal(jrandom.fold_in(key, 1), (2, 2, c_in)),
'b': jrandom.normal(jrandom.fold_in(key, 2), (3, 1, c_in)),
}
perm_spec = {
'a': (0, 1, None),
'b': (1, 0, None),
}
return params, perm_spec
class TestUNFLayerAndSequential(unittest.TestCase):
# leave any other tests in this class as they are
def test_unflayer_shapes_and_forward_equivalence(self):
key = jrandom.PRNGKey(123)
c_in, c_out = 3, 4
params, perm_spec = _make_params_and_spec(key, c_in)
with patch('canonical.gen_basis', side_effect=_mock_gen_basis), \
patch('layers.gen_basis', side_effect=_mock_gen_basis):
c_mod = CanonicalUNFLayer(c_out=c_out, c_in=c_in)
g_mod = GeneratedUNFLayer(c_out=c_out, c_in=c_in)
c_vars = c_mod.init(key, params, perm_spec)
g_vars = g_mod.init(key, params, perm_spec)
_same_structure_and_shapes(c_vars['params'], g_vars['params'])
g_vars_synced = {'params': _copy_params(c_vars['params'], g_vars['params'])}
c_out_tree = c_mod.apply(c_vars, params, perm_spec)
g_out_tree = g_mod.apply(g_vars_synced, params, perm_spec)
_same_structure_and_shapes(c_out_tree, g_out_tree)
for cl, gl in zip(jtu.tree_leaves(c_out_tree), jtu.tree_leaves(g_out_tree)):
np.testing.assert_allclose(cl, gl, rtol=1e-5, atol=1e-8)
def test_unflayer_param_shapes_and_bias_broadcast(self):
key = jrandom.PRNGKey(123)
c_in, c_out = 3, 4
params, perm_spec = _make_params_and_spec(key, c_in)
with patch('canonical.gen_basis', side_effect=_mock_gen_basis), \
patch('layers.gen_basis', side_effect=_mock_gen_basis):
mod = CanonicalUNFLayer(c_out=c_out, c_in=c_in)
vars_ = mod.init(key, params, perm_spec)
flat_params = jtu.tree_leaves(vars_['params'])
# At least one param leaf should end with c_out (theta[..., c_out])
self.assertTrue(any(p.shape and p.shape[-1] == c_out for p in flat_params))
# At least one 1-D bias of length c_out
self.assertTrue(any((p.ndim == 1 and p.shape[0] == c_out) for p in flat_params))
def test_unfsequential_end_to_end(self):
key = jrandom.PRNGKey(123)
c_in, c_out = 3, 4
params, perm_spec = _make_params_and_spec(key, c_in)
with patch('canonical.gen_basis', side_effect=_mock_gen_basis), \
patch('layers.gen_basis', side_effect=_mock_gen_basis):
c_seq = CanonicalUNFSequential(layers=[
CanonicalUNFLayer(c_out=c_out, c_in=c_in),
canonical_nf_relu,
])
g_seq = GeneratedUNFSequential(layers=[
GeneratedUNFLayer(c_out=c_out, c_in=c_in),
generated_nf_relu,
])
c_vars = c_seq.init(key, params, perm_spec)
g_vars = g_seq.init(key, params, perm_spec)
g_vars_synced = {'params': _copy_params(c_vars['params'], g_vars['params'])}
c_out_tree = c_seq.apply(c_vars, params, perm_spec)
g_out_tree = g_seq.apply(g_vars_synced, params, perm_spec)
_same_structure_and_shapes(c_out_tree, g_out_tree)
for cl, gl in zip(jtu.tree_leaves(c_out_tree), jtu.tree_leaves(g_out_tree)):
np.testing.assert_allclose(cl, gl, rtol=1e-5, atol=1e-8)
for leaf in jtu.tree_leaves(c_out_tree):
self.assertTrue((leaf >= 0).all())
def test_batchunflayer_matches_unbatched(self):
key = jrandom.PRNGKey(123)
c_in, c_out = 3, 4
params, perm_spec = _make_params_and_spec(key, c_in)
with patch('canonical.gen_basis', side_effect=_mock_gen_basis), \
patch('layers.gen_basis', side_effect=_mock_gen_basis):
batch_size = 5
batched_params = jax.tree.map(
lambda x: jnp.stack([x + 0.01 * i for i in range(batch_size)], axis=0),
params
)
c_unf = CanonicalUNFLayer(c_out=c_out, c_in=c_in)
c_batch = CanonicalBatchUNFLayer(c_out=c_out, c_in=c_in)
# Initialize unbatched once; BatchUNFLayer shares params across batch
c_vars = c_unf.init(key, params, perm_spec)
def single_forward(p):
return c_unf.apply(c_vars, p, perm_spec)
manual_batched = jax.vmap(single_forward, in_axes=0, out_axes=0)(batched_params)
# Pass shared params collection explicitly
c_batch_out = c_batch.apply({'params': c_vars['params']}, batched_params, perm_spec)
_same_structure_and_shapes(manual_batched, c_batch_out)
for ml, bl in zip(jtu.tree_leaves(manual_batched), jtu.tree_leaves(c_batch_out)):
np.testing.assert_allclose(ml, bl, rtol=1e-5, atol=1e-8)
# Keep your original TestUNFSequentialBehavior mock test to validate routing logic
class TestUNFSequentialBehavior(unittest.TestCase):
def setUp(self):
self.key = jrandom.PRNGKey(42)
self.c_in = 3
self.params = {'weight': jrandom.normal(self.key, (2, 2, self.c_in))}
self.perm_spec = {'weight': (0, 1, None)}
def test_sequential_layer_routing(self):
class MockUNFLayer:
def __init__(self):
self.called_with_spec = False
def __call__(self, params, spec):
self.called_with_spec = True
return jtu.tree_map(lambda x: x + 1.0, params)
class MockPointwise:
def __init__(self):
self.called = False
def __call__(self, params):
self.called = True
return jtu.tree_map(lambda x: x * 2.0, params)
unf = MockUNFLayer()
pw = MockPointwise()
def run_seq(layers, params, spec):
out = params
for layer in layers:
if isinstance(layer, MockUNFLayer):
out = layer(out, spec)
else:
out = layer(out)
return out
out = run_seq([unf, pw], self.params, self.perm_spec)
self.assertTrue(unf.called_with_spec)
self.assertTrue(pw.called)
expected = jtu.tree_map(lambda x: (x + 1.0) * 2.0, self.params)
for a, b in zip(jtu.tree_leaves(out), jtu.tree_leaves(expected)):
np.testing.assert_array_equal(a, b)
if __name__ == "__main__":
unittest.main()