Download src/flyBrain.ts from gpue/flyyt: direct link, hf CLI and curl.
- Browser
- Download file 6.83 kB
-
https://huggingface.co/spaces/gpue/flyyt/resolve/main/src/flyBrain.ts
- Command line
-
hf download hf://spaces/gpue/flyyt/src/flyBrain.ts
-
curl -L -o flyBrain.ts https://huggingface.co/spaces/gpue/flyyt/resolve/main/src/flyBrain.ts
6.83 kB
| /** | |
| * A small placeholder spiking neuron population — NOT the real FlyWire | |
| * connectome / Brian2 LIF network from Shiu et al. That network is ~139k | |
| * neurons / ~50M synapses and, per every reference implementation | |
| * researched (philshiu/Drosophila_brain_model, eonsystemspbc/fly-brain, | |
| * dtch1997/fly-api, neilt93/Fly-Brain-AI, vaibhavkedarisetti/fruit-fly-lab), | |
| * is NOT real-time anywhere — fruit-fly-lab's own optimized event-driven | |
| * engine reports ~10x slower than real-time. Running one live instance of | |
| * the real thing per fly, every animation frame, in a browser, isn't | |
| * feasible with any known implementation. | |
| * | |
| * This is a small (500-unit) leaky-integrate-and-fire population instead, | |
| * with the same shape of interface (create / step / read activity) so a | |
| * later real backend-streamed brain is a drop-in replacement — same spirit | |
| * as tripodGait.ts driving real joint names with a placeholder gait | |
| * function. The "sensory" and "motor" groups are the canonical minimal | |
| * sensorimotor demo used across the reference repos (LC4/LPLC2 visual- | |
| * looming input -> DNp01 "Giant Fibre" escape output) — and every neuron | |
| * here is a REAL FlyWire neuron at its REAL anatomical position (see | |
| * NEURON_POSITIONS below) — but the *connectivity* between them | |
| * (BrainState.weights) is still a random fixed matrix, not real connectome | |
| * synapses (which aren't loaded here). The motor group's activity isn't | |
| * only visualized: motorOutput() below feeds wingController.ts, so each | |
| * DNp01 neuron's firing actually drives its own wing's flap. | |
| */ | |
| import brainPositions from "./assets/brain-positions.json"; | |
| // Group sizes come from the baked data itself (tools/export_brain_positions.py) | |
| // rather than being hardcoded here, so the two can never drift out of sync: | |
| // every real LC4 + LPLC2 neuron (sensory), both real DNp01 neurons (motor), | |
| // and a real central-brain sample (hidden). | |
| export const SENSORY_COUNT = brainPositions.sensoryCount; | |
| export const HIDDEN_COUNT = brainPositions.hiddenCount; | |
| export const MOTOR_COUNT = brainPositions.motorCount; | |
| export const NEURON_COUNT = SENSORY_COUNT + HIDDEN_COUNT + MOTOR_COUNT; | |
| export type NeuronGroup = "sensory" | "hidden" | "motor"; | |
| export function neuronGroup(index: number): NeuronGroup { | |
| if (index < SENSORY_COUNT) return "sensory"; | |
| if (index < SENSORY_COUNT + HIDDEN_COUNT) return "hidden"; | |
| return "motor"; | |
| } | |
| // Which of the 2 motor-group slots is the real left/right DNp01 (baked | |
| // alongside their positions by tools/export_brain_positions.py from | |
| // FlyWire's own "side" column), found once rather than per frame. | |
| const MOTOR_SIDE_INDEX: Record<"left" | "right", number> = (() => { | |
| const motorStart = SENSORY_COUNT + HIDDEN_COUNT; | |
| const index = { left: -1, right: -1 }; | |
| brainPositions.motorSides.forEach((side, i) => { | |
| if (side === "left" || side === "right") index[side] = motorStart + i; | |
| }); | |
| return index; | |
| })(); | |
| /** Current activity (0-1, decaying) of the real left/right DNp01 neuron — consumed by wingController.ts. */ | |
| export function motorOutput(state: BrainState, side: "left" | "right"): number { | |
| return state.brightness[MOTOR_SIDE_INDEX[side]]; | |
| } | |
| const TAU_S = 0.02; // membrane time constant | |
| const THRESHOLD = 1; | |
| const NOISE_AMPLITUDE = 0.6; // baseline/spontaneous drive | |
| const RECURRENT_GAIN = 0.5; | |
| const CONNECTION_DENSITY = 0.15; | |
| const BRIGHTNESS_DECAY_TAU_S = 0.3; // afterglow when a neuron fires | |
| // Static point-cloud layout, shared by every fly's brain (population shape | |
| // is identical across instances; only activity differs). These are REAL | |
| // FlyWire FAFB v783 neuron positions, baked by tools/export_brain_positions.py | |
| // from flyconnectome/flywire_annotations: every real LC4 (104) + LPLC2 (210) | |
| // neuron for "sensory", both real DNp01 neurons (the full population -- | |
| // there are only 2, the "Giant Fibre" pair) for "motor", and a real sample | |
| // from FlyWire's central-brain super_class for "hidden". Order matches | |
| // neuronGroup(): sensory first, then hidden, then motor. Real anatomy, not | |
| // a synthetic scatter -- but the *connectivity* between them | |
| // (BrainState.weights, below) is still a random fixed matrix, not real | |
| // connectome synapses (which aren't loaded here); these neurons aren't | |
| // claimed to form one real circuit together. | |
| export const NEURON_POSITIONS = new Float32Array(brainPositions.positions); | |
| export interface BrainState { | |
| potentials: Float32Array; | |
| spiked: Uint8Array; | |
| /** 0-1 per neuron, set to 1 on spike, decays each step — drives the point-cloud visualization. */ | |
| brightness: Float32Array; | |
| weights: Float32Array; // NEURON_COUNT x NEURON_COUNT, row = source, col = target | |
| /** Reused every stepBrain() call, not reallocated -- every fly's brain now steps every frame (FlyInstances.tsx), not just the selected one. */ | |
| recurrentInputScratch: Float32Array; | |
| } | |
| function randomWeights(): Float32Array { | |
| const weights = new Float32Array(NEURON_COUNT * NEURON_COUNT); | |
| for (let i = 0; i < NEURON_COUNT; i++) { | |
| for (let j = 0; j < NEURON_COUNT; j++) { | |
| if (i === j) continue; | |
| if (Math.random() < CONNECTION_DENSITY) { | |
| weights[i * NEURON_COUNT + j] = (Math.random() * 2 - 1) * RECURRENT_GAIN; | |
| } | |
| } | |
| } | |
| return weights; | |
| } | |
| export function createBrain(): BrainState { | |
| return { | |
| potentials: new Float32Array(NEURON_COUNT), | |
| spiked: new Uint8Array(NEURON_COUNT), | |
| brightness: new Float32Array(NEURON_COUNT), | |
| weights: randomWeights(), | |
| recurrentInputScratch: new Float32Array(NEURON_COUNT), | |
| }; | |
| } | |
| /** | |
| * @param sensoryDrive 0-1, extra input current for the sensory group — fed | |
| * from the max of joystick magnitude and loomingPerception.ts's per-wing | |
| * drive (FlyInstances.tsx), so an approaching fly visibly lights up this | |
| * population same as manual driving does, not just a placeholder anymore. | |
| */ | |
| export function stepBrain(state: BrainState, sensoryDrive: number, dt: number): void { | |
| const { potentials, spiked, brightness, weights, recurrentInputScratch: recurrentInput } = state; | |
| const decay = dt / TAU_S; | |
| const brightnessDecay = Math.exp(-dt / BRIGHTNESS_DECAY_TAU_S); | |
| recurrentInput.fill(0); | |
| for (let i = 0; i < NEURON_COUNT; i++) { | |
| if (!spiked[i]) continue; | |
| for (let j = 0; j < NEURON_COUNT; j++) { | |
| recurrentInput[j] += weights[i * NEURON_COUNT + j]; | |
| } | |
| } | |
| for (let i = 0; i < NEURON_COUNT; i++) { | |
| const noise = (Math.random() * 2 - 1) * NOISE_AMPLITUDE; | |
| const sensoryInput = neuronGroup(i) === "sensory" ? sensoryDrive * 2 : 0; | |
| const input = noise + sensoryInput + recurrentInput[i]; | |
| potentials[i] += decay * (-potentials[i] + input); | |
| brightness[i] *= brightnessDecay; | |
| if (potentials[i] >= THRESHOLD) { | |
| spiked[i] = 1; | |
| potentials[i] = 0; | |
| brightness[i] = 1; | |
| } else { | |
| spiked[i] = 0; | |
| } | |
| } | |
| } | |