-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathindex.html
526 lines (451 loc) · 53.8 KB
/
index.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
<html><head><meta content="chrome=1" http-equiv="X-UA-Compatible" /><meta charset="utf-8" /><meta content="width=device-width, initial-scale=1, user-scalable=no" name="viewport" /><title>clortex</title><style>body {
padding:50px;
font:14px/1.5 Helvetica, Arial, sans-serif;
color:#777;
font-weight:300;
}
h1, h2, h3, h4, h5, h6 {
color:#222;
margin:0 0 20px;
}
p, ul, ol, table, pre, dl {
margin:0 0 20px;
}
h1, h2, h3 {
line-height:1.1;
}
h1 {
font-size:28px;
}
h2 {
color:#393939;
}
h4, h5, h6 {
color:#494949;
margin:0;
}
header h4{
margin: 10 0 0 0px;
}
a {
color:#39c;
font-weight:400;
text-decoration:none;
}
a small {
font-size:11px;
color:#777;
margin-top:-0.6em;
display:block;
}
.wrapper {
width:860px;
margin:0 auto;
}
.figure div.img {
text-align: center;
border-radius: 5px;
border: 1px solid #ddd;
padding: 10px;
}
blockquote {
border-left:1px solid #e5e5e5;
margin:0;
padding:0 0 0 20px;
font-style:italic;
}
code, pre {
font-family:Monaco, Bitstream Vera Sans Mono, Lucida Console, Terminal;
color:#333;
font-size:12px;
}
pre {
padding:8px 15px;
background: #f8f8f8;
border-radius:5px;
border:1px solid #e5e5e5;
overflow-x: auto;
}
table {
width:100%;
border-collapse:collapse;
}
th, td {
text-align:left;
padding:5px 10px;
border-bottom:1px solid #e5e5e5;
}
dt {
color:#444;
font-weight:700;
}
th {
color:#444;
}
img {
max-width:100%;
}
header {
width:270px;
float:left;
/*position:fixed;*/
}
header ul {
list-style:none;
height:40px;
padding:0;
background: #eee;
background: -moz-linear-gradient(top, #f8f8f8 0%, #dddddd 100%);
background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#f8f8f8), color-stop(100%,#dddddd));
background: -webkit-linear-gradient(top, #f8f8f8 0%,#dddddd 100%);
background: -o-linear-gradient(top, #f8f8f8 0%,#dddddd 100%);
background: -ms-linear-gradient(top, #f8f8f8 0%,#dddddd 100%);
background: linear-gradient(top, #f8f8f8 0%,#dddddd 100%);
border-radius:5px;
border:1px solid #d2d2d2;
box-shadow:inset #fff 0 1px 0, inset rgba(0,0,0,0.03) 0 -1px 0;
width:270px;
}
header li {
width:89px;
float:left;
border-right:1px solid #d2d2d2;
height:40px;
}
header ul a {
line-height:1;
font-size:11px;
color:#999;
display:block;
text-align:center;
padding-top:6px;
height:40px;
}
strong {
font-weight:700;
}
header ul li + li {
width:88px;
border-left:1px solid #fff;
}
header ul li + li + li {
border-right:none;
width:89px;
}
header ul a strong {
font-size:14px;
display:block;
color:#222;
}
section {
width: 60%;
float:right;
padding-bottom:50px;
padding-right: 10%;
}
small {
font-size:11px;
}
hr {
border:0;
background:#e5e5e5;
height:1px;
margin:0 0 20px;
}
footer {
width:270px;
float:left;
position:fixed;
bottom:50px;
}
header div.heading {
display:none;
}
@media print, screen and (max-width: 960px) {
div.wrapper {
width:auto;
margin:0;
}
header, section, footer {
float:none;
position:static;
width:auto;
}
header div.heading {
display:block;
}
section div.heading {
display:none;
}
section {
border:1px solid #e5e5e5;
border-width:1px 0;
padding:20px 0;
margin:0 0 20px;
}
header a small {
display:inline;
}
header ul {
position:absolute;
right:50px;
top:52px;
}
}
@media print, screen and (max-width: 720px) {
body {
word-wrap:break-word;
}
header {
padding:0;
}
header ul, header p.view {
position:static;
}
pre, code {
word-wrap:normal;
}
}
@media print, screen and (max-width: 480px) {
body {
padding:15px;
}
header ul {
display:none;
}
}
@media print {
body {
padding:0.4in;
font-size:12pt;
color:#444;
}
}
.highlight { background: #ffffff; }
.highlight .c { color: #999988; font-style: italic } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { font-weight: bold } /* Keyword */
.highlight .o { font-weight: bold } /* Operator */
.highlight .cm { color: #999988; font-style: italic } /* Comment.Multiline */
.highlight .cp { color: #999999; font-weight: bold } /* Comment.Preproc */
.highlight .c1 { color: #999988; font-style: italic } /* Comment.Single */
.highlight .cs { color: #999999; font-weight: bold; font-style: italic } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .gd .x { color: #000000; background-color: #ffaaaa } /* Generic.Deleted.Specific */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #999999 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .gi .x { color: #000000; background-color: #aaffaa } /* Generic.Inserted.Specific */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #800080; font-weight: bold; } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { font-weight: bold } /* Keyword.Constant */
.highlight .kd { font-weight: bold } /* Keyword.Declaration */
.highlight .kn { font-weight: bold } /* Keyword.Namespace */
.highlight .kp { font-weight: bold } /* Keyword.Pseudo */
.highlight .kr { font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #445588; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #009999 } /* Literal.Number */
.highlight .s { color: #d14 } /* Literal.String */
.highlight .na { color: #008080 } /* Name.Attribute */
.highlight .nb { color: #0086B3 } /* Name.Builtin */
.highlight .nc { color: #445588; font-weight: bold } /* Name.Class */
.highlight .no { color: #008080 } /* Name.Constant */
.highlight .ni { color: #800080 } /* Name.Entity */
.highlight .ne { color: #990000; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #990000; font-weight: bold } /* Name.Function */
.highlight .nn { color: #555555 } /* Name.Namespace */
.highlight .nt { color: #000080 } /* Name.Tag */
.highlight .nv { color: #008080 } /* Name.Variable */
.highlight .ow { font-weight: bold } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mf { color: #009999 } /* Literal.Number.Float */
.highlight .mh { color: #009999 } /* Literal.Number.Hex */
.highlight .mi { color: #009999 } /* Literal.Number.Integer */
.highlight .mo { color: #009999 } /* Literal.Number.Oct */
.highlight .sb { color: #d14 } /* Literal.String.Backtick */
.highlight .sc { color: #d14 } /* Literal.String.Char */
.highlight .sd { color: #d14 } /* Literal.String.Doc */
.highlight .s2 { color: #d14 } /* Literal.String.Double */
.highlight .se { color: #d14 } /* Literal.String.Escape */
.highlight .sh { color: #d14 } /* Literal.String.Heredoc */
.highlight .si { color: #d14 } /* Literal.String.Interpol */
.highlight .sx { color: #d14 } /* Literal.String.Other */
.highlight .sr { color: #009926 } /* Literal.String.Regex */
.highlight .s1 { color: #d14 } /* Literal.String.Single */
.highlight .ss { color: #990073 } /* Literal.String.Symbol */
.highlight .bp { color: #999999 } /* Name.Builtin.Pseudo */
.highlight .vc { color: #008080 } /* Name.Variable.Class */
.highlight .vg { color: #008080 } /* Name.Variable.Global */
.highlight .vi { color: #008080 } /* Name.Variable.Instance */
.highlight .il { color: #009999 } /* Literal.Number.Integer.Long */
.type-csharp .highlight .k { color: #0000FF }
.type-csharp .highlight .kt { color: #0000FF }
.type-csharp .highlight .nf { color: #000000; font-weight: normal }
.type-csharp .highlight .nc { color: #2B91AF }
.type-csharp .highlight .nn { color: #000000 }
.type-csharp .highlight .s { color: #A31515 }
.type-csharp .highlight .sc { color: #A31515 }
</style></head><body><header><div class="heading"><h1>clortex</h1><h3>Clojure Library for Jeff Hawkins' Hierarchical Temporal Memory</h3><hr /><div class="info"><h5>Author: Fergal Byrne<b> <a href="mailto:[email protected]">([email protected])</a></b></h5><h5>Library: v0.1.1-SNAPSHOT</h5><h5>Date: 18 July 2014</h5><h5>Website: <a href="https://github.com/fergalbyrne/clortex">https://github.com/fergalbyrne/clortex</a></h5><h5>Generated By: <a href="http://www.github.com/zcaudate/lein-midje-doc">MidjeDoc</a></h5></div><br /><hr /></div><h4><a href="#introduction">1 Introduction</a></h4><h5> <i><a href="#background">1.1 Background</a></i></h5><h4><a href="#requirements">2 Requirements</a></h4><h5> <i><a href="#directly-analogous-to-htm/cla-theory">2.1 Directly Analogous to HTM/CLA Theory</a></i></h5><h5> <i><a href="#transparently-understandable-implementation-in-source-code">2.2 Transparently Understandable Implementation in Source Code</a></i></h5><h5> <i><a href="#directly-observable-data">2.3 Directly Observable Data</a></i></h5><h5> <i><a href="#sufficiently-performant">2.4 Sufficiently Performant</a></i></h5><h5> <i><a href="#useful-metrics">2.5 Useful Metrics</a></i></h5><h5> <i><a href="#appropriate-platform">2.6 Appropriate Platform</a></i></h5><h4><a href="#system-architecture">3 System Architecture</a></h4><h4><a href="#sensors">4 Sensors</a></h4><h5> <i><a href="#numenta-opf-sensor-(csv-data)">4.1 Numenta OPF Sensor (CSV data)</a></i></h5><h5> <i><a href="#opf-date-parsing">4.1.1 OPF Date Parsing</a></i></h5><h4><a href="#encoders">5 Encoders</a></h4><h5> <i><a href="#simple-scalar-encoder">5.1 Simple Scalar Encoder</a></i></h5><h5> <i><a href="#category/string-encoder">5.2 Category/String Encoder</a></i></h5><h5> <i><a href="#todo">5.3 TODO</a></i></h5><h4><a href="#data-structures-and-functions">6 Data Structures and Functions</a></h4><h5> <i><a href="#neuron">6.1 Neuron</a></i></h5><h5> <i><a href="#synapse">6.2 Synapse</a></i></h5><h5> <i><a href="#axon">6.3 Axon</a></i></h5><h5> <i><a href="#dendrite">6.4 Dendrite</a></i></h5><h5> <i><a href="#column">6.5 Column</a></i></h5><h5> <i><a href="#patch">6.6 Patch</a></i></h5><h4><a href="#license">7 License</a></h4><br /></header><section><div class="heading"><h1>clortex</h1><h3>Clojure Library for Jeff Hawkins' Hierarchical Temporal Memory</h3><hr /><div class="info"><h5>Author: Fergal Byrne<b> <a href="mailto:[email protected]">([email protected])</a></b></h5><h5>Library: v0.1.1-SNAPSHOT</h5><h5>Date: 18 July 2014</h5><h5>Website: <a href="https://github.com/fergalbyrne/clortex">https://github.com/fergalbyrne/clortex</a></h5><h5>Generated By: <a href="http://www.github.com/zcaudate/lein-midje-doc">MidjeDoc</a></h5></div><br /><hr /></div><div><a name="introduction"></a><h2><b>1 Introduction</b></h2></div><div><a name="background"></a><h3>1.1 Background</h3></div><div><p><strong>Hierarchical Temporal Memory</strong> (<em>HTM</em>) is a theory of the neocortex developed by Jeff Hawkins in the early-mid 2000's. HTM explains the working of the neocortex as a hierarchy of <strong>regions</strong>, each of which performs a similar algorithm. The algorithm performed in each region is known in the theory as the <strong>Cortical Learning Algorithm</strong> (<em>CLA</em>).</p><p>Clortex is a reimagining and reimplementation of Numenta Platfrom for Intelligent Computing (NuPIC), which is also an Open Source project released by Grok Solutions (formerly Numenta), the company founded by Jeff to make his theories a practical and commercial reality. NuPIC is a mature, excellent and useful software platform, with a vibrant community, so please join us at <a href='http://numenta.org'>Numenta.org</a>.</p><p><strong>Warning: pre-alpha software</strong>. This project is only beginning, and everything you see here will eventually be thrown away as we develop better ways to do things. The design and the APIs are subject to drastic change without a moment's notice.</p><p>Clortex is Open Source software, released under the GPL Version 3 (see the end of the README). You are free to use, copy, modify, and redistribute this software according to the terms of that license. For commercial use of the algorithms used in Clortex, please contact <a href='http://groksolutions.com'>Grok Solutions</a>, where they'll be happy to discuss commercial licensing.</p></div><div><a name="requirements"></a><h2><b>2 Requirements</b></h2></div><div><a name="directly-analogous-to-htm/cla-theory"></a><h3>2.1 Directly Analogous to HTM/CLA Theory</h3></div><div><p><em>In order to be a platform for demonstration, exploration and experimentation of Jeff Hawkins' theories, the system must at all levels of relevant detail match the theory directly (ie 1:1). Any optimisations introduced may only occur following an effectively mathematical proof that this correspondence is maintained under the change.</em></p><p>There are several benefits to this requirement. Firstly, during development, this requirement provides a rigid and testable constraint on the options for implementation. With a good model of the theory in his mind, we may proceed with confidence to use transparently analogous data structures and algorithms, leaving the question of computational performance for a later day.</p><p>Secondly, this requirement will ensure that the system at its heart remains a working implementation of the theory as it develops. In addition, because of this property, it will be directly usable by Jeff and any co-workers (including us) in extending and experimenting with new ideas in the theoretical space. This will enhance support for the new project, and encourage the HTM community to consider the new project as a parallel or alternative way to realise their own goals.</p><p>Thirdly, the software will provide a runnable explanation of the theory, real working code (see next requirement) replacing the pseudocode and providing live imagery instead of diagrams (see later requirement).</p><p>Lastly, we feel that the theory deserves software of similar quality, and that this has slowed the realisation of the goals of all concerned. The development of a true analogue in software will pave the way for a rapid expansion in interest in the entire project. In particular, this will benefit anyone seeking to exploit the commercial advantages which the CLA offers.</p></div><div><a name="transparently-understandable-implementation-in-source-code"></a><h3>2.2 Transparently Understandable Implementation in Source Code</h3></div><div><p><em>All source code must at all times be readable by a non-developer. This can only be achieved if a person familiar with the theory and the models (but not a trained programmer) can read any part of the source code and understand precisely what it is doing and how it is implementing the algorithms.</em></p><p>This requirement is again deliberately very stringent, and requires the utmost discipline on the part of the developers of the software. Again, there are several benefits to this requirement.</p><p>Firstly, the extreme constraint forces the programmer to work in the model of the domain rather than in the model of the software. This constraint, by being adhered to over the lifecycle of the project, will ensure that the only complexity introduced in the software comes solely from the domain. Any other complexity introduced by the design or programming is known as incidental complexity and is the cause of most problems in software.</p><p>Secondly, this constraint provides a mechanism for verifying the first requirement. Any expert in the theory must be able to inspect the code for an aspect of the system and verify that it is transparently analogous to the theory.</p><p>Thirdly, anyone wishing to extend or enhance the software will be presented with no introduced obstacles, leaving only their level of understanding of the workings of the theory.</p><p>Finally, any bugs in the software should be reduced to breaches of this requirement, or alternatively, bugs in the theory.</p></div><div><a name="directly-observable-data"></a><h3>2.3 Directly Observable Data</h3></div><div><p><em>All relevant data structures representing the computational model must be directly observable and measurable at all times. A user must be able to inspect all this data and if required, present it in visual form.</em></p><p>This requirement ensures that the user of the platform can see what theyâre doing at all times. The software is essentially performing a simulation of a simplified version of the neocortex as specified in the CLA, and the user must be able to directly observe how this simulation is progressing and how her choices in configuring the system might affect the computation.</p><p>The benefits of this requirement should be reasonably obvious. Two in particular: first, during development, a direct visual confirmation of the results of changes is a powerful tool; and secondly, this answers much of the representation problem, as it allows an observer to directly see how the models in the theory work, rather than relying on analogy.</p></div><div><a name="sufficiently-performant"></a><h3>2.4 Sufficiently Performant</h3></div><div><p><em>The system must have performance sufficient to provide for rapid development of configurations suitable to a user task. In addition, the performance on large or complex data sets must be sufficient to establish that the system is succeeding in its task in principle, and that simply by scaling or optimising it can perform at âproductionâ levels.</em></p><p>What this says is that the system must be a working prototype for how a more finely tuned or higher-performance equivalent will perform. Compute power and memory are cheap, and software can always be made faster relatively easily. The question a user has when using the system is primarily whether or not (and how well) the system can solve her problem, not whether it takes a few seconds or a few hours.</p><p>This constraint requires that the software infrastructure be designed so as to allow for significant raw performance improvements, both by algorithm upgrades and also by using concurrency and distribution when the user has the resources to scale the system.</p></div><div><a name="useful-metrics"></a><h3>2.5 Useful Metrics</h3></div><div><p><em>The system must include functionality which allows the user to assess the effectiveness of configuration choices on the system at all relevant levels.</em></p><p>At present, NuPIC has some metrics but they are either difficult to understand and interpret, inappropriate, or both. The above requirement must be answered using metrics which have yet to be devised, so we have no further detail at this stage.</p></div><div><a name="appropriate-platform"></a><h3>2.6 Appropriate Platform</h3></div><div><p><em>The development language(s) and runtime platform must ensure ease of deployment, robust execution, easy maintenance and operation, reliability, extensibility, use in new contexts, portability, interoperability, and scaleable performance.</em></p><p>Quite a list, but each failure in the list reduces the potential mindshare of the software and raises fears for new adopters. Success in every item, along with the other requirements, ensures maximal usefulness and easy uptake by the rising ramp of the adoption curve.</p></div><div><a name="system-architecture"></a><h2><b>3 System Architecture</b></h2></div><div><p>In order to mirror the HTM/CLA theory, <code>clortex</code> has a system architecture which is based on loosely-coupled components communicating over simple channels (or queues).</p><p>The primary dataflow in <code>clortex</code> involves 'enervation' data structures passing from <em>sources</em>, through a possible hierarchy of <em>regions</em> and flowing to a set of <em>sinks</em>.</p><p>Enervation, or inter-region communication, is encoded as a simple <strong>SDR</strong> map, which contains some very basic self-description data (<code>source</code>, <code>bit-size</code>, <code>description</code>, <code>type</code> etc) and a list of <code>on-bits</code>, <code>changed-on</code> and <code>changed-off</code> bit indices.</p><p>An SDR may also contain a channel which can be used to send the source (or an intermediary) data.</p></div><div><div class="highlight"><pre><span class="p">(</span><span class="k">def </span><span class="nv">an-sdr</span> <span class="p">{</span><span class="ss">:source</span> <span class="s">"a-uuid"</span>,
<span class="ss">:description</span> <span class="s">"an example SDR"</span>,
<span class="ss">:type</span> <span class="ss">:scalar-encoding</span>,
<span class="ss">:bit-size</span> <span class="mi">512</span>,
<span class="ss">:topology</span> <span class="p">[</span><span class="mi">512</span><span class="p">]</span>,
<span class="ss">:on-bits</span> <span class="o">#</span><span class="p">{</span><span class="mi">3</span>, <span class="mi">22</span>, <span class="mi">31</span>, <span class="mi">55</span>, <span class="mi">138</span><span class="p">}</span>,
<span class="ss">:changed-on</span> <span class="o">#</span><span class="p">{</span><span class="mi">22</span>, <span class="mi">31</span>, <span class="mi">138</span><span class="p">}</span>,
<span class="ss">:changed-off</span> <span class="o">#</span><span class="p">{</span><span class="mi">6</span>, <span class="mi">111</span>, <span class="mi">220</span><span class="p">}</span>,
<span class="p">})</span>
</pre></div>
</div><div><a name="sensors"></a><h2><b>4 Sensors</b></h2></div><div><p>Sensors gather information from the world and deliver it in encoded form to the CLA.</p></div><div><a name="numenta-opf-sensor-(csv-data)"></a><h3>4.1 Numenta OPF Sensor (CSV data)</h3></div><div><p>The first sensor in <code>clortex</code> reads CSV data which is compatible with Numenta's OPF (Online Prediction Framework) software. </p></div><div><div class="highlight"><pre><span class="nv">gym</span>,<span class="nv">address</span>,<span class="nv">timestamp</span>,<span class="nv">consumption</span>
<span class="nv">string</span>,<span class="nv">string</span>,<span class="nv">datetime</span>,<span class="nv">float</span>
<span class="nv">S</span>,,<span class="nv">T</span>,
<span class="nv">Balgowlah</span> <span class="nv">Platinum</span>,<span class="nv">Shop</span> <span class="mi">67</span> <span class="mi">197-215</span> <span class="nv">Condamine</span> <span class="nv">Street</span> <span class="nv">Balgowlah</span> <span class="mi">2093</span>,<span class="mi">2010-07-02</span> <span class="mi">00</span><span class="ss">:00:00.0</span>,<span class="mf">5.3</span>
<span class="nv">Balgowlah</span> <span class="nv">Platinum</span>,<span class="nv">Shop</span> <span class="mi">67</span> <span class="mi">197-215</span> <span class="nv">Condamine</span> <span class="nv">Street</span> <span class="nv">Balgowlah</span> <span class="mi">2093</span>,<span class="mi">2010-07-02</span> <span class="mi">00</span><span class="ss">:15:00.0</span>,<span class="mf">5.5</span>
<span class="nv">Balgowlah</span> <span class="nv">Platinum</span>,<span class="nv">Shop</span> <span class="mi">67</span> <span class="mi">197-215</span> <span class="nv">Condamine</span> <span class="nv">Street</span> <span class="nv">Balgowlah</span> <span class="mi">2093</span>,<span class="mi">2010-07-02</span> <span class="mi">00</span><span class="ss">:30:00.0</span>,<span class="mf">5.1</span>
<span class="nv">Balgowlah</span> <span class="nv">Platinum</span>,<span class="nv">Shop</span> <span class="mi">67</span> <span class="mi">197-215</span> <span class="nv">Condamine</span> <span class="nv">Street</span> <span class="nv">Balgowlah</span> <span class="mi">2093</span>,<span class="mi">2010-07-02</span> <span class="mi">00</span><span class="ss">:45:00.0</span>,<span class="mf">5.3</span>
</pre></div>
</div><div><p>The first line lists the field names for the data in the file. These field names are referenced elsewhere when specifying the field(s) which need to be predicted, or the encoders to use for that field. The second line describes the type fo each field (in Python terms). The third line is OPF-specific. <code>S</code> (referring to the <code>gym</code> field) indicates that this field, when it changes, indicates a new <strong>sequence</strong> of data records. The <code>T</code> (for the <code>timestamp</code> field) indicates that this field is to be treated as time-series data. These two concepts are important in powering the CLA's sequence learning.</p></div><div><a name="opf-date-parsing"></a><h3><i>4.1.1 OPF Date Parsing</i></h3></div><div><div class="highlight"><pre><span class="p">(</span><span class="nb">str </span><span class="p">(</span><span class="nf">parse-opf-date</span> <span class="s">"2010-07-02 08:15:00.01"</span><span class="p">))</span> <span class="nv">=></span> <span class="s">"2010-07-02T08:15:00.010Z"</span>
</pre></div>
</div><div><div class="highlight"><pre><span class="s">"after loading the hotgym data, it has 87840 items"</span>
<span class="p">(</span><span class="k">def </span><span class="nv">hotgym-config</span> <span class="p">{</span><span class="ss">:file</span> <span class="s">"resources/hotgym.csv"</span>
<span class="ss">:read-n-records</span> <span class="ss">:all</span>
<span class="ss">:fields</span> <span class="p">[</span><span class="s">"gym"</span> <span class="p">{</span><span class="ss">:type</span> <span class="ss">:string</span>
<span class="ss">:doc</span> <span class="s">"Name of this Gym"</span>
<span class="ss">:encoder</span> <span class="p">{</span><span class="ss">:type</span> <span class="ss">:hash-encoder</span>
<span class="ss">:bits</span> <span class="mi">32</span>
<span class="ss">:on</span> <span class="mi">8</span><span class="p">}</span>
<span class="ss">:sequence-flag?</span> <span class="nv">true</span><span class="p">}</span>
<span class="s">"address"</span> <span class="p">{</span><span class="ss">:type</span> <span class="ss">:string</span>
<span class="ss">:doc</span> <span class="s">"Address of this Gym"</span>
<span class="ss">:encoder</span> <span class="p">{</span><span class="ss">:type</span> <span class="ss">:hash-encoder</span>
<span class="ss">:bits</span> <span class="mi">32</span>
<span class="ss">:on</span> <span class="mi">8</span><span class="p">}}</span>
<span class="s">"timestamp"</span> <span class="p">{</span><span class="ss">:type</span> <span class="ss">:datetime</span>
<span class="ss">:doc</span> <span class="s">"Timestamp of this data record"</span>
<span class="ss">:subencode</span> <span class="p">[{</span><span class="ss">:field</span> <span class="ss">:day-of-year</span><span class="p">}</span>
<span class="p">{</span><span class="ss">:field</span> <span class="ss">:day-of-week</span><span class="p">}</span>
<span class="p">{</span><span class="ss">:field</span> <span class="ss">:time-of-day</span><span class="p">}</span>
<span class="p">{</span><span class="ss">:field</span> <span class="ss">:weekday?</span><span class="p">}]}</span>
<span class="p">]})</span>
<span class="p">(</span><span class="k">def </span><span class="nv">hotgym</span> <span class="p">(</span><span class="nf">load-opf-file</span> <span class="nv">hotgym-config</span><span class="p">))</span>
<span class="p">(</span><span class="nb">count </span><span class="p">(</span><span class="ss">:parsed-data</span> <span class="nv">hotgym</span><span class="p">))</span> <span class="nv">=></span> <span class="mi">87840</span>
<span class="p">(</span><span class="nf">mapv</span> <span class="p">(</span><span class="nb">comp str </span><span class="nv">first</span><span class="p">)</span> <span class="p">(</span><span class="nb">nth </span><span class="p">(</span><span class="ss">:parsed-data</span> <span class="nv">hotgym</span><span class="p">)</span> <span class="mi">10</span><span class="p">))</span> <span class="nv">=></span>
<span class="p">[</span><span class="s">"Balgowlah Platinum"</span> <span class="s">"Shop 67 197-215 Condamine Street Balgowlah 2093"</span> <span class="s">"2010-07-02T02:30:00.000Z"</span> <span class="s">"1.2"</span><span class="p">]</span>
<span class="p">(</span><span class="k">def </span><span class="nv">encs</span> <span class="p">(</span><span class="ss">:encoders</span> <span class="nv">hotgym</span><span class="p">))</span>
<span class="p">(</span><span class="k">def </span><span class="nv">enc-10</span> <span class="p">(</span><span class="nf">data-encode</span> <span class="nv">hotgym</span> <span class="mi">10</span><span class="p">))</span>
<span class="p">(</span><span class="k">def </span><span class="nv">enc-11</span> <span class="p">(</span><span class="nf">data-encode</span> <span class="nv">hotgym</span> <span class="mi">11</span><span class="p">))</span>
<span class="p">(</span><span class="k">def </span><span class="nv">enc-30</span> <span class="p">(</span><span class="nf">data-encode</span> <span class="nv">hotgym</span> <span class="mi">30</span><span class="p">))</span>
<span class="nv">enc-10</span> <span class="nv">=></span> <span class="o">#</span><span class="p">{</span><span class="mi">8</span> <span class="mi">12</span> <span class="mi">13</span> <span class="mi">14</span> <span class="mi">15</span>
<span class="mi">42</span> <span class="mi">46</span> <span class="mi">56</span> <span class="mi">64</span> <span class="mi">71</span> <span class="mi">80</span> <span class="mi">85</span> <span class="mi">88</span>
<span class="mi">96</span> <span class="mi">99</span> <span class="mi">101</span> <span class="mi">102</span> <span class="mi">104</span> <span class="mi">118</span> <span class="mi">123</span> <span class="mi">124</span> <span class="mi">130</span> <span class="mi">136</span> <span class="mi">141</span> <span class="mi">145</span> <span class="mi">163</span>
<span class="mi">175</span> <span class="mi">176</span> <span class="mi">189</span> <span class="mi">191</span> <span class="mi">201</span> <span class="mi">204</span> <span class="mi">209</span> <span class="mi">210</span> <span class="mi">221</span> <span class="mi">229</span> <span class="mi">230</span> <span class="mi">236</span>
<span class="mi">237</span> <span class="mi">239</span> <span class="mi">242</span> <span class="mi">246</span> <span class="mi">287</span> <span class="mi">288</span> <span class="mi">289</span> <span class="mi">290</span> <span class="mi">291</span> <span class="mi">292</span> <span class="mi">293</span> <span class="mi">294</span>
<span class="mi">295</span> <span class="mi">296</span> <span class="mi">297</span> <span class="mi">298</span> <span class="mi">299</span> <span class="mi">300</span> <span class="mi">301</span> <span class="mi">302</span> <span class="mi">303</span> <span class="mi">304</span> <span class="mi">305</span> <span class="mi">306</span>
<span class="mi">307</span> <span class="mi">429</span> <span class="mi">430</span> <span class="mi">431</span> <span class="mi">432</span> <span class="mi">433</span> <span class="mi">434</span> <span class="mi">435</span> <span class="mi">436</span> <span class="mi">437</span> <span class="mi">438</span> <span class="mi">439</span>
<span class="mi">440</span> <span class="mi">441</span> <span class="mi">442</span> <span class="mi">443</span> <span class="mi">444</span> <span class="mi">445</span> <span class="mi">446</span> <span class="mi">447</span> <span class="mi">448</span> <span class="mi">449</span> <span class="mi">1348</span> <span class="mi">1349</span>
<span class="mi">1350</span> <span class="mi">1357</span> <span class="mi">1359</span> <span class="mi">1360</span> <span class="mi">1367</span> <span class="mi">1375</span> <span class="mi">1383</span> <span class="mi">1393</span> <span class="mi">1394</span> <span class="mi">1395</span>
<span class="mi">1401</span> <span class="mi">1414</span> <span class="mi">1425</span> <span class="mi">1440</span> <span class="mi">1443</span> <span class="mi">1450</span> <span class="mi">1453</span> <span class="mi">1462</span> <span class="mi">1466</span><span class="p">}</span>
<span class="p">(</span><span class="nb">difference </span><span class="nv">enc-10</span> <span class="nv">enc-11</span><span class="p">)</span> <span class="nv">=></span> <span class="o">#</span><span class="p">{</span><span class="mi">429</span> <span class="mi">430</span> <span class="mi">431</span> <span class="mi">432</span> <span class="mi">433</span> <span class="mi">434</span> <span class="mi">435</span> <span class="mi">436</span> <span class="mi">437</span> <span class="mi">438</span><span class="p">}</span>
<span class="p">(</span><span class="nb">difference </span><span class="nv">enc-10</span> <span class="nv">enc-30</span><span class="p">)</span> <span class="nv">=></span> <span class="o">#</span><span class="p">{</span><span class="mi">429</span> <span class="mi">430</span> <span class="mi">431</span> <span class="mi">432</span> <span class="mi">433</span> <span class="mi">434</span> <span class="mi">435</span> <span class="mi">436</span> <span class="mi">437</span> <span class="mi">438</span>
<span class="mi">439</span> <span class="mi">440</span> <span class="mi">441</span> <span class="mi">442</span> <span class="mi">443</span> <span class="mi">444</span> <span class="mi">445</span> <span class="mi">446</span> <span class="mi">447</span> <span class="mi">448</span> <span class="mi">449</span>
<span class="mi">1348</span> <span class="mi">1349</span> <span class="mi">1350</span> <span class="mi">1359</span> <span class="mi">1360</span> <span class="mi">1375</span> <span class="mi">1383</span> <span class="mi">1393</span> <span class="mi">1394</span>
<span class="mi">1395</span> <span class="mi">1401</span> <span class="mi">1414</span> <span class="mi">1425</span> <span class="mi">1440</span> <span class="mi">1443</span> <span class="mi">1462</span> <span class="mi">1466</span><span class="p">}</span>
</pre></div>
</div><div><div class="highlight"><pre><span class="o">#</span><span class="nv">_</span><span class="p">(</span><span class="nf">write-edn-file</span> <span class="nv">hotgym</span> <span class="s">"resources/hotgym.edn"</span><span class="p">)</span>
</pre></div>
</div><div><a name="encoders"></a><h2><b>5 Encoders</b></h2></div><div><p>Encoders are very important in <code>clortex</code>. Encoders turn real-world data into a form which <code>clortex</code> can understand - <strong>Sparse Distrubuted Representations</strong> (or <em>SDRs</em>). Encoders for the human brain include retinal cells (or groups of them), as well as cells in the ear, skin, tongue and nose.</p></div><div><a name="simple-scalar-encoder"></a><h3>5.1 Simple Scalar Encoder</h3></div><div><p>Encoders convert input data values into bit-array representations (compatible with Sparse Distributed Representations). The simplest encoder converts a scalar value into a bit-array as seen below. We'll set up a very small scalar encoder with 4 bits on out of 12, so we can see how it works (<a href='#sse-def'>e.5.1</a>).</p></div><div><a name="sse-def"></a><h4><i>e.5.1 - a very simple scalar encoder</i></h4><div class="highlight"><pre><span class="p">(</span><span class="k">def </span><span class="nv">enc</span> <span class="p">(</span><span class="nf">s/scalar-encoder</span> <span class="ss">:bits</span> <span class="mi">12</span> <span class="ss">:on</span> <span class="mi">4</span><span class="p">))</span> <span class="c1">; uses default params min 0.0, max 100.0</span>
</pre></div>
</div><div><p><code>scalar-encoder</code> returns a map of functions which can be used in various parts of the encoding of data. We'll define those functions by pulling them out of the map (<a href='#sse-use'>e.5.2</a>):</p></div><div><a name="sse-use"></a><h4><i>e.5.2 - pulling out the functions</i></h4><div class="highlight"><pre><span class="p">(</span><span class="k">def </span><span class="nv">sencode</span> <span class="p">(</span><span class="ss">:encode</span> <span class="nv">enc</span><span class="p">))</span>
<span class="p">(</span><span class="k">def </span><span class="nv">sencoders</span> <span class="p">(</span><span class="ss">:encoders</span> <span class="nv">enc</span><span class="p">))</span>
<span class="p">(</span><span class="k">def </span><span class="nv">sencode-all</span> <span class="p">(</span><span class="ss">:encode-all</span> <span class="nv">enc</span><span class="p">))</span>
<span class="p">(</span><span class="k">def </span><span class="nv">encoder-record</span> <span class="p">(</span><span class="nf">s/->ScalarEncoder</span> <span class="s">"field"</span> <span class="mi">12</span> <span class="mi">4</span> <span class="mf">0.0</span> <span class="mf">100.0</span> <span class="nv">sencoders</span> <span class="nv">sencode</span><span class="p">))</span>
<span class="p">(</span><span class="k">def </span><span class="nv">sencode</span> <span class="p">(</span><span class="nf">.encode</span> <span class="nv">encoder-record</span><span class="p">))</span>
</pre></div>
</div><div><p>Let's check that the bottom and top values give the bottom and top SDRs:</p></div><div><div class="highlight"><pre><span class="p">(</span><span class="nf">sencode</span> <span class="mi">0</span><span class="p">)</span> <span class="nv">=></span> <span class="o">#</span><span class="p">{</span><span class="mi">0</span> <span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span><span class="p">}</span>
<span class="p">(</span><span class="nf">sencode</span> <span class="mi">100</span><span class="p">)</span> <span class="nv">=></span> <span class="o">#</span><span class="p">{</span><span class="mi">8</span> <span class="mi">9</span> <span class="mi">10</span> <span class="mi">11</span><span class="p">}</span>
<span class="p">(</span><span class="nf">sencode-all</span> <span class="mi">0</span><span class="p">)</span> <span class="nv">=></span>
<span class="p">[[</span><span class="mi">0</span> <span class="nv">true</span><span class="p">]</span> <span class="p">[</span><span class="mi">1</span> <span class="nv">true</span><span class="p">]</span> <span class="p">[</span> <span class="mi">2</span> <span class="nv">true</span><span class="p">]</span> <span class="p">[</span> <span class="mi">3</span> <span class="nv">true</span><span class="p">]</span>
<span class="p">[</span><span class="mi">4</span> <span class="nv">false</span><span class="p">]</span> <span class="p">[</span><span class="mi">5</span> <span class="nv">false</span><span class="p">]</span> <span class="p">[</span> <span class="mi">6</span> <span class="nv">false</span><span class="p">]</span> <span class="p">[</span> <span class="mi">7</span> <span class="nv">false</span><span class="p">]</span>
<span class="p">[</span><span class="mi">8</span> <span class="nv">false</span><span class="p">]</span> <span class="p">[</span><span class="mi">9</span> <span class="nv">false</span><span class="p">]</span> <span class="p">[</span><span class="mi">10</span> <span class="nv">false</span><span class="p">]</span> <span class="p">[</span><span class="mi">11</span> <span class="nv">false</span><span class="p">]]</span>
</pre></div>
</div><div><p><code>scalar-encoder</code> defaults to NuPIC's scalar encoder parameters:</p></div><div><a name="sse-default"></a><h4><i>e.5.3 - default 21/127 bit encoder</i></h4><div class="highlight"><pre><span class="p">(</span><span class="k">def </span><span class="nv">enc</span> <span class="p">(</span><span class="nf">s/scalar-encoder</span><span class="p">))</span> <span class="c1">; uses default params 127 bits, 21 on, min 0.0, max 100.0</span>
<span class="p">(</span><span class="k">def </span><span class="nv">sencode</span> <span class="p">(</span><span class="ss">:encode</span> <span class="nv">enc</span><span class="p">))</span>
</pre></div>
</div><div><div class="highlight"><pre><span class="p">(</span><span class="nf">sencode</span> <span class="mi">0</span><span class="p">)</span> <span class="nv">=></span>
<span class="o">#</span><span class="p">{</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span> <span class="mi">5</span> <span class="mi">6</span>
<span class="mi">7</span> <span class="mi">8</span> <span class="mi">9</span> <span class="mi">10</span> <span class="mi">11</span> <span class="mi">12</span> <span class="mi">13</span>
<span class="mi">14</span> <span class="mi">15</span> <span class="mi">16</span> <span class="mi">17</span> <span class="mi">18</span> <span class="mi">19</span> <span class="mi">20</span><span class="p">}</span>
<span class="p">(</span><span class="nb">count </span><span class="p">(</span><span class="nf">sencode</span> <span class="mi">0</span><span class="p">))</span> <span class="nv">=></span> <span class="mi">21</span>
<span class="p">(</span><span class="nf">sencode</span> <span class="mi">50</span><span class="p">)</span> <span class="nv">=></span>
<span class="o">#</span><span class="p">{</span><span class="mi">53</span> <span class="mi">54</span> <span class="mi">55</span> <span class="mi">56</span> <span class="mi">57</span> <span class="mi">58</span> <span class="mi">59</span>
<span class="mi">60</span> <span class="mi">61</span> <span class="mi">62</span> <span class="mi">63</span> <span class="mi">64</span> <span class="mi">65</span> <span class="mi">66</span>
<span class="mi">67</span> <span class="mi">68</span> <span class="mi">69</span> <span class="mi">70</span> <span class="mi">71</span> <span class="mi">72</span> <span class="mi">73</span><span class="p">}</span>
<span class="p">(</span><span class="nb">count </span><span class="p">(</span><span class="nf">sencode</span> <span class="mi">50</span><span class="p">))</span> <span class="nv">=></span> <span class="mi">21</span>
<span class="p">(</span><span class="nf">sencode</span> <span class="mi">100</span><span class="p">)</span> <span class="nv">=></span>
<span class="o">#</span><span class="p">{</span><span class="mi">106</span> <span class="mi">107</span> <span class="mi">108</span> <span class="mi">109</span> <span class="mi">110</span> <span class="mi">111</span> <span class="mi">112</span>
<span class="mi">113</span> <span class="mi">114</span> <span class="mi">115</span> <span class="mi">116</span> <span class="mi">117</span> <span class="mi">118</span> <span class="mi">119</span>
<span class="mi">120</span> <span class="mi">121</span> <span class="mi">122</span> <span class="mi">123</span> <span class="mi">124</span> <span class="mi">125</span> <span class="mi">126</span><span class="p">}</span>
</pre></div>
</div><div><a name="category/string-encoder"></a><h3>5.2 Category/String Encoder</h3></div><div><p>We need to map arbitrary categories or string descriptors to bit encodings. Using the SHA1 message digest, we generate a list of 20 deterministically-generated bytes (this ensures the encoding will be consistent), which we use to fill the bit array until the required number of bits is set.</p></div><div><a name="simple-hash-encoder"></a><div class="highlight"><pre><span class="p">(</span><span class="k">def </span><span class="nv">enc</span> <span class="p">(</span><span class="nf">h/hash-encoder</span> <span class="ss">:bits</span> <span class="mi">12</span> <span class="ss">:on</span> <span class="mi">4</span><span class="p">))</span>
<span class="p">(</span><span class="k">def </span><span class="nv">cencode</span> <span class="p">(</span><span class="ss">:encode</span> <span class="nv">enc</span><span class="p">))</span>
<span class="p">(</span><span class="k">def </span><span class="nv">cencode-all</span> <span class="p">(</span><span class="ss">:encode-all</span> <span class="nv">enc</span><span class="p">))</span>
<span class="p">(</span><span class="nf">cencode</span> <span class="s">"test"</span><span class="p">)</span> <span class="nv">=></span> <span class="o">#</span><span class="p">{</span><span class="mi">0</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">8</span><span class="p">}</span>
<span class="p">(</span><span class="nf">cencode</span> <span class="s">"another test"</span><span class="p">)</span> <span class="nv">=></span> <span class="o">#</span><span class="p">{</span><span class="mi">2</span> <span class="mi">4</span> <span class="mi">6</span> <span class="mi">11</span><span class="p">}</span>
<span class="p">(</span><span class="nf">cencode-all</span> <span class="s">"test"</span><span class="p">)</span> <span class="nv">=></span>
<span class="p">[[</span><span class="mi">0</span> <span class="nv">true</span><span class="p">]</span> <span class="p">[</span><span class="mi">1</span> <span class="nv">false</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span> <span class="nv">true</span><span class="p">]</span>
<span class="p">[</span><span class="mi">3</span> <span class="nv">true</span><span class="p">]</span> <span class="p">[</span><span class="mi">4</span> <span class="nv">false</span><span class="p">]</span> <span class="p">[</span><span class="mi">5</span> <span class="nv">false</span><span class="p">]</span>
<span class="p">[</span><span class="mi">6</span> <span class="nv">false</span><span class="p">]</span> <span class="p">[</span><span class="mi">7</span> <span class="nv">false</span><span class="p">]</span> <span class="p">[</span><span class="mi">8</span> <span class="nv">true</span><span class="p">]</span>
<span class="p">[</span><span class="mi">9</span> <span class="nv">false</span><span class="p">]</span> <span class="p">[</span><span class="mi">10</span> <span class="nv">false</span><span class="p">]</span> <span class="p">[</span><span class="mi">11</span> <span class="nv">false</span><span class="p">]]</span>
</pre></div>
</div><div><a name="todo"></a><h3>5.3 TODO</h3></div><div><p><ul><li>build a timestamp encoder</li><li>build an adaptive scalar encoder</li></ul></div><div><a name="data-structures-and-functions"></a><h2><b>6 Data Structures and Functions</b></h2></div><div><p>The design of <code>clortex</code> is based on large, homogenous, passive data structures (e.g. Layers) which are collections of simple structures (e.g. Neurons, Dendrites and Synapses), along with a set of simple functions which act on these data structures (e.g. <code>(cla/predictive? a-neuron)</code>).</p></div><div><a name="neuron"></a><h3>6.1 Neuron</h3></div><div><p><em>Neurons</em> in <code>clortex</code> are represented as a map as follows:</p></div><div><div class="highlight"><pre><span class="p">(</span><span class="k">def </span><span class="nv">a-neuron</span> <span class="p">{</span><span class="ss">:active</span> <span class="mi">0</span>,
<span class="ss">:activation-potential</span> <span class="mi">0</span>,
<span class="ss">:feedforward-potential</span> <span class="mi">0</span>,
<span class="ss">:predictive</span> <span class="mi">0</span>,
<span class="ss">:predictive-potential</span> <span class="mi">0</span>,
<span class="ss">:proximal-dendrite</span> <span class="p">[</span><span class="o">#</span><span class="nv">_</span><span class="p">[</span><span class="nv">synapse</span> <span class="nv">...</span><span class="p">]]</span>,
<span class="ss">:distal-dendrites</span> <span class="p">[</span><span class="o">#</span><span class="nv">_</span><span class="p">[</span><span class="nv">dendrite...</span><span class="p">]]</span>,
<span class="ss">:axon</span> <span class="nv">nil</span>
<span class="p">})</span>
</pre></div>
</div><div><p>Neurons with <code>:active</code> are designated as <strong>active</strong> neurons. Active neurons represent the layer's SDR, and also will send their signals to downstream neurons for prediction.</p></div><div><p>Simple functions act on neurons, such as <code>predictive?</code>, defined as follows:</p></div><div><div class="highlight"><pre><span class="p">(</span><span class="kd">defn </span><span class="nv">predictive?</span>
<span class="s">"checks if a neuron is in the predictive state"</span>
<span class="p">[</span><span class="nv">neuron</span><span class="p">]</span>
<span class="p">(</span><span class="nb">pos? </span><span class="p">(</span><span class="ss">:predictive</span> <span class="nv">neuron</span><span class="p">)))</span>
<span class="p">(</span><span class="kd">defn </span><span class="nv">set-predictive</span>
<span class="s">"sets a neuron's predictive state"</span>
<span class="p">[</span><span class="nv">neuron</span> <span class="nv">p</span><span class="p">]</span>
<span class="p">(</span><span class="nf">assoc-in</span> <span class="nv">neuron</span> <span class="p">[</span><span class="ss">:predictive</span><span class="p">]</span> <span class="nv">p</span><span class="p">))</span>
</pre></div>
</div><div><p>and used like this:</p></div><div><p>neurons have simple predictive states</p></div><div><div class="highlight"><pre><span class="p">(</span><span class="nf">predictive?</span> <span class="nv">a-neuron</span><span class="p">)</span>
<span class="nv">=></span> <span class="nv">false</span>
</pre></div>
</div><div><div class="highlight"><pre><span class="p">(</span><span class="nf">predictive?</span> <span class="p">(</span><span class="nf">set-predictive</span> <span class="nv">a-neuron</span> <span class="mi">1</span><span class="p">))</span>
<span class="nv">=></span> <span class="nv">true</span>
</pre></div>
</div><div><a name="synapse"></a><h3>6.2 Synapse</h3></div><div><p>Synapses represent connections between neurons.</p></div><div><a name="axon"></a><h3>6.3 Axon</h3></div><div><p>Axons represent the terminal points of interneural connections. Patches (see below) maintain a set of axon endpoints to provide feedforward inputs from sensors or lower patches, as well as for in-patch predictive connections. Axons have a <code>source</code> and an <code>activity</code> value. Incoming SDR's are translated into values on the axon collection of a patch.</p><p></p></div><div><a name="dendrite"></a><h3>6.4 Dendrite</h3></div><div><p>A dendrite is a set of synapses. Dendrites can either be <em>proximal</em> (meaning <em>near</em>) or <em>distal</em> (meaning <em>far</em>). Each neuron usually has one proximal dendrite, which gathers signals from feedforward sources, and many distal dendrites, which gather predictive signal, usually from nearby active neurons.</p></div><div><a name="column"></a><h3>6.5 Column</h3></div><div><p>A column is a vector of neurons, representing the vertical organisation of neurns in the neocortex. Columns share the same set of potential feedforward inputs, and also identify the spatial location of the neurons in a layer or region.</p></div><div><a name="patch"></a><h3>6.6 Patch</h3></div><div><p>A Patch is a container for neurons and their connections (synapses). A patch is the system component which links to others and manages incoming and outgoing data, as well as the transformation of the memory in the synapses.</p><p>Patches are responsible for translating a pattern of activity on a set of inputs into the appropriate changes in the neurons.</p></div><div><a name="license"></a><h2><b>7 License</b></h2></div><div><p>Copyright &copy; 2014 Fergal Byrne, Brenter IT</p><p>Distributed under the GPLv3 or (at your option) any later version.</p></div></section></body><script type="text/javascript">var metas = document.getElementsByTagName('meta');
var i;
if (navigator.userAgent.match(/iPhone/i)) {
for (i=0; i<metas.length; i++) {
if (metas[i].name == "viewport") {
metas[i].content = "width=device-width, minimum-scale=1.0, maximum-scale=1.0";
}
}
document.addEventListener("gesturestart", gestureStart, false);
}
function gestureStart() {
for (i=0; i<metas.length; i++) {
if (metas[i].name == "viewport") {
metas[i].content = "width=device-width, minimum-scale=0.25, maximum-scale=1.6";
}
}
}</script><script>var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-44409012-2']);
_gaq.push(['_trackPageview']);
(function() {
var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
})();</script></html>