qishizhe/digital-drosophila
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Seal AO interface failure and verified isolated postprocessing diagnosis

Browse Source
This commit is contained in:
Digital Drosophila Archive
2026-09-30 17:57:02 +08:00
parent 4ff241bdc9
commit 8e9f8f4d56
126 changed files with 92124 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
registry/phase4ao-conditioning-interface/source-snapshot/test_conditioning_inputs.py
+258
View File
@@ -0,0 +1,258 @@
"""Synthetic CPU/mocked-CUDA contract tests; never run a real input generator."""
import ast
import hashlib
import json
from pathlib import Path
import types
import unittest
from unittest.mock import patch
import numpy as np
import conditioning_inputs as c
def req(rows):
values = np.asarray(rows, np.int32).reshape(-1, 2)
return {'tick': values[:, 0].copy(), 'neuron_idx': values[:, 1].copy()}
class FakeTensor:
def __init__(self, values, device):
self.values = np.array(values, copy=True)
self.device, self.dtype = device, self.values.dtype
def __getitem__(self, key): return FakeTensor(self.values[key], self.device)
def __lt__(self, other): return FakeTensor(self.values < other.values, self.device)
def cpu(self): return self
def numpy(self): return self.values.copy()
class FakeTorch:
"""Observable adapter, not a CUDA or random-number emulation."""
float32 = np.dtype(np.float32)
__version__ = 'SYNTHETIC-CONTRACT-MOCK-NOT-TORCH'
version = types.SimpleNamespace(cuda=None)
def __init__(self, uniforms, truncate=False):
self.uniforms = uniforms
self.calls, self.seeds, self.truncate = [], [], truncate
self.cuda = types.SimpleNamespace(is_available=lambda: True,
get_device_name=lambda device: 'SYNTHETIC-NOT-A-REAL-GPU', get_device_capability=lambda device: (0, 0),
get_device_properties=lambda device: types.SimpleNamespace())
def get_default_dtype(self): return self.float32
def device(self, name): return name
def Generator(self, device):
owner = self
class Generator:
def manual_seed(self, value):
owner.seeds.append(value); self.seed = value & 0xffffffff if owner.truncate else value
def initial_seed(self): return self.seed
self.calls.append(('generator', device)); return Generator()
def as_tensor(self, values, dtype, device):
self.calls.append(('probability', np.array(values, copy=True), dtype, device))
return FakeTensor(values, device)
def rand(self, shape, generator, device):
self.calls.append(('rand', shape, generator.initial_seed(), device))
if shape != self.uniforms.shape: raise AssertionError('Unexpected draw shape')
return FakeTensor(self.uniforms, device)
class InputsTests(unittest.TestCase):
def setUp(self):
self.targets = np.array([19, 3], np.int32)
self.rates = np.array([5000, 10000], np.float32)
def test_frozen_probability_dtype_order_signed_zero_and_no_mutation(self):
targets = np.arange(6, dtype=np.int32)
rates = np.array([0., -0., np.nextafter(np.float32(0), np.float32(1)), .1, 123.456, 10000.], np.float32)
before = rates.tobytes(); rates.setflags(write=False)
actual = c.probabilities_f32(targets, rates)
self.assertEqual(actual.dtype, np.float32)
self.assertEqual(actual.tobytes(), (rates * .1 / 1000.).tobytes())
self.assertEqual(rates.tobytes(), before)
def test_uniform_threshold_is_strict_and_bernoulli_not_poisson_counts(self):
p = np.array([0, .5, 1], np.float32)
u = np.array([[0, .5, np.nextafter(np.float32(1), np.float32(0))], [0, .499, 0]], np.float32)
forced = c.forced_from_uniforms(u, p)
np.testing.assert_array_equal(forced, [[False, False, True], [False, True, True]])
self.assertEqual(forced.dtype, np.bool_)
def test_original_PN_column_order_then_sparse_tick_global_sort_only(self):
forced = np.array([[True, True], [True, False], [False, True]], np.bool_)
before = forced.copy(); self.targets.setflags(write=False)
result = c.requests_from_forced(forced, self.targets, cs_start_tick=0, cs_stop_tick=3)
np.testing.assert_array_equal(result['requests']['tick'], [0, 0, 1, 2])
np.testing.assert_array_equal(result['requests']['neuron_idx'], [3, 19, 19, 3])
np.testing.assert_array_equal(forced, before)
self.assertEqual(result['audit']['duplicate_requests_removed'], 0)
def test_half_open_window_masks_full_matrix_including_empty_window(self):
forced = np.ones((5, 2), np.bool_)
result = c.requests_from_forced(forced, self.targets, cs_start_tick=1, cs_stop_tick=4)
self.assertEqual(result['audit']['full_matrix_boolean_hits'], 10)
self.assertEqual(result['audit']['outside_CS_boolean_hits_masked'], 4)
self.assertEqual(set(result['requests']['tick']), {1, 2, 3})
empty = c.requests_from_forced(forced, self.targets, cs_start_tick=2, cs_stop_tick=2)
self.assertEqual(len(empty['requests']['tick']), 0)
self.assertEqual(empty['audit']['outside_CS_boolean_hits_masked'], 10)
def test_full_63bit_seed_single_full_draw_and_mock_scope_receipt(self):
seed = (1 << 62) + (1 << 32) + 19
fake = FakeTorch(np.array([[.2, .6], [.7, .7], [.1, .2], [.8, .1], [.1, .1]], np.float32))
with patch.object(c, '_load_torch', return_value=fake):
result = c.generate_cs_requests(self.targets, self.rates, seed=seed, steps=5, cs_start_tick=1, cs_stop_tick=4,
device='cuda:0', max_uniform_draws=10)
self.assertEqual(fake.seeds, [seed]); draws = [x for x in fake.calls if x[0] == 'rand']
self.assertEqual(draws, [('rand', (5, 2), seed, 'cuda:0')])
a = result['audit']; self.assertEqual(a['seed_hex'], f'{seed:016x}')
self.assertEqual(a['numpy_version'], np.__version__)
self.assertEqual(a['torch_version'], fake.__version__)
self.assertEqual(a['device_name'], 'SYNTHETIC-NOT-A-REAL-GPU')
self.assertFalse(a['CUDA_sequence_equivalence_tested_here'])
self.assertFalse(a['CUDA_high_seed_bit_sequence_influence_tested_here'])
self.assertFalse(a['full_old_L_input_identity_claimed'])
self.assertEqual(a['uniform_scalar_draws'], 10)
self.assertEqual((a['max_uniform_draws'], a['uniform_matrix_bytes']), (10, 40))
self.assertEqual(a['device_identity'], {'uuid': None, 'pci_bus_id': None, 'query_error': None})
np.testing.assert_array_equal(result['requests']['tick'], [1, 2, 2, 3])
np.testing.assert_array_equal(result['requests']['neuron_idx'], [3, 3, 19, 3])
json.dumps(a, allow_nan=False)
def test_high_seed_bits_preserved_and_bad_consumer_detected_before_draw(self):
for seed in (0, 17, (1 << 32) + 17, (1 << 63) - 1):
fake = FakeTorch(np.zeros((1, 2), np.float32))
with patch.object(c, '_load_torch', return_value=fake):
result = c.generate_cs_requests(self.targets, self.rates, seed=seed, steps=1, cs_start_tick=0, cs_stop_tick=1,
device='cuda:0', max_uniform_draws=2)
self.assertEqual(result['audit']['generator_initial_seed'], seed)
self.assertEqual(fake.seeds, [seed])
fake = FakeTorch(np.zeros((1, 2), np.float32), truncate=True)
with patch.object(c, '_load_torch', return_value=fake), self.assertRaisesRegex(ValueError, 'complete semantic seed'):
c.generate_cs_requests(self.targets, self.rates, seed=(1 << 32) + 17, steps=1, cs_start_tick=0, cs_stop_tick=1,
device='cuda:0', max_uniform_draws=2)
self.assertFalse(any(x[0] == 'rand' for x in fake.calls))
def test_invalid_seed_clock_or_rate_never_imports_torch(self):
for seed in (-1, 2**63, True, np.int64(3), 3.):
with patch.object(c, '_load_torch') as loader, self.assertRaises(ValueError):
c.generate_cs_requests(self.targets, self.rates, seed=seed, steps=5, cs_start_tick=0, cs_stop_tick=5,
device='cuda:0', max_uniform_draws=10)
loader.assert_not_called()
for start, stop in ((-1, 1), (2, 1), (0, 6), (False, 1)):
with patch.object(c, '_load_torch') as loader, self.assertRaises(ValueError):
c.generate_cs_requests(self.targets, self.rates, seed=3, steps=5, cs_start_tick=start, cs_stop_tick=stop,
device='cuda:0', max_uniform_draws=10)
loader.assert_not_called()
def test_invalid_arrays_and_no_clipping_or_duplicate_merging(self):
for rates in (np.array([-1, 2], np.float32), np.array([np.nan, 2], np.float32), np.array([np.inf, 2], np.float32),
np.array([10001, 2], np.float32), self.rates.astype(np.float64), self.rates[:1]):
with self.assertRaises(ValueError): c.probabilities_f32(self.targets, rates)
for targets in (np.array([3, 3], np.int32), np.array([-1, 3], np.int32), np.array([166700, 3], np.int32), self.targets.astype(np.int64)):
with self.assertRaises(ValueError): c.probabilities_f32(targets, self.rates)
with self.assertRaises(ValueError): c.probabilities_f32(self.targets, self.rates, dt_ms=.2)
with self.assertRaises(ValueError): c.requests_from_forced(np.ones((2, 2), np.uint8), self.targets, cs_start_tick=0, cs_stop_tick=2)
def test_no_cpu_fallback_or_changed_default_float_dtype(self):
for variant in ('cpu', 'unavailable', 'float64'):
fake = FakeTorch(np.zeros((1, 2), np.float32)); device = 'cuda:0'
if variant == 'cpu': device = 'cpu'
if variant == 'unavailable': fake.cuda.is_available = lambda: False
if variant == 'float64': fake.get_default_dtype = lambda: np.dtype(np.float64)
with patch.object(c, '_load_torch', return_value=fake), self.assertRaises(ValueError):
c.generate_cs_requests(self.targets, self.rates, seed=3, steps=1, cs_start_tick=0, cs_stop_tick=1,
device=device, max_uniform_draws=2)
self.assertFalse(any(x[0] == 'rand' for x in fake.calls))
def test_explicit_device_and_budget_required_and_budget_checked_before_torch(self):
common = dict(seed=3, steps=5, cs_start_tick=0, cs_stop_tick=1)
for missing in ({}, {'device': 'cuda:0'}, {'max_uniform_draws': 10}):
with patch.object(c, '_load_torch') as loader, self.assertRaises(TypeError):
c.generate_cs_requests(self.targets, self.rates, **common, **missing)
loader.assert_not_called()
for budget in (0, -1, 9, True, 10., np.int64(10)):
with patch.object(c, '_load_torch') as loader, self.assertRaises(ValueError):
c.generate_cs_requests(self.targets, self.rates, **common, device='cuda:0', max_uniform_draws=budget)
loader.assert_not_called()
# Full 5x2 matrix admission, not merely the 1-tick active CS window.
fake = FakeTorch(np.zeros((5, 2), np.float32))
with patch.object(c, '_load_torch', return_value=fake):
result = c.generate_cs_requests(self.targets, self.rates, **common, device='cuda:1', max_uniform_draws=10)
self.assertEqual(result['audit']['execution_device'], 'cuda:1')
self.assertEqual(result['audit']['uniform_scalar_draws'], 10)
def test_optional_device_uuid_recorded_as_reported_or_explicitly_unavailable(self):
fake = FakeTorch(np.zeros((1, 2), np.float32))
fake.cuda.get_device_properties = lambda device: types.SimpleNamespace(uuid='SYNTHETIC-UUID', pci_bus_id='SYNTHETIC-PCI')
args = dict(seed=3, steps=1, cs_start_tick=0, cs_stop_tick=1, device='cuda:7', max_uniform_draws=2)
with patch.object(c, '_load_torch', return_value=fake):
audit = c.generate_cs_requests(self.targets, self.rates, **args)['audit']
self.assertEqual(audit['device_identity'], {'uuid': 'SYNTHETIC-UUID', 'pci_bus_id': 'SYNTHETIC-PCI', 'query_error': None})
self.assertFalse(audit['device_identity_verified_against_external_pin'])
def unavailable(device): raise RuntimeError('Synthetic property unavailable')
fake.cuda.get_device_properties = unavailable
with patch.object(c, '_load_torch', return_value=fake):
audit = c.generate_cs_requests(self.targets, self.rates, **args)['audit']
self.assertIsNone(audit['device_identity']['uuid'])
self.assertEqual(audit['device_identity']['query_error'], 'RuntimeError: Synthetic property unavailable')
def test_returned_audited_arrays_are_owned_readonly_and_inputs_not_frozen(self):
forced = np.ones((2, 2), np.bool_)
generated = c.requests_from_forced(forced, self.targets, cs_start_tick=0, cs_stop_tick=2)
merged = c.merge_requests(req([[0, 9]]), req([[1, 8]]), steps=2)
for value in (*generated['requests'].values(), *merged['requests'].values(), merged['source_mask']):
self.assertTrue(value.flags.owndata)
self.assertFalse(value.flags.writeable)
with self.assertRaises(ValueError): value[0] = 0
self.assertTrue(forced.flags.writeable)
self.assertTrue(self.targets.flags.writeable)
def test_empty_targets_and_p0_p1_are_explicit_valid_limits(self):
result = c.requests_from_forced(np.zeros((3, 0), np.bool_), np.empty(0, np.int32), cs_start_tick=0, cs_stop_tick=3)
self.assertEqual(result['requests']['tick'].dtype, np.int32); self.assertEqual(len(result['requests']['tick']), 0)
np.testing.assert_array_equal(c.probabilities_f32(self.targets, np.array([0, 10000], np.float32)), [0, 1])
def test_merging_disjoint_sources_is_sorted_without_mutating_inputs(self):
cs, us = req([[0, 9], [3, 4]]), req([[0, 2], [2, 5]])
for value in [*cs.values(), *us.values()]: value.setflags(write=False)
result = c.merge_requests(cs, us, steps=4)
np.testing.assert_array_equal(result['requests']['tick'], [0, 0, 2, 3])
np.testing.assert_array_equal(result['requests']['neuron_idx'], [2, 9, 5, 4])
np.testing.assert_array_equal(result['source_mask'], [2, 1, 2, 1])
self.assertEqual(result['audit']['explicit_boolean_overlap_collapses'], 0)
def test_collision_rejected_by_default_or_explicitly_audited_boolean_union(self):
cs, us = req([[0, 9], [3, 4]]), req([[0, 9], [2, 5], [3, 4]])
with self.assertRaises(c.RequestConflictError) as error: c.merge_requests(cs, us, steps=4)
self.assertEqual(error.exception.audit['cross_source_conflict_count'], 2)
result = c.merge_requests(cs, us, steps=4, conflict_policy='boolean_union')
np.testing.assert_array_equal(result['source_mask'], [3, 2, 3])
a = result['audit']; self.assertEqual((a['CS_attempts'], a['US_attempts'], a['output_requests']), (2, 3, 3))
self.assertEqual(a['explicit_boolean_overlap_collapses'], 2)
self.assertEqual([x['combined_boolean_requests'] for x in a['conflicts']], [1, 1])
json.dumps(a, allow_nan=False)
def test_within_source_duplicate_unsorted_and_bad_range_never_deduped(self):
for rows in ([[0, 3], [0, 3]], [[1, 3], [0, 3]], [[4, 3]], [[0, -1]]):
with self.assertRaises(ValueError): c.merge_requests(req(rows), req([]), steps=4, conflict_policy='boolean_union')
with self.assertRaises(ValueError): c.merge_requests(req([]), req([]), steps=4, conflict_policy='clip')
def test_frozen_AK_pure_conversion_AST_matches_for_full_window(self):
local = Path(__file__).resolve().parent.parent / 'apl-timing-validation-v1/encoder_inputs.py'
raw = local.read_bytes(); self.assertEqual(hashlib.sha256(raw).hexdigest(), c.AK_ENCODER_SHA)
tree = ast.parse(raw); node = next(n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name == 'requests_from_forced')
namespace = {'np': np}; exec(compile(ast.Module(body=[node], type_ignores=[]), str(local), 'exec'), namespace)
forced = np.array([[True, True], [False, True], [True, False]], np.bool_)
expected = namespace['requests_from_forced'](forced, self.targets)
actual = c.requests_from_forced(forced, self.targets, cs_start_tick=0, cs_stop_tick=3)['requests']
np.testing.assert_array_equal(expected, np.column_stack([actual['tick'], actual['neuron_idx']]))
if __name__ == '__main__':
unittest.main()