29:["$","title",null,{"children":"Research Replication: Unsupervised Learning of Digit Recognition Using STDP (Part 1) | Steve Oney | Observable"}] 2e:T5a2,{ const DATA_MIN_VAL = 0; const DATA_MAX_VAL = 255; const MIN_FIRING_RATE = 0.01; const MAX_FIRING_RATE = 4; const tau = 1.8; const delta_t = 0.001; const PIXEL_SIZE = 20; const svg = DOM.svg(PIXEL_SIZE * DIGIT_WIDTH, PIXEL_SIZE * DIGIT_HEIGHT); const color = d3.scaleLinear().range(["white", "black"]).domain([0, 0.7/delta_t]); const digitPixels = randomImage; const v = digitPixels.map(_ => 0); const rectangles = digitPixels.map((intensity, idx) => { const [x, y] = idx2Coordinates(idx, DIGIT_HEIGHT, DIGIT_WIDTH); const rect = d3.select(svg).append('rect') .attr('x', x * PIXEL_SIZE) .attr('y', y * PIXEL_SIZE) .attr('width', PIXEL_SIZE) .attr('height', PIXEL_SIZE) .style('fill', 'none'); return rect; }); function update(dt) { digitPixels.forEach((intensity, i) => { const firingProbability = dt * (MIN_FIRING_RATE + (MAX_FIRING_RATE - MIN_FIRING_RATE) * (intensity - DATA_MIN_VAL) / (DATA_MAX_VAL - DATA_MIN_VAL)); const fires = Math.random() < firingProbability; v[i] = v[i] * (1 - dt / tau); if(fires) { v[i] += 1/dt; } rectangles[i].style('fill', color(v[i])); }); const lastRun = Date.now(); setTimeout(() => { update((Date.now()-lastRun)/1000); }, delta_t * 1000); } update(0); return svg; }2f:T646,Our goal is going to be to have each excitatory neuron associated with each digit. In order to do that, we want: 1. To ensure that none of the neurons get too "greedy" and start firing with every input. For that reason, we implement the excitatory layer with ALIFs, which become less sensitive after they start firing. 2. To try to encourage *one* neuron to be associated with each digit (we don't want every neuron to represent a `6`). When a digit is shown, we want to only encourage one neuron to respond. To do this, we add an extra **inhibitory** layer. The inhibitory layer is a layer of LIF neurons (the same number of neurons as the excitatory layer). Each excitatory neuron has *one* corresponding inhibitory neuron. But, each inhibitory neuron will inhibit **every other excitatory neuron**. So, when an excitatory *x* neuron fires, it triggers its associated inhibitory neuron to fire. When that inhibitory neuron fires, it inhibits every excitatory neuron *except* for *x*, making it more likely that *x* is the only excitatory neuron that fires. ```JavaScript // Create the inhibitory neurons and post-synaptic potential for them const inhibitory_neurons = new NeuronCollection(() => new LIF, NUM_NEURONS) const inhPSP = new PSP(inhibitory_neurons, 0.2); // ... // Compute the output of the inhibitory layer by... const totalInhibitoryOutput = sum(inhPSP.output); // Finding the total inhibitory output // And take the sum *minus* each inhibitory neuron's value to get every other inhibitory neuron's value const inhibitoryOutput = inhPSP.output.map((v) => totalInhibitoryOutput - v); ```30:Tbe7,step = { // Create the input and post-synaptic potential for the input const inputLayer = new DigitInput(); const inputPSP = new PSP(inputLayer, 0.1); // STDP-learned weights between input and excitatory layer const stdp = new STDPWeights(DIGIT_SIZE, NUM_NEURONS); // Create the excitatory neurons and post-synaptic potential for them const excitatory_neurons = new NeuronCollection(() => new ALIF, NUM_NEURONS); const exPSP = new PSP(excitatory_neurons, 0.2); // Create the inhibitory neurons and post-synaptic potential for them const inhibitory_neurons = new NeuronCollection(() => new LIF, NUM_NEURONS) const inhPSP = new PSP(inhibitory_neurons, 0.2); // These PSPs are used for our display code (they have nothing to do with // the functionality of the network) const display_tau = 0.2; const inputDisplay = new PSP(inputLayer, display_tau); // For displaying input const exDisplay = new PSP(excitatory_neurons, display_tau); // For displaying excitatory output // Track the number of neurons that have fired let numFiresForRound = 0; inputLayer.onAdvance = () => numFiresForRound = 0; // When our input layer advances, reset our number of fires return async function(t_step, t) { await inputLayer.step(t_step, t); // Step the input inputPSP.step(t_step); // Step input post-synaptic const weightedInputVals = stdp.weightedOutput(inputPSP.output); // Compute the weighted inputs for the excitatory layer // Compute the output of the inhibitory layer by... const totalInhibitoryOutput = sum(inhPSP.output); // Finding the total inhibitory output // And take the sum *minus* each inhibitory neuron's value to get every other inhibitory neuron's value const inhibitoryOutputs = inhPSP.output.map((v) => totalInhibitoryOutput - v); // Compute the input to the excitatory layer as the sum of the weighted input from the digit and the // inhibitory input const excitatoryInput = addArrays(weightedInputVals, mulArray(negArray(inhibitoryOutputs), 2)); excitatory_neurons.step(excitatoryInput, t_step); // Step excitatory layer exPSP.step(t_step); // Step excitatory post-synaptic inhibitory_neurons.step(excitatory_neurons.output, t_step); // Step inhibitory layer (using excitatory output as its input) inhPSP.step(t_step); // Step inhibitory post-synaptic stdp.step(t_step); // Step STDP stdp.updateWeights(inputLayer.output, excitatory_neurons.output); // Update STDP weights updateDisplays(t_step, inputDisplay, exDisplay, stdp, excitatory_neurons); // This will update the interactive displays const numFires = excitatory_neurons.output.filter((val) => val > 0).length; // Number of neurons that fired in this timestep numFiresForRound += numFires; // Total number of neurons that have fired since this digit has been displayed if(numFiresForRound > 5) { // If enough neurons have fired... inputLayer.canAdvance = true; // Then tell the input layer we can advance to the next digit } } }31:Tcdb,class STDPWeights { constructor(numPre, numPost, tau_plus = 0.03, tau_minus = 0.03, a_plus = 0.08, a_minus = 0.088, g_min = 0, g_max = 1) { this.numPre = numPre; this.numPost = numPost; this.tau_plus = tau_plus; this.tau_minus = tau_minus; this.x = times(numPre, 0); // An array with numPre zeros this.y = times(numPost, 0); // An array with numPost zeros this.a_plus = a_plus; this.a_minus = a_minus; this.g_min = g_min; this.g_max = g_max; this.w = times2d(numPre, numPost, () => randomBetween(this.g_min, 10 * this.g_max/numPre)); // A 2-D array; numPre x numPost random values } updateWeights(preOutputs, postOutputs) { const preSpikeIndices = getIndicesGreaterThan0(preOutputs); // Indices of pre-synaptic spiking neurons const postSpikeIndices = getIndicesGreaterThan0(postOutputs); // Indices of poast-synaptic spiking neurons // Increment x for spiking pre-synaptic neurons preSpikeIndices.forEach((ps_idx) => { this.x[ps_idx] += this.a_plus; }); // Increment y for spiking poast-synaptic neurons postSpikeIndices.forEach((ps_idx) => { this.y[ps_idx] -= this.a_minus; }); const alpha_g = this.g_max - this.g_min; // Scaling factor for weight updates // Loop over the *index* of every pre-synaptic neuron that spiked preSpikeIndices.forEach((ps_idx) => { // And for every post-synaptic neuron connected to this pre-synaptic neuron, update // the connection weight by the `y` value for that post-synaptic neuron for(let i = 0; i this.g_max) { this.w[ps_idx][i] = this.g_max; } // if greater than g_max, set to g_max } }); // Loop over the *index* of every post-synaptic neuron that spiked postSpikeIndices.forEach((ps_idx) => { // And for every pre-synaptic neuron connected to this post-synaptic neuron, update // the connection weight by the `x` value for that pre-synaptic neuron for(let i = 0; i this.g_max) { this.w[i][ps_idx] = this.g_max; } // if greater than g_max, set to g_max } }); return this.w; } step(dt) { // Loop through each value of this.x and decay for(let i = 0; i 0); this.state = 'initializing'; this.nextInputSwitchTime = -1; } async updatePixelsAndLabel() { const [digitPixels, digitLabel] = (await this.dataGenerator.next()).value; this.digitPixels = digitPixels; } async startShowingNumber(t) { await this.updatePixelsAndLabel(); this.state = 'number'; this.nextInputSwitchTime = t + SHOW_NUM_TIME; this.canAdvance = false; this.currentMaxFiringRate = this.DEFAULT_MAX_FIRING_RATE; if(this.onAdvance) { this.onAdvance(); } } startShowingBlank(t) { this.digitPixels = _.times(DIGIT_SIZE, () => 0); this.state = 'blank'; this.nextInputSwitchTime = t + SHOW_BLANK_TIME; } increaseNumberIntensity(t) { this.nextInputSwitchTime = t + SHOW_NUM_TIME; this.currentMaxFiringRate += MAX_RATE_INCREASE_INCREMENT; } async step(dt, t) { if(this.state === 'initializing') { await this.startShowingNumber(t); } else if(t >= this.nextInputSwitchTime) { if(this.state === 'number') { if(this.canAdvance) { this.startShowingBlank(t); } else { this.increaseNumberIntensity(t); } } else { await this.startShowingNumber(t); } } this.digitPixels.forEach((intensity, i) => { const firingProbability = dt * (this.MIN_FIRING_RATE + (this.currentMaxFiringRate - this.MIN_FIRING_RATE) * (intensity - this.DATA_MIN_VAL) / (this.DATA_MAX_VAL - this.DATA_MIN_VAL)); const fires = Math.random() < firingProbability; if(fires) { this.output[i] = 1/dt; } else { this.output[i] = 0; } }); return this.output; } static testData = FileAttachment("test-14x14-chunked.zip").zip() static trainData = FileAttachment("train-14x14-chunked.zip").zip() static getTrainTestData = async function*(train_test='train') { const zipFile = await (train_test === 'trian' ? DigitInput.trainData : DigitInput.testData); const {files, N} = await zipFile.file('index.json').json('string'); let exNum = 0; for (const file of files) { const {images, labels} = await zipFile.file(file).json(); for(let i = 0; i= n) { return null; } const generator = DigitInput.getTrainTestData(train_test); for(let i = 0; i {\n const [x, y] = idx2Coordinates(index, DIGIT_HEIGHT, DIGIT_WIDTH);\n return { x, y, value };\n }), {\n x: 'x',\n y: 'y',\n fill: 'value'\n }),\n Plot.text(randomImage.map((value, index) => {\n const [x, y] = idx2Coordinates(index, DIGIT_HEIGHT, DIGIT_WIDTH);\n return { x, y, value };\n }), {\n x: 'x',\n y: 'y',\n text: 'value',\n fill: 'blue'\n })\n ]\n})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":270,"value":"Looking at this, we can see that it is a ${randomLabel} (maybe...the digit is random so I can't say how legible it is). But we're going to train an SNN that can do this classification for us. First, we need to convert our data into spikes, which we covered in [a previous tutorial](https://observablehq.com/d/5436a9da323e2530?collection=@soney/neuromorphic-computing#cell-193):","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":293,"value":"$2e","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":319,"value":"The input to our network is going to be a random digit (like the one above) from the training set \"displayed\" for ${SHOW_NUM_TIME} seconds, followed by a blank image for ${SHOW_BLANK_TIME} seconds, and then repeating with the next image for every image in our training set. We defined [a `DigitInput` class](https://observablehq.com/d/01f7c541e3f547f2?collection=@soney/neuromorphic-computing#DigitInput) to represent the digit input (you do not need to read the code). It follows from our previous code on representing numbers but has some more logic for changing the digits over time.\n\nWe will use a decaying post-synaptic potential function, as implemented in [a previous notebook](https://observablehq.com/d/3c638d3aaf9207b4) between the input and the excitatory neurons.\n\n```JavaScript\n// Create the input and post-synaptic potential for the input\nconst inputLayer = new DigitInput();\nconst inputPSP = new PSP(inputLayer, 0.1);\n```","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":352,"value":"This input will then be fed to a layer of [adaptive LIF neurons](https://observablehq.com/d/9f9286d1e917416a) through [STDP-weighted](https://observablehq.com/d/a6571460fd755600) connections. We are going to call this layer the \"excitatory\" layer.\n\n```JavaScript\n// STDP-learned weights between input and excitatory layer\nconst stdp = new STDPWeights(DIGIT_SIZE, NUM_NEURONS);\n```\n\nLet's start by defining the adaptive LIF neurons (using the same definition from before). We will then create an array of ${NUM_NEURONS} and put them into the variable `excitatory_neurons`. Later on, we will increase this number but we're keeping it at ${NUM_NEURONS} to maintain decent performance without needing to [scale our code](https://observablehq.com/d/230c2d0cdb5ff809).\n\n```JavaScript\n// Create the excitatory neurons and post-synaptic potential for them\nconst excitatory_neurons = new NeuronCollection(() => new ALIF, NUM_NEURONS);\nconst exPSP = new PSP(excitatory_neurons, 0.2);\n```","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":1090,"value":"$2f","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":1244,"value":"The image below (from [[1]](https://www.frontiersin.org/articles/10.3389/fncom.2015.00099/full)) captures this architecture.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":1240,"value":"mnist_stdp = FileAttachment(\"mnist_stdp.png\").image()","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1239,"value":"In order make sure that *some* neuron is responding, we also specify that we can only advance to the next digit if at least *5* excitatory neurons have fired while showing the digit. If not, then we increase the digit's intensity (by upping the maximum firing rate by ${MAX_RATE_INCREASE_INCREMENT} and showing that digit for another ${SHOW_NUM_TIME} seconds).\n\nYou can see our network running below. At the top is the input. Below that is a ${NUM_NEURON_ROWS} x ${NUM_NEURON_COLS} grid representing all ${NUM_NEURONS} neurons. Inside each neuron display is the *weights* associated with each input. When the neuron fires, a red border will appear. As it fires more, its firing threshold increases (because it is an ALIF). As the firing threshold gets higher (making it more difficult to trigger the neuron), a black border will appear around the neuron.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":462,"value":"svg1 = DOM.svg(INP_DISPLAY_PIXEL_SIZE * DIGIT_WIDTH, INP_DISPLAY_PIXEL_SIZE * DIGIT_HEIGHT);","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":731,"value":"weights_svg = DOM.svg(EX_MARGIN * 2 + (EX_PIXEL_SIZE + EX_PADDING) * NUM_NEURON_COLS * DIGIT_WIDTH, EX_MARGIN * 2 + (EX_PIXEL_SIZE + EX_PADDING) * NUM_NEURON_ROWS * DIGIT_HEIGHT);","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1110,"value":"It takes a while but if you wait, you can start to see the \"imprint\" of the input appearing on the weights for a given neuron. Note that we've scaled down this example (both the inputs and the number of neurons) so the digits might not be as clear as they would be in a full simulation. It also takes a long time to train, so the weights will be incomplete. However, in the next notebook, we will pre-supply a larger model and execute it.\n\nYou can see the code that we run in each simulation step below:","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":515,"value":"$30","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1226,"value":"In [the paper \"Unsupervised learning of digit recognition using spike-timing-dependent plasticity\"](https://doi.org/10.3389/fncom.2015.00099), there is an additional labeling step (where we analyze each neuron to determine which digit it represents) and testing step (to determine the accuracy). With 6,400 neurons (rather than our ${NUM_NEURONS}) and 28 x 28 inputs (rather than our ${DIGIT_WIDTH} x ${DIGIT_HEIGHT}), they achieve an accuracy of 95%. However, we are going to skip these steps (implementation is similar to what we did above) and stick to a smaller network that can run more quickly in the browser.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":1257,"value":"# Summary\n\n- We created a network that can recognize digits from the MNIST dataset\n- Our network uses primitives that we learned in prior notebooks: LIFs, ALIFs, STDP, and PSPs\n- The STDP weights, which we learn over time, encode the digits being recognized\n- Our network is a scaled down version of the one implemented by Diehl and Cook [1]","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":1221,"value":"# References\n\n- This notebook (mostly) follows the paper: Diehl, Peter U., and Matthew Cook. \"Unsupervised learning of digit recognition using spike-timing-dependent plasticity.\" Frontiers in computational neuroscience 9 (2015): 99.: [https://doi.org/10.3389/fncom.2015.00099]","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":1081,"value":"---","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":1173,"value":"ALIF_INC = 5","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":359,"value":"class ALIF {\n constructor(tau_rc=0.2, v_init=0, tau_ref=0.002, v_th=1, tau_inh = 1000, inc_inh = ALIF_INC) {\n this.tau_rc = tau_rc;\n this.tau_ref = tau_ref;\n this.v = v_init;\n this.v_th = v_th;\n \n this.output = 0;\n this.refractory_time = 0;\n\n this.inh = 0;\n this.tau_inh = tau_inh;\n this.inc_inh = inc_inh;\n }\n\n step(I, t_step) {\n this.refractory_time -= t_step; // Subtract the amount of time thhat passed from our refractory time\n \n if(this.refractory_time < 0) { // If we aren't in our refractory period, update the voltage\n this.v = this.v * (1 - t_step/this.tau_rc) + (I * t_step / this.tau_rc);\n }\n this.inh = this.inh * (1 - t_step/this.tau_inh);\n\n if(this.v >= this.v_th + this.inh) {\n this.inh += this.inc_inh;\n this.refractory_time = this.tau_ref; // Set refractory time\n\n this.output = 1 / t_step; // Fire\n this.v = 0; // Reset potential\n } else {\n this.output = 0; // Don't fire\n }\n return this.output;\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":375,"value":"class LIF {\n constructor(tau_rc=0.2, v_init=0, tau_ref=0.002, v_th=1){\n this.tau_rc = tau_rc;\n this.tau_ref = tau_ref;\n this.v = v_init;\n this.v_th = v_th;\n \n this.output = 0;\n this.refractory_time = 0;\n }\n\n step(I, t_step) {\n this.refractory_time -= t_step; // Subtract the amount of time thhat passed from our refractory time\n \n if(this.refractory_time < 0) { // If we aren't in our refractory period, update the voltage\n this.v = this.v * (1 - t_step/this.tau_rc) + (I * t_step / this.tau_rc);\n }\n\n if(this.v >= this.v_th) { // Fired\n this.refractory_time = this.tau_ref; // Set refractory time\n\n this.output = 1 / t_step; // Fire\n this.v = 0; // Reset potential\n } else {\n this.output = 0; // Don't fire\n }\n return this.output;\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":994,"value":"NUM_NEURON_ROWS = 4","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":996,"value":"NUM_NEURON_COLS = 4","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":362,"value":"NUM_NEURONS = NUM_NEURON_ROWS * NUM_NEURON_COLS;","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":284,"value":"SHOW_NUM_TIME = 0.35;","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":286,"value":"SHOW_BLANK_TIME = 0.15;","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":295,"value":"function idx2Coordinates(idx, rows, cols) {\n const col = idx % cols;\n const row = Math.floor(idx / rows);\n return [col, row];\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":297,"value":"DIGIT_WIDTH = 14","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":299,"value":"DIGIT_HEIGHT = DIGIT_WIDTH","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1003,"value":"DIGIT_SIZE = DIGIT_WIDTH * DIGIT_HEIGHT","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1196,"value":"updateDisplays = {\n const inpColor = d3.scaleLinear().range([\"white\", \"black\", \"red\"]).domain([0, 30, 100]);\n const wcolor = d3.scaleLinear().range([\"white\", \"black\"]).domain([0, 1]);\n const exFiringOpacity = d3.scaleLinear().range([0, 1]).domain([0, 10]);\n const exThreshColor = d3.scaleLinear().range([\"white\", \"black\"]).domain([0, 50]);\n return function updateDisplays(t_step, inputDisplay, exDisplay, stdp, excitatory_neurons) {\n inputDisplay.step(t_step).forEach((displayVal, i) => {\n rectangles1[i].style('fill', inpColor(displayVal));\n });\n exDisplay.step(t_step).forEach((displayVal, i) => {\n firing_rectangles1[i].style('stroke-opacity', exFiringOpacity(displayVal));\n thresh_rectangles1[i].style('stroke', exThreshColor(excitatory_neurons.neurons[i].inh));\n });\n stdp.w.forEach((weights, i) => {\n weights.forEach((w, j) => {\n w_rectangles1[i][j].style('fill', wcolor(w));\n });\n });\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":634,"value":"MAX_RATE_INCREASE_INCREMENT = 16","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":702,"value":"$31","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":705,"value":"function getIndicesGreaterThan0(arr) {\n return arr.map((_, index) => index).filter((index) => arr[index] > 0);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":707,"value":"function times2d(n1, n2, funcVal) {\n const result = [];\n const func = (typeof funcVal === 'function') ? funcVal : (() => funcVal);\n\n for(let i = 0; i funcVal);\n\n for(let i = 0; i neuron.output); // Assign our output to be a list of neuron outputs\n }\n\n step(inputs, t_step) {\n // Step every individual neuron\n // Assign this.output to the neurons' outputs\n // Return this.output\n return this.output = this.neurons.map((neuron, i) => neuron.step(inputs[i], t_step));\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":727,"value":"class PSP {\n constructor(collection, tau) {\n this.collection = collection; // NeuronCollection instance\n this.tau = tau; // time constant for decay\n this.output = this.collection.output.map(o => o); // Use the collection's output (but make a clone so we don't mutate the original)\n }\n\n step(t_step) {\n // Loop through my output, decay it, and add the output from the incoming collection.\n for(let i = 0; i accum + val, 0);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":854,"value":"function addArrays(l1, l2) {\n return l1.map((v, i) => v + l2[i]);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":929,"value":"function mulArray(l, by) {\n return l.map((v) => by*v);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1168,"value":"function negArray(l) {\n return mulArray(l, -1);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":991,"value":"INP_DISPLAY_PIXEL_SIZE = 30","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1009,"value":"EX_MARGIN = 5","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1011,"value":"EX_PIXEL_SIZE = 12","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1018,"value":"EX_PADDING = 2","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":323,"value":"rectangles1 = times(DIGIT_SIZE, (idx) => {\n const [x, y] = idx2Coordinates(idx, DIGIT_HEIGHT, DIGIT_WIDTH);\n const rect = d3.select(svg1).append('rect')\n .attr('x', x * INP_DISPLAY_PIXEL_SIZE)\n .attr('y', y * INP_DISPLAY_PIXEL_SIZE)\n .attr('width', INP_DISPLAY_PIXEL_SIZE)\n .attr('height', INP_DISPLAY_PIXEL_SIZE)\n .style('fill', 'none');\n return rect;\n });","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":955,"value":"thresh_rectangles1 = times(NUM_NEURONS, (neuronIdx) => {\n const [neuronX, neuronY] = idx2Coordinates(neuronIdx, NUM_NEURON_ROWS, NUM_NEURON_COLS);\n\n const x = neuronX * (DIGIT_WIDTH + EX_PADDING);\n const y = neuronY * (DIGIT_HEIGHT + EX_PADDING);\n const rect = d3.select(weights_svg).append('rect')\n .attr('x', x * EX_PIXEL_SIZE + EX_MARGIN)\n .attr('y', y * EX_PIXEL_SIZE + EX_MARGIN)\n .attr('width', EX_PIXEL_SIZE * DIGIT_WIDTH)\n .attr('height', EX_PIXEL_SIZE * DIGIT_HEIGHT)\n .style('fill', 'none')\n .style('stroke', 'blue');\n return rect;\n });","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":950,"value":"firing_rectangles1 = times(NUM_NEURONS, (neuronIdx) => {\n const [neuronX, neuronY] = idx2Coordinates(neuronIdx, NUM_NEURON_ROWS, NUM_NEURON_COLS);\n\n const x = neuronX * (DIGIT_WIDTH + EX_PADDING);\n const y = neuronY * (DIGIT_HEIGHT + EX_PADDING);\n const rect = d3.select(weights_svg).append('rect')\n .attr('x', x * EX_PIXEL_SIZE + EX_MARGIN)\n .attr('y', y * EX_PIXEL_SIZE + EX_MARGIN)\n .attr('width', EX_PIXEL_SIZE * DIGIT_WIDTH)\n .attr('height', EX_PIXEL_SIZE * DIGIT_HEIGHT)\n .style('fill', 'none')\n .style('stroke', 'red')\n .style('stroke-width', '5')\n // .style('stroke-dasharray', 4)\n .style('stroke-opacity', 0.5);\n return rect;\n })","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":734,"value":"w_rectangles1 = times(DIGIT_SIZE, (inputIdx) => {\n const [inpX, inpY] = idx2Coordinates(inputIdx, DIGIT_HEIGHT, DIGIT_WIDTH);\n return _.times(NUM_NEURONS, (neuronIdx) => {\n const [neuronX, neuronY] = idx2Coordinates(neuronIdx, NUM_NEURON_ROWS, NUM_NEURON_COLS);\n \n const x = neuronX * (DIGIT_WIDTH + EX_PADDING) + inpX;\n const y = neuronY * (DIGIT_HEIGHT + EX_PADDING) + inpY;\n const rect = d3.select(weights_svg).append('rect')\n .attr('x', x * EX_PIXEL_SIZE + EX_MARGIN)\n .attr('y', y * EX_PIXEL_SIZE + EX_MARGIN)\n .attr('width', EX_PIXEL_SIZE)\n .attr('height', EX_PIXEL_SIZE)\n .style('fill', 'none');\n return rect;\n });\n });","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":784,"value":"$32","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":445,"value":"{\n const delta_t = 0.01;\n let stepNum = 0;\n async function doUpdate() {\n const t = delta_t * stepNum;\n await step(delta_t, t);\n stepNum++;\n setTimeout(doUpdate, delta_t * 1000);\n }\n doUpdate();\n return 'Running';\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"}],"files":"$W33","stdlib":"1","titling":"auto"}} 2d:"$2c:body" 28:E{"digest":"NEXT_REDIRECT;replace;/@soney/nmc-digit-recognition-1;307;"}