Digital Drosophila Archive
222 lines
14 KiB
Python
222 lines
14 KiB
Python
"""UNREGISTERED input consumer; no I/O, brain execution, or training.
|
|
|
|
The frozen L/AK interface is discrete float32 Bernoulli (one request per PN
|
|
and tick), not a continuous-time Poisson sampler. PN/rate mapping is supplied
|
|
and externally authenticated by the caller; this module never selects odors,
|
|
rebuilds mappings, rescales rates, clips probabilities, or resets brain RNGs.
|
|
|
|
generate_cs_requests lazily uses the original CUDA Torch random operation.
|
|
CPU mocks test its contract only, not CUDA sequence equivalence. A full
|
|
(steps, PN-columns) matrix is drawn once, then the explicit half-open CS
|
|
window masks requests. A 100 ms CS in a 120 ms epoch is NOT the full old L
|
|
120 ms input. Different draw shapes need not share identical random prefixes.
|
|
The caller must register source/rate authority, device/environment, budgets,
|
|
stream aliases, and a separate bounded CUDA equivalence test before real use.
|
|
Returned request/source arrays are owned read-only copies, not immutable
|
|
capabilities; the consumer must recheck their recorded hashes before use.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import re
|
|
|
|
import numpy as np
|
|
|
|
|
|
N_NEURONS = 166700
|
|
L_SOURCE_SHA = 'e97d58d8c1f44920d0e953f8f5831ddc86fa0198784e86460e315de4116ac553'
|
|
AK_ENCODER_SHA = '0061689abb1832e963718bd836bc8a50009ee38b258143a753b4d59e63414925'
|
|
|
|
|
|
def require(value, message):
|
|
if not value:
|
|
raise ValueError(message)
|
|
|
|
|
|
def array_identity(value):
|
|
return dict(dtype=value.dtype.str, shape=list(value.shape), order='C-logical-bytes',
|
|
sha256=hashlib.sha256(value.tobytes(order='C')).hexdigest())
|
|
|
|
|
|
def _vector(value, dtype, name):
|
|
require(isinstance(value, np.ndarray) and value.dtype == np.dtype(dtype) and value.ndim == 1,
|
|
name + ' must be an exact one-dimensional ' + np.dtype(dtype).name + ' array')
|
|
|
|
|
|
def _targets(value):
|
|
_vector(value, np.int32, 'targets')
|
|
require(np.all((value >= 0) & (value < N_NEURONS)), 'Target outside canonical global neuron range')
|
|
require(len(np.unique(value)) == len(value), 'Duplicate PN columns rejected; never merge rates or deduplicate RNG columns')
|
|
|
|
|
|
def _clock(steps, start, stop):
|
|
require(type(steps) is int and 0 < steps <= np.iinfo(np.int32).max, 'steps must be a positive int32-range integer')
|
|
require(type(start) is type(stop) is int and 0 <= start <= stop <= steps, 'Invalid explicit half-open CS tick window')
|
|
|
|
|
|
def probabilities_f32(targets, rates_hz, *, dt_ms=0.1):
|
|
"""Preserve the L expression's separate float32 multiply then divide."""
|
|
_targets(targets); _vector(rates_hz, np.float32, 'rates_hz')
|
|
require(rates_hz.shape == targets.shape and np.all(np.isfinite(rates_hz)) and np.all(rates_hz >= 0), 'Invalid PN rate vector')
|
|
require(type(dt_ms) in (int, float) and dt_ms == 0.1, 'Only the frozen dt_ms=0.1 contract is supported')
|
|
probability = np.divide(np.multiply(rates_hz, np.float32(dt_ms), dtype=np.float32), np.float32(1000.0), dtype=np.float32)
|
|
original = rates_hz * dt_ms / 1000.0
|
|
require(original.dtype == np.float32 and original.tobytes() == probability.tobytes(), 'Installed NumPy changed the frozen rate expression')
|
|
require(np.all(np.isfinite(probability)) and np.all((probability >= 0) & (probability <= 1)), 'Probability outside [0,1]; no clipping or rate adjustment')
|
|
return probability
|
|
|
|
|
|
def forced_from_uniforms(uniforms, probability):
|
|
"""Pure arithmetic fixture helper, NOT a replacement CUDA generator."""
|
|
_vector(probability, np.float32, 'probability')
|
|
require(isinstance(uniforms, np.ndarray) and uniforms.dtype == np.float32 and uniforms.ndim == 2 and
|
|
uniforms.shape[1] == len(probability), 'Uniform fixture requires exact float32 [ticks,columns]')
|
|
require(np.all(np.isfinite(uniforms)) and np.all((uniforms >= 0) & (uniforms < 1)) and
|
|
np.all(np.isfinite(probability)) and np.all((probability >= 0) & (probability <= 1)), 'Invalid uniform/probability fixture')
|
|
return uniforms < probability[None, :]
|
|
|
|
|
|
def requests_from_forced(forced, targets, *, cs_start_tick, cs_stop_tick):
|
|
"""Sort resulting requests only; never reorder the pre-sampling columns."""
|
|
_targets(targets)
|
|
require(isinstance(forced, np.ndarray) and forced.dtype == np.bool_ and forced.ndim == 2 and
|
|
forced.shape[1] == len(targets), 'Forced samples must be Boolean [steps,original PN columns]')
|
|
steps = forced.shape[0]; _clock(steps, cs_start_tick, cs_stop_tick)
|
|
ticks, columns = np.nonzero(forced[cs_start_tick:cs_stop_tick])
|
|
ticks = ticks.astype(np.int32) + np.int32(cs_start_tick)
|
|
neurons = targets[columns].copy()
|
|
order = np.lexsort((neurons, ticks))
|
|
requests = {'tick': ticks[order], 'neuron_idx': neurons[order]}
|
|
validate_requests(requests, steps)
|
|
for value in requests.values(): value.setflags(write=False)
|
|
generated = int(np.count_nonzero(forced)); retained = len(ticks)
|
|
return dict(requests=requests, audit=dict(steps=steps, CS_window=[cs_start_tick, cs_stop_tick],
|
|
full_matrix_boolean_hits=generated, retained_CS_requests=retained,
|
|
outside_CS_boolean_hits_masked=generated - retained,
|
|
original_PN_column_order_preserved=True, sorted_only_after_sampling=True,
|
|
duplicate_requests_removed=0, probabilities_clipped=False,
|
|
returned_requests_read_only=True, consumer_must_recheck_array_hashes=True,
|
|
forced_identity=array_identity(forced), targets_identity=array_identity(targets),
|
|
requests_identity={k: array_identity(v) for k, v in requests.items()}))
|
|
|
|
|
|
def _load_torch():
|
|
import torch
|
|
return torch
|
|
|
|
|
|
def generate_cs_requests(targets, rates_hz, *, seed, steps, cs_start_tick, cs_stop_tick,
|
|
device, max_uniform_draws, dt_ms=0.1):
|
|
"""Future explicit CUDA input generation; no implicit CPU fallback.
|
|
|
|
``seed`` is the caller's full semantic seed (Python int in [0,2**63)).
|
|
The generator is private to this call. No offset/modulo/truncation or
|
|
global/manual brain seed is used. Aliases must reuse the same complete
|
|
sampling descriptor, including steps/column order/window, not seed alone.
|
|
The caller owns authorization, resource admission, and external rate pins.
|
|
``device`` and ``max_uniform_draws`` must be explicitly supplied. The
|
|
latter bounds steps * PN columns, not total process/GPU memory. Retaining
|
|
initial_seed proves only integer delivery, not CUDA high-bit influence.
|
|
"""
|
|
require(type(seed) is int and 0 <= seed < 2**63, 'Exact full 63-bit Python integer seed required')
|
|
_clock(steps, cs_start_tick, cs_stop_tick)
|
|
probability = probabilities_f32(targets, rates_hz, dt_ms=dt_ms)
|
|
require(type(device) is str and re.fullmatch('cuda:[0-9]+', device), 'Explicit indexed CUDA device required; no CPU fallback')
|
|
require(type(max_uniform_draws) is int and max_uniform_draws > 0, 'Explicit positive integer uniform-draw budget required')
|
|
uniform_draws = steps * len(targets)
|
|
require(uniform_draws <= max_uniform_draws, 'Full matrix exceeds caller uniform-draw budget; no chunking or clipping')
|
|
torch = _load_torch()
|
|
require(torch.cuda.is_available() and torch.get_default_dtype() == torch.float32, 'Original CUDA/default-float32 sampler environment required')
|
|
actual_device = torch.device(device)
|
|
generator = torch.Generator(device=actual_device)
|
|
generator.manual_seed(seed)
|
|
require(generator.initial_seed() == seed, 'Generator did not retain the complete semantic seed')
|
|
p_gpu = torch.as_tensor(probability, dtype=torch.float32, device=actual_device)
|
|
# Exactly one complete draw. No chunking, per-PN loop, or tail-dependent redraw.
|
|
uniforms = torch.rand((steps, len(targets)), generator=generator, device=actual_device)
|
|
require(uniforms.dtype == torch.float32 and str(uniforms.device) == str(actual_device), 'Sampler dtype/device changed')
|
|
forced = (uniforms < p_gpu[None, :]).cpu().numpy()
|
|
result = requests_from_forced(forced, targets, cs_start_tick=cs_start_tick, cs_stop_tick=cs_stop_tick)
|
|
# Optional identifiers are recorded only when the installed Torch exposes
|
|
# them. An indexed device name is not presented as a UUID or external pin.
|
|
identity = {'uuid': None, 'pci_bus_id': None, 'query_error': None}
|
|
try:
|
|
properties = torch.cuda.get_device_properties(actual_device)
|
|
for key in ('uuid', 'pci_bus_id'):
|
|
value = getattr(properties, key, None)
|
|
if value is not None: identity[key] = str(value)
|
|
except (AttributeError, RuntimeError) as exc:
|
|
identity['query_error'] = type(exc).__name__ + ': ' + str(exc)
|
|
result['audit'].update(schema='phase4an-conditioning-input-v1-unregistered',
|
|
seed=seed, seed_bits=63, seed_hex=f'{seed:016x}', generator_initial_seed=generator.initial_seed(),
|
|
seed_conversion='exact integer; no truncation/modulo/offset', private_generator=True,
|
|
sampler='Torch CUDA rand default float32; strict U < float32 probability',
|
|
generator_type=type(generator).__module__ + '.' + type(generator).__qualname__,
|
|
numpy_version=str(np.__version__), torch_version=str(torch.__version__), torch_cuda_version=torch.version.cuda,
|
|
execution_device=str(uniforms.device), device_name=str(torch.cuda.get_device_name(actual_device)),
|
|
device_capability=list(torch.cuda.get_device_capability(actual_device)),
|
|
device_identity=identity, device_identity_verified_against_external_pin=False,
|
|
matrix_draw_calls=1, uniform_matrix_shape=[steps, len(targets)], uniform_scalar_draws=uniform_draws,
|
|
max_uniform_draws=max_uniform_draws, uniform_matrix_bytes=uniform_draws * np.dtype(np.float32).itemsize,
|
|
budget_scope='Uniform scalar count only, not total process or GPU memory',
|
|
sampled_before_window_mask=True, dt_ms=dt_ms, dt_float32_identity=array_identity(np.asarray([dt_ms], np.float32)),
|
|
rate_units='Hz', probability_identity=array_identity(probability), rates_identity=array_identity(rates_hz),
|
|
input_mapping_authority_verified_by_this_module=False,
|
|
reference_L_source_sha256=L_SOURCE_SHA, reference_AK_encoder_source_sha256=AK_ENCODER_SHA,
|
|
full_old_L_input_identity_claimed=False, CUDA_sequence_equivalence_tested_here=False,
|
|
CUDA_high_seed_bit_sequence_influence_tested_here=False,
|
|
timing_scope='Full epoch matrix drawn once, then explicit CS window; old L supplied PN requests over its full duration',
|
|
RNG_prefix_invariance_across_shapes_claimed=False, continuous_time_Poisson_claimed=False,
|
|
brain_reset_called=False, brain_executed=False, training_executed=False, protocol_registered=False)
|
|
return result
|
|
|
|
|
|
def validate_requests(requests, steps):
|
|
_clock(steps, 0, steps)
|
|
require(type(requests) is dict and set(requests) == {'tick', 'neuron_idx'}, 'Exact sparse request schema required')
|
|
for key, value in requests.items(): _vector(value, np.int32, key)
|
|
tick, neuron = requests['tick'], requests['neuron_idx']
|
|
require(tick.shape == neuron.shape and np.all((tick >= 0) & (tick < steps)) and
|
|
np.all((neuron >= 0) & (neuron < N_NEURONS)), 'Requests outside local clock/global neuron range')
|
|
keys = tick.astype(np.int64) * N_NEURONS + neuron
|
|
require(len(keys) < 2 or np.all(keys[1:] > keys[:-1]), 'Requests must already be sorted unique; no silent sorting/deduplication')
|
|
return keys
|
|
|
|
|
|
class RequestConflictError(ValueError):
|
|
def __init__(self, audit):
|
|
super().__init__('CS/US request overlap rejected; explicit boolean_union is required to combine it')
|
|
self.audit = audit
|
|
|
|
|
|
def merge_requests(cs, us, *, steps, conflict_policy='error'):
|
|
"""Compose two valid streams, recording every cross-source collision.
|
|
|
|
boolean_union explicitly reproduces a single Boolean request per neuron /
|
|
tick, not two deliveries. Separate source attempts are retained in audit
|
|
and uint8 source_mask (CS=1, US=2, overlap=3). This is not refractory
|
|
acceptance, actual spiking, an artificial D value, or an update rule.
|
|
"""
|
|
require(conflict_policy in ('error', 'boolean_union'), 'Unknown explicit conflict policy')
|
|
cs_keys, us_keys = validate_requests(cs, steps), validate_requests(us, steps)
|
|
overlap = np.intersect1d(cs_keys, us_keys, assume_unique=True)
|
|
conflicts = [dict(tick=int(k // N_NEURONS), neuron_idx=int(k % N_NEURONS), CS_attempts=1, US_attempts=1,
|
|
combined_boolean_requests=1 if conflict_policy == 'boolean_union' else None) for k in overlap]
|
|
audit = dict(schema='phase4an-request-composition-v1-unregistered', policy=conflict_policy,
|
|
CS_attempts=len(cs_keys), US_attempts=len(us_keys), cross_source_conflict_count=len(overlap), conflicts=conflicts,
|
|
duplicate_within_source_allowed=False, refractory_acceptance_evaluated=False, actual_spikes_evaluated=False,
|
|
input_identity={name: {k: array_identity(v) for k, v in values.items()} for name, values in (('CS', cs), ('US', us))})
|
|
if len(overlap) and conflict_policy == 'error': raise RequestConflictError(audit)
|
|
keys = np.union1d(cs_keys, us_keys)
|
|
sources = np.zeros(len(keys), np.uint8)
|
|
sources[np.searchsorted(keys, cs_keys)] |= np.uint8(1)
|
|
sources[np.searchsorted(keys, us_keys)] |= np.uint8(2)
|
|
requests = {'tick': (keys // N_NEURONS).astype(np.int32), 'neuron_idx': (keys % N_NEURONS).astype(np.int32)}
|
|
validate_requests(requests, steps)
|
|
for value in (*requests.values(), sources): value.setflags(write=False)
|
|
audit.update(output_requests=len(keys), explicit_boolean_overlap_collapses=len(overlap),
|
|
requests_identity={k: array_identity(v) for k, v in requests.items()}, source_mask_identity=array_identity(sources),
|
|
returned_arrays_read_only=True, consumer_must_recheck_array_hashes=True,
|
|
learning_or_D_command_defined=False, brain_executed=False, protocol_registered=False)
|
|
return dict(requests=requests, source_mask=sources, audit=audit)
|