2a:null 2b:["$","title",null,{"children":"Translating Data to Spikes | Steve Oney | Observable"}] 30:T5ca,This works but it has a few drawbacks. First, if we want regular spiking intervals then we need to have some notion of state in order to track if we should fire at a given timestep or not. Second, it does not contain any noise. Noise can help improve the robustness of our systems (and make them more realistic) by (1) ensuring that the system is recognizing common underlying patterns rather than overfitting to specific examples and (2) making sure it is more tolerant to errors and noisier inputs. Instead, it is common to use Poisson processes to represent these data probablistically. ## Probabilistic Firing We want to have a **probability** of firing that will likely result in firing rate ${tex`f_s(x)`}. Like before, suppose we want to represent scalar ${tex`x`} with firing rate ${tex`f_s(x) = f_{min} + \frac{x-x_{min}}{x_{max}-x_{min}}(f_{max}-f_{min})`}. To do this, we want to have a probability of ${tex`f_s(x)`} of firing every second. This means that in a discrete simulation with timesteps ${tex`T_{step}`}, we should have a probability of firing as ${tex`f_s(x) T_{step}`} on every timestep: ${tex`Pr(fire) = T_{step}(f_{min} + \frac{x-x_{min}}{x_{max}-x_{min}}(f_{max}-f_{min}))`} ...then given a number of spikes ${tex`s`} over time ${tex`T_{step}`}, our frequency is ${tex`\frac{s}{T_{step}}`} and we can estimate our value by solving for ${tex`\hat{x}`}: ${tex`\hat{x} = \frac{\frac{s}{T_{step}}-f_{min}}{f_{max}-f_{min}}(x_{max} - x_{min}) + x_{min}`}31:T9fd,digitPixels = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 84, 185, 159, 151, 60, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 222, 254, 254, 254, 254, 241, 198, 198, 198, 198, 198, 198, 198, 198, 170, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 114, 72, 114, 163, 227, 254, 225, 254, 254, 254, 250, 229, 254, 254, 140, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 66, 14, 67, 67, 67, 59, 21, 236, 254, 106, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 83, 253, 209, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 233, 255, 83, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 129, 254, 238, 44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 59, 249, 254, 62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 133, 254, 187, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 205, 248, 58, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 126, 254, 182, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 75, 251, 240, 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 221, 254, 166, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 203, 254, 219, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 38, 254, 254, 77, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, 224, 254, 115, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 133, 254, 254, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 61, 242, 254, 254, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 121, 254, 254, 219, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 121, 254, 207, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];32:T57a,{ const DATA_MIN_VAL = 0; const DATA_MAX_VAL = 255; const MIN_FIRING_RATE = min_rate; const MAX_FIRING_RATE = 1; const tau = 0.8; const delta_t = 0.001; const PIXEL_SIZE = 12; const svg = DOM.svg(PIXEL_SIZE * DIGIT_WIDTH, PIXEL_SIZE * DIGIT_HEIGHT); const color = d3.scaleLinear().range(["white", "black", "red"]).domain([0, 0.1/delta_t, 1/delta_t]); const v = digitPixels.map(_ => 0); const rectangles = digitPixels.map((intensity, idx) => { const [x, y] = idx2Coordinates(idx); 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; }33:[] 2e:{"id":"5436a9da323e2530","slug":"nmc-translating-data-to-spikes","title":"Translating Data to Spikes","thumbnail":"490876dafaf8c7d0c988d1db119691f55f696b27bd414fa0f9a5331933373a10","access_level":"public","create_time":"$D2022-10-24T16:30:01.767Z","update_time":"$D2024-07-10T01:17:24.353Z","view_time":null,"first_public_time":"$D2023-01-24T15:22:07.535Z","fork":false,"stars":0,"starred":false,"owner":{"type":"team","id":"55b87b37da07de37","login":"soney","name":"Steve Oney","avatar_url":"https://avatars-next.observableusercontent.com/565926373d73cf99aa6425cf7c0d7ff79e41635d1a367894a5e3bce0299b18b9","tier":"starter_2024"},"version":596,"publish_version":null,"role":null,"authored":false,"authors":[{"type":"individual","id":"1d138075b46297f1","login":"soney","name":"Steve Oney","avatar_url":"https://avatars-next.observableusercontent.com/565926373d73cf99aa6425cf7c0d7ff79e41635d1a367894a5e3bce0299b18b9","tier":null}],"members":[{"type":"individual","id":"79581e18d086caf4","login":"ericgallo","name":"","avatar_url":null,"tier":null,"role":"editor"},{"type":"individual","id":"93113dd5fb467076","login":"sharvari-bondre","name":"Sharvari Bondre","avatar_url":"https://avatars-next.observableusercontent.com/754b967a5cf1ce71589f615fed536b94bd68509f3412154d82572c4b6aa44ead","tier":null,"role":"editor"},{"type":"individual","id":"1d138075b46297f1","login":"soney","name":"Steve Oney","avatar_url":"https://avatars-next.observableusercontent.com/565926373d73cf99aa6425cf7c0d7ff79e41635d1a367894a5e3bce0299b18b9","tier":null,"role":"editor"}],"comments":[{"id":"5da1aa0c83887d12","reply_to_id":null,"content":"add more explanation for why noise can add robustness","create_time":"$D2023-01-24T17:06:31.444Z","update_time":null,"resolved":true,"user":{"type":"individual","id":"1d138075b46297f1","login":"soney","name":"Steve Oney","avatar_url":"https://avatars-next.observableusercontent.com/565926373d73cf99aa6425cf7c0d7ff79e41635d1a367894a5e3bce0299b18b9","tier":null}}],"custom_thumbnail":false,"trashed":false,"subscribed":null,"forks":0,"collection":{"id":"ceab76d8d8a0acbc","slug":"neuromorphic-computing","title":"Neuromorphic Tutorials: Spiking Neural Networks (SNNs) from Scratch","owner":{"id":"55b87b37da07de37","login":"soney","name":"Steve Oney"}},"type":"notebook","body":{"title":"Translating Data to Spikes","cells":[{"id":0,"value":"# Translating Data to Spikes","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":35,"value":"Suppose we have some data that we want to represent as spikes. Let's start with something like a scalar number. How would we translate this into spikes? We could use either **frequency** encoding (where we send information by communicating with *how often* our neuron fires) or **time** encoding (where we send information through the precise *timing* of neuron fires). **Let's focus on frequency coding**.\n\nA simple way would be to spike in proportion to the value of the number; the higher the number, the more spikes. So let's suppose we have a target number ${tex`x`} that we want to represent in spikes. If ${tex`x`} is positive, we can do this easily by translating ${tex`x`} into a **firing rate** (number of spikes per second). This would mean that we fire ${tex`x`} times per second...or once every ${tex`\\frac{1}{x}`} seconds, if ${tex`x`} is positive.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":251,"value":"viewof simple_freq = Inputs.range([0.01, 3], {value: 1, step: 0.01, label: \"freq\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":207,"value":"plotSpikes(simpleFrequencySpikes(simple_freq, 100))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":261,"value":"This works but has a few problems. First, it does not account for things like negative numbers (you can't have a negative frequency). So let's say that we assume that ${tex`x`} is in the range ${tex`[x_{min}, x_{max}]`}. We can then scale our prior value of ${tex`x`} to be ${tex`x_s`} and ensure it is in the range ${tex`[0, 1]`}: ${tex`x_s = \\frac{x-x_{min}}{x_{max}-x_{min}}`}.\n\nThen, if we want it to use frequencies outside of ${tex`[0, 1]`} (say we want frequencies in the range ${tex`[f_{min}, f_{max}]`}), we can do: ${tex`f_s(x) = f_{min} + x_s(f_{max}-f_{min}) = f_{min} + \\frac{x-x_{min}}{x_{max}-x_{min}}(f_{max}-f_{min})`}.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":279,"value":"viewof f_min1 = Inputs.range([0, 0.9], {value: 1, step: 0.01, label: \"f_min\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":281,"value":"viewof f_max1 = Inputs.range([1, 3], {value: 1, step: 0.01, label: \"f_max\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":285,"value":"viewof v_min1 = Inputs.range([-10, -1], {value: -5, step: 0.01, label: \"v_min\"})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":287,"value":"viewof v_max1 = Inputs.range([1, 10], {value: 5, step: 0.01, label: \"v_max\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":293,"value":"viewof v1 = Inputs.range([v_min1, v_max1], {value: 1, step: 0.01, label: \"v\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":296,"value":"plotSpikes(scaledFrequencySpikes(v1, 100, f_min1, f_max1, v_min1, v_max1))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":307,"value":"$30","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":335,"value":"function poissonSpikes(freq, T, dt=0.01) {\n const spikes = [];\n if(freq > 0) {\n for(let step = 0; step < T/dt; step++) {\n const t = step * dt;\n const probFire = freq * dt;\n if(Math.random() < probFire) {\n spikes.push(true);\n } else {\n spikes.push(false);\n }\n }\n }\n return spikes;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":338,"value":"function scaledPoissonSpikes(v, T, f_min, f_max, v_min, v_max, dt=0.01) {\n return poissonSpikes(f_min + (f_max - f_min)*(v - v_min)/(v_max - v_min), T, dt);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":342,"value":"viewof f_min2 = Inputs.range([0, 0.9], {value: 0, step: 0.01, label: \"f_min\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":344,"value":"viewof f_max2 = Inputs.range([1, 3], {value: 1, step: 0.01, label: \"f_max\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":349,"value":"viewof x_min2 = Inputs.range([-10, 0], {value: 0, step: 0.01, label: \"x_min\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":353,"value":"viewof x_max2 = Inputs.range([1, 10], {value: 10, step: 0.01, label: \"x_max\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":357,"value":"viewof x2 = Inputs.range([x_min2, x_max2], {value: 1, step: 0.01, label: \"x\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":364,"value":"{\n const T = 100;\n const spikes = scaledPoissonSpikes(x2, T, f_min2, f_max2, x_min2, x_max2);\n const numSpikes = spikes.filter((s) => s).length;\n const freq = numSpikes / T;\n const estimatedValue = ((freq - f_min2) / (f_max2 - f_min2))*(x_max2 - x_min2) + x_min2;\n \n return html`${plotSpikes(spikes).outerHTML}
Spikes: ${numSpikes} over ${T} seconds (${freq.toPrecision(1)} Hz). Estimated value: ${estimatedValue.toPrecision(3)} (Actual: ${x2.toPrecision(3)} / Error: ${(estimatedValue - x2).toPrecision(3)})`;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":410,"value":"Let's look at how the estimated value varies compared to the actual value when we do this. For now, we'll use the values `f_min = 0`, `f_max = 100`, `x_min = 0`, `x_max = 100`. We'll use a discrete time simulation with `Tstep = 0.01` for every step:","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":414,"value":"{\n const f_min = 0;\n const f_max = 100;\n const x_min = 0;\n const x_max = 5;\n const x_step = 0.01;\n const T = 10;\n\n const data = [];\n for(let x = x_min; x<= x_max; x += x_step) {\n const spikes = scaledPoissonSpikes(x, T, f_min, f_max, x_min, x_max);\n const numSpikes = spikes.filter((s) => s).length;\n const freq = numSpikes / T;\n const estimatedValue = ((freq - f_min) / (f_max - f_min))*(x_max - x_min) + x_min;\n data.push({x, estimatedValue});\n }\n const plot = Plot.plot({\n y: {\n grid: true,\n label: 'Estimated x'\n },\n marks: [\n Plot.line(data, {x: \"x\", y: \"estimatedValue\", stroke: 'black', strokeWidth: 1}),\n Plot.line(data, {x: \"x\", y: \"x\", stroke: 'red', strokeWidth: 1}),\n ]\n });\n return plot;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":444,"value":"We can see that our reconstructed estimates look fairly reasonable. Now let's look at what happens if we increase `f_max` to `200`:","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":446,"value":"{\n const f_min = 0;\n const f_max = 200;\n const x_min = 0;\n const x_max = 5;\n const x_step = 0.01;\n const T = 10;\n\n const data = [];\n for(let x = x_min; x <= x_max; x += x_step) {\n const spikes = scaledPoissonSpikes(x, T, f_min, f_max, x_min, x_max);\n const numSpikes = spikes.filter((s) => s).length;\n const freq = numSpikes / T;\n const estimatedValue = ((freq - f_min) / (f_max - f_min))*(x_max - x_min) + x_min;\n\n data.push({x, estimatedValue});\n }\n const plot = Plot.plot({\n y: {\n grid: true,\n label: 'Estimated x'\n },\n marks: [\n Plot.line(data, {x: \"x\", y: \"estimatedValue\", stroke: 'black', strokeWidth: 1}),\n Plot.line(data, {x: \"x\", y: \"x\", stroke: 'red', strokeWidth: 1}),\n ]\n });\n return plot;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":457,"value":"Notice how our estimate stops increasing around `x = 2.5`? This corresponds to a frequency of 100 Hz. In our discrete time simulation, we can't fire more than once every step. Given that we had a value of `Tstep = 0.01`, we can never achieve a frequency greater than ${tex`\\frac{1}{T_{step}} = 100`} since we can only fire a maximum of one time per time step.\n\nThis tells us that we need to be sure our maximum frequency is not so high that we would need multiple firings per time step for our discrete time simulation; ${tex`f_{max} \\leq \\frac{1}{T_{step}}`}.\n\nNote that Poisson processes can \"handle\" this by assuming that there might be multiple events in every step and they estimate the probability of ${tex`k`} firings as ${tex`\\frac{\\lambda{}^k}{k!}e^{-\\lambda{}}`} where ${tex`\\lambda{} = Pr(fire)`} from above.\n\nHowever, rather than allowing multiple spikes per timestep, we will just choose time-steps small enough that we can assume it's exceedingly unlikely that multiple spikes will fire per timestep.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":506,"value":"### Caveats:\n\nPoisson processes make the assumption that the likelyhood of firing at every timestep is completely independent. This isn't quite biologically realistic, because:\n\n- Neurons have a refractory period; they are less likely to fire immediately after they have just fired\n- Some neurons (like \"burst\" neurons) have special properties that make them more likely to fire in bursts.\n\nHowever, we aren't concerned about biological realism here and so will ignore these caveats. [Prior work has attempted to address them](https://www.cns.nyu.edu/~david/handouts/poisson.pdf).","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":193,"value":"# Representing 2D Images\n\nNow, suppose we have something like an image or a digit like the one below:","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":21,"value":"{\n const PIXEL_SIZE = 12;\n const svg = DOM.svg(PIXEL_SIZE * DIGIT_WIDTH, PIXEL_SIZE * DIGIT_HEIGHT);\n const color = d3.scaleLinear().range([\"white\", \"black\"]).domain([0, 255]);\n digitPixels.forEach((intensity, idx) => {\n const [x, y] = idx2Coordinates(idx);\n const rect = d3.select(svg).append('rect')\n .attr('x', x * PIXEL_SIZE)\n .attr('y', y * PIXEL_SIZE)\n .attr('width', PIXEL_SIZE)\n .attr('height', PIXEL_SIZE)\n .style('fill', color(intensity));\n });\n return svg;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":39,"value":"We can represent this as a series of pixel values from `0` (blank) to `255` (filled in), as we specify in `digitPixels` below:","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":5,"value":"$31","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":43,"value":"...we can represent this as multiple Poisson variables with firing frequencies proportional to the value.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":9,"value":"DIGIT_WIDTH = 28","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":11,"value":"DIGIT_HEIGHT = DIGIT_WIDTH","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":15,"value":"function idx2Coordinates(idx, rows=DIGIT_WIDTH, cols=DIGIT_HEIGHT) {\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":180,"value":"Modelling as a Poisson process:","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":171,"value":"$${tex`Pr(spike) = T_{step}(\\frac{d - d_{min}}{d_{max} - d_{min}} (r_{max} - r_{min}) + r_{min}`})","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":566,"value":"Here, our value for ${tex`r_{min}`}) can be thought of as the \"noise\", since it controls how often neurons in the background (the ones that are not part of the digit being represented) fire. Try modifying its value below:","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":184,"value":"viewof min_rate = Inputs.range([0, 0.8], {value: 0.003, step: 0.0001, label: \"min_rate (noise)\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":46,"value":"$32","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":572,"value":"Visually, we can see that we can make out our numeric digit from the probabilitic firing patterns. However, if we increase ${tex`r_{min}`}, the background noise makes it more difficult to discern the represented digit.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":577,"value":"# Summary\n\n- We often model data sources as Poisson processes\n- These models can represent values as probabilistic frequencies\n- If our data is ${tex`x`}, at every time step, we can have a probability of firing of ${tex`T_{step}(f_{min} + \\frac{x-x_{min}}{x_{max}-x_{min}}(f_{max}-f_{min}))`}\n - ${tex`x`} is the data we are representing\n - ${tex`x_{max}`} is the highest value we expect ${tex`x`} to have\n - ${tex`x_{min}`} is the lowest value we expect ${tex`x`} to have\n - ${tex`T_{step}`} is the size of our timestep\n - ${tex`f_{min}`} is the minimum desired firing frequency\n - ${tex`f_{max}`} is the maximum desired firing frequency\n- We can represent 2D images as a neuron group where each neuron represents a different pixel in the image","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":586,"value":"# References\n\n- The Neuromatch Academy has [a helpful overview of the Poisson distribution](https://compneuro.neuromatch.io/tutorials/W0D5_Statistics/student/W0D5_Tutorial1.html#section-2-2-poisson-distribution)\n- [This snnTorch tutorial](https://snntorch.readthedocs.io/en/latest/tutorials/tutorial_1.html) has a great overview of spike encoding","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":570,"value":"---","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":213,"value":"function simpleFrequencySpikes(freq, T, dt=0.01) {\n const spikes = [];\n if(freq > 0) {\n for(let step = 0; step < T/dt; step++) {\n const t = step * dt;\n if(t % (1/freq) <= dt + 1e-8) {\n spikes.push(true);\n } else {\n spikes.push(false);\n }\n }\n }\n return spikes;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":202,"value":"plotSpikes = {\n const width = 800;\n const height = 20;\n const padding = 5;\n function plotSpikes(spikes) {\n const svg = DOM.svg(width + 2*padding, height + 2*padding);\n const spikeScaleX = d3.scaleLinear([0, spikes.length], [padding, padding+width]);\n spikes.forEach((spike, t) => {\n if(spike) {\n const displayX = spikeScaleX(t);\n const locationIndicator = d3.select(svg).append(\"path\")\n .attr(\"stroke\", 'black')\n .attr(\"fill\", \"none\")\n .attr(\"stroke-width\", 2)\n .attr(\"d\", `M${displayX},${padding}v${height}`);\n }\n });\n return svg;\n }\n \n return plotSpikes;\n} ","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":276,"value":"function scaledFrequencySpikes(v, T, f_min, f_max, v_min, v_max, dt=0.01) {\n return simpleFrequencySpikes(f_min + (f_max - f_min)*(v - v_min)/(v_max - v_min), T, dt);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"}],"files":"$W33","stdlib":"1","titling":"auto"}} 2f:"$2e:body"