254 lines
12 KiB
Python
254 lines
12 KiB
Python
"""Synthetic-only acceptance. Run from tools; never loads any corpus geometry/field."""
|
|
import os
|
|
os.environ["CUDA_VISIBLE_DEVICES"] = ""
|
|
|
|
import json
|
|
from pathlib import Path
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
import numpy as np
|
|
import torch
|
|
from sklearn.ensemble import HistGradientBoostingRegressor
|
|
|
|
from s2_models import features as f, objectives as o
|
|
from s2_models.attention import Physics_Attention_Irregular_Mesh
|
|
from s2_models.network import QueryModel, weighted_mse
|
|
|
|
torch.set_num_threads(1)
|
|
|
|
|
|
def synthetic_star():
|
|
# One outer tetrahedron with its barycentre inserted: 4 volume tets.
|
|
x = np.array([[0., 0, 0], [1., 0, 0], [0., 1, 0], [0., 0, 1], [.25, .25, .25]])
|
|
t = np.array([[0, 1, 2, 4], [0, 1, 3, 4], [0, 2, 3, 4], [1, 2, 3, 4]])
|
|
return x, t, np.array([0., 0, 0, 0, .25])
|
|
|
|
|
|
class GeometryTests(unittest.TestCase):
|
|
def test_volume_lumping(self):
|
|
x, t, _ = synthetic_star()
|
|
*_, volumes, mass, edges, lengths = f.mesh_geometry(x, t)
|
|
self.assertAlmostEqual(volumes.sum(), 1/6)
|
|
self.assertAlmostEqual(mass.sum(), 1/6)
|
|
self.assertEqual(len(edges), 10)
|
|
|
|
def test_wall_edges_removed_both_distances_and_gate_tie(self):
|
|
x, t, dw = synthetic_star()
|
|
di, df, source = f.graph_distances(x, t, dw, [0., 0, 0])
|
|
expected = np.linalg.norm(x[4]-x[0]) + np.linalg.norm(x[1]-x[4])
|
|
self.assertAlmostEqual(di[1], expected)
|
|
np.testing.assert_allclose(df, di/.125)
|
|
self.assertEqual(source, 0)
|
|
unrestricted, _ = f.graph_distances(x, t, dw, x[0], exclude_wall_edges=False)
|
|
self.assertAlmostEqual(unrestricted[1], 1.)
|
|
self.assertGreater(di[1], unrestricted[1])
|
|
# Tie between original node 0 and interior 4, with no closer node.
|
|
_, _, source = f.graph_distances(x, t, dw, (x[0]+x[4])/2)
|
|
self.assertEqual(source, 0)
|
|
|
|
def test_unreachable_fail_closed(self):
|
|
x, t, dw = synthetic_star()
|
|
with self.assertRaisesRegex(ValueError, "unreachable"):
|
|
f.graph_distances(x, t, np.zeros_like(dw), x[0])
|
|
|
|
def test_degenerate_and_unused_fail(self):
|
|
x, t, _ = synthetic_star()
|
|
with self.assertRaisesRegex(ValueError, "degenerate"):
|
|
f.mesh_geometry(x, np.array([[0, 0, 1, 2]]))
|
|
with self.assertRaisesRegex(ValueError, "unused"):
|
|
f.mesh_geometry(np.vstack([x, [2, 2, 2]]), t)
|
|
|
|
def test_strict_volume_front_ties(self):
|
|
actual = f.relative_flow_volume([0, 2, 2, 3], [1, 2, 3, 4])
|
|
np.testing.assert_allclose(actual, [0, .1, .1, .6])
|
|
|
|
def test_affine_p1_and_zero_gradient(self):
|
|
x, t, _ = synthetic_star()
|
|
a = np.array([2., -3., 4.])
|
|
np.testing.assert_allclose(f.p1_nodal_gradient(x, t, x@a+7, normalize=False), np.tile(a, (5, 1)), atol=1e-13)
|
|
np.testing.assert_allclose(f.p1_nodal_gradient(x, t, x@a+7), np.tile(a/np.linalg.norm(a), (5, 1)), atol=1e-13)
|
|
np.testing.assert_array_equal(f.p1_nodal_gradient(x, t, np.ones(5)), np.zeros((5, 3)))
|
|
|
|
def test_moment_volume_weight_rotation_and_filter(self):
|
|
x, t, _ = synthetic_star()
|
|
di = np.zeros(5)
|
|
s, radius = f.spatial_moment(x, t, di)
|
|
centers = x[t].mean(axis=1)
|
|
directions = centers-x[0]
|
|
directions /= np.linalg.norm(directions, axis=1)[:, None]
|
|
expected = np.mean([np.outer(v, v) for v in directions], axis=0)
|
|
np.testing.assert_allclose(s[0], expected)
|
|
self.assertAlmostEqual(radius, 3*np.sqrt(2))
|
|
q = np.array([[0., -1, 0], [1., 0, 0], [0., 0, 1]])
|
|
rotated, _ = f.spatial_moment(x@q.T+3, t, di)
|
|
np.testing.assert_allclose(rotated, q@s@q.T, atol=1e-14)
|
|
self.assertGreaterEqual(np.linalg.eigvalsh(s).min(), -1e-14)
|
|
np.testing.assert_allclose(np.trace(s, axis1=1, axis2=2), 1.)
|
|
# D_i exclusion can empty a neighbourhood; no fabricated fallback tensor.
|
|
with self.assertRaisesRegex(ValueError, "empty"):
|
|
f.spatial_moment(x, t, [100, 0, 0, 0, 0])
|
|
|
|
def test_features_and_physical_scaling(self):
|
|
x, t, dw = synthetic_star()
|
|
a = f.r2_features(x, t, dw, x[0], .4)
|
|
b = f.r2_features(2*x, t, 2*dw, 2*x[0], .4)
|
|
self.assertEqual(a["features"].shape, (5, 20))
|
|
np.testing.assert_allclose(b["Df"], a["Df"])
|
|
np.testing.assert_allclose(b["Di"], 2*a["Di"])
|
|
np.testing.assert_allclose(b["Vf"], a["Vf"])
|
|
np.testing.assert_allclose(b["S"], a["S"])
|
|
np.testing.assert_allclose(a["features"][:, -1], .4)
|
|
|
|
def test_moment_unequal_volumes_and_coincident_center(self):
|
|
x, t, _ = synthetic_star()
|
|
x[4] = [.125, .25, .125]
|
|
s, radius = f.spatial_moment(x, t, np.zeros(5))
|
|
_, _, _, v, _, _, _ = f.mesh_geometry(x, t)
|
|
direction = x[t].mean(axis=1) - x[0]
|
|
direction /= np.linalg.norm(direction, axis=1)[:, None]
|
|
expected = np.einsum('j,ja,jb->ab', v/v.sum(), direction, direction)
|
|
np.testing.assert_allclose(s[0], expected)
|
|
# Add a tetrahedron whose centre is exactly node 4. Its volume must
|
|
# be excluded from that node's denominator as well as its numerator.
|
|
x, t, _ = synthetic_star()
|
|
s0, _ = f.spatial_moment(x, t, np.zeros(5))
|
|
s1, _ = f.spatial_moment(x, np.vstack([t, [0, 1, 2, 3]]), np.zeros(5))
|
|
np.testing.assert_allclose(s1[4], s0[4])
|
|
self.assertAlmostEqual(np.trace(s1[4]), 1.)
|
|
|
|
def test_base_slots_and_nonfinite_fail(self):
|
|
x, t, dw = synthetic_star()
|
|
dg, _ = f.graph_distances(x, t, dw, x[0], exclude_wall_edges=False)
|
|
base = f.base_features(x, dw, dg, x[0], [0, 0, 0], 2, 1/6, .5, .4)
|
|
self.assertEqual(base.shape, (5, 10))
|
|
np.testing.assert_allclose(base[:, :3], x/2)
|
|
np.testing.assert_allclose(base[:, 3], dw/.5)
|
|
np.testing.assert_allclose(base[:, 5], dg/2)
|
|
with self.assertRaises(ValueError):
|
|
f.base_features(x, dw, dg*float("nan"), x[0], [0, 0, 0], 2, 1/6, .5, .4)
|
|
|
|
|
|
class ObjectiveTests(unittest.TestCase):
|
|
def test_hierarchy_and_draw_compression(self):
|
|
# A has two parts; B one. Their masses must be .25, .25, .5.
|
|
c, p, g = [1, 3, 2, 4], [0, 0, 1, 2], ["A", "A", "A", "B"]
|
|
w = o.hierarchy_weights(c, p, g)
|
|
np.testing.assert_allclose(w, [.0625, .1875, .25, .5])
|
|
pred = torch.tensor([1., 3, 2, 4])
|
|
loss = weighted_mse(pred, torch.zeros(4), torch.tensor(w))
|
|
expanded = o.hierarchy_weights(np.ones(10), np.repeat(p, c), np.repeat(g, c))
|
|
expected = np.sum(expanded*np.repeat(pred.numpy(), c)**2)
|
|
self.assertAlmostEqual(loss.item(), expected)
|
|
# Sum of part contributions equals pooled objective, without local renorm.
|
|
subtotal = sum(weighted_mse(pred[np.array(p)==i], torch.zeros(sum(np.array(p)==i)), torch.tensor(w[np.array(p)==i])).item() for i in [0, 1, 2])
|
|
self.assertAlmostEqual(subtotal, loss.item())
|
|
|
|
def test_invalid_hierarchy(self):
|
|
with self.assertRaises(ValueError):
|
|
o.hierarchy_weights([1, 1], [0, 0], ["A", "B"])
|
|
with self.assertRaises(ValueError):
|
|
o.hierarchy_weights([1, 0], [0, 1], ["A", "B"])
|
|
|
|
def test_process_target_roundtrip_and_scale_invariance(self):
|
|
seconds = np.array([.1, .2, .6])
|
|
target = o.dimensionless_target(seconds, .4)
|
|
np.testing.assert_allclose(o.prediction_seconds(target, .4), seconds)
|
|
score1 = o.relative_l2(seconds*1.1, seconds, [1, 3, 1], [True]*3)
|
|
score2 = o.relative_l2(target*1.1, target, [1, 3, 1], [True]*3)
|
|
self.assertAlmostEqual(score1["value"], score2["value"])
|
|
np.testing.assert_allclose(o.b0_seconds([0, .5, 1], .4), [0, .2, .4])
|
|
|
|
def test_zero_missing_scales_no_fallback(self):
|
|
for scale in [0., -1., float("nan")]:
|
|
with self.assertRaises(ValueError):
|
|
o.dimensionless_target([1.], scale)
|
|
with self.assertRaises(ValueError):
|
|
o.prediction_seconds([float("nan")], .4)
|
|
self.assertFalse(hasattr(o, "log_target"))
|
|
self.assertFalse(hasattr(o, "weighted_median"))
|
|
|
|
def test_score_masks_before_arithmetic_and_zero_truth(self):
|
|
result = o.relative_l2([2., np.nan], [1., np.nan], [2, 0], [True, False])
|
|
self.assertEqual(result["value"], 1.)
|
|
self.assertIsNone(o.relative_l2([1.], [0.], [1], [True])["value"])
|
|
|
|
def test_histgbrt_grid_unfitted(self):
|
|
grid = f.histgbrt_grid()
|
|
self.assertEqual(len(grid), 12)
|
|
self.assertEqual(len({json.dumps(c, sort_keys=True) for c in grid}), 12)
|
|
with patch.object(HistGradientBoostingRegressor, "fit", side_effect=AssertionError("fitting forbidden")):
|
|
for config in grid:
|
|
model = HistGradientBoostingRegressor(**config)
|
|
self.assertFalse(model.early_stopping)
|
|
self.assertFalse(hasattr(model, "n_iter_"))
|
|
|
|
|
|
class NetworkTests(unittest.TestCase):
|
|
def test_original_attention_numerical_parity(self):
|
|
path = Path(__file__).parent/'s2_models/upstream/Physics_Attention.py'
|
|
source = path.read_text().split('class Physics_Attention_Structured_Mesh_2D')[0]
|
|
source = source.replace('from einops import rearrange, repeat', '')
|
|
namespace = {"rearrange": lambda x, pattern: x.permute(0, 2, 1, 3).reshape(x.shape[0], x.shape[2], -1)}
|
|
exec(compile(source, str(path), "exec"), namespace)
|
|
torch.manual_seed(9)
|
|
original = namespace['Physics_Attention_Irregular_Mesh'](128, heads=8, dim_head=16, slice_num=32).eval()
|
|
adapted = Physics_Attention_Irregular_Mesh(128, heads=8, dim_head=16, slice_num=32).eval()
|
|
adapted.load_state_dict(original.state_dict())
|
|
x = torch.randn(1, 7, 128)
|
|
with torch.inference_mode():
|
|
torch.testing.assert_close(original(x), adapted(x), rtol=0, atol=0)
|
|
|
|
def test_upstream_snapshot_hashes(self):
|
|
import hashlib
|
|
root = Path(__file__).parent/'s2_models/upstream'
|
|
manifest = json.loads((root/'manifest.json').read_text())
|
|
self.assertEqual(manifest['revision'], '75e0f67643806a81cd1d3f6adc88dd8c02416fe7')
|
|
for name, digest in manifest['files'].items():
|
|
self.assertEqual(hashlib.sha256((root/Path(name).name).read_bytes()).hexdigest(), digest)
|
|
|
|
def test_four_models_forward_only_and_parameter_counts(self):
|
|
for width in (128, 256):
|
|
models = {}
|
|
for arm in ("N", "E"):
|
|
torch.manual_seed(0)
|
|
model = QueryModel(arm, width).eval()
|
|
before = {k: v.clone() for k, v in model.state_dict().items()}
|
|
base, ids, gaps = torch.randn(7, 10), torch.tensor([0, 4, 6]), torch.rand(3, 2)
|
|
edge = torch.rand(3, 4) if arm == "E" else None
|
|
with torch.inference_mode():
|
|
pred = model(base, ids, gaps, edge)
|
|
self.assertEqual(pred.shape, (3,))
|
|
self.assertTrue(torch.isfinite(pred).all())
|
|
self.assertEqual(next(model.parameters()).device.type, "cpu")
|
|
for k, value in model.state_dict().items():
|
|
torch.testing.assert_close(value, before[k], rtol=0, atol=0)
|
|
models[arm] = model.parameter_counts()
|
|
self.assertEqual(models['E']['encoder'], models['N']['encoder'])
|
|
self.assertEqual(models['E']['total']-models['N']['total'], 4*width)
|
|
|
|
def test_query_order_global_context_and_input_rejection(self):
|
|
torch.manual_seed(7)
|
|
model = QueryModel("N").eval()
|
|
base, ids, gaps = torch.randn(7, 10), torch.tensor([0, 4]), torch.rand(2, 2)
|
|
with torch.inference_mode():
|
|
a = model(base, ids, gaps)
|
|
b = model(base, ids.flip(0), gaps.flip(0))
|
|
torch.testing.assert_close(a, b.flip(0))
|
|
changed = base.clone(); changed[6] += 20
|
|
c = model(changed, ids, gaps)
|
|
self.assertGreater(float(torch.max(torch.abs(a-c))), 1e-9)
|
|
with self.assertRaises(ValueError):
|
|
model(base, ids, gaps, torch.zeros(2, 4))
|
|
with self.assertRaises(ValueError):
|
|
model(base, torch.tensor([7]), torch.zeros(1, 2))
|
|
changed[6, 0] = float("nan")
|
|
with self.assertRaises(ValueError):
|
|
model(changed, ids, gaps)
|
|
with self.assertRaises(ValueError):
|
|
QueryModel("E")(base, ids, gaps)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main(verbosity=2)
|