numenta / htmresearch Goto Github PK

Experimental algorithms. Unsupported.

License: GNU Affero General Public License v3.0

Shell 0.10% Python 13.61% C++ 0.19% Makefile 0.01% C# 0.17% JavaScript 0.91% R 0.01% Jupyter Notebook 84.08% MATLAB 0.49% HTML 0.07% Cap'n Proto 0.01% TeX 0.38% Mercury 0.01%

htmresearch's People

Contributors

Stargazers

Watchers

Forkers

subutai chetan51 chagge simjega ywcui1990 koimotion yihuang rhyolight breznak sambitgaan retopara scottpurdy r0k3 ryanjmccall epaxon plexzhang marionleborgne boltzmannbrain pombreda rtvt123 akhilaananthram tomsilver luisandresilva neuroidss oztc dioptre lscheinkman saganbolliger arhik mrcslws fergalbyrne oxtopus victaie weaver-viii starcounter-jack rcrowder zuhaagha hernandezurbina mewbak natoromano andrewmalta13 cogmission vaua timtimt bipulroy8 hjlebbink sourceops solversa jsliuqun sudeepverma77 chrox ianmadlenya thomasmiconi siarez vitaly-krugl mirkoklukas maxaschwarzer jacobeverist 347469339 rougier sl624 vincentliuk kyuchangkang codeaudit ali2050 phpmind ascode jakobstruye abshej kshitiz621 lorenzai learning2021 sandychuang xyuan princehr vkowtha takanokage dubing12 fluid126 jshuadvd fidelityagi dee0512 sycomix adriacab jenfrie ssghost duweiqiang stjordanis toertel pratyushdeka vcharatsidis studentzhang barnettjv leotiez gumpfly clemenspeters mengjin001 mtna6 fagan2888 treestreamymw

htmresearch's Issues

Refactor SensorimotorExperimentRunner to allow feeding in one record at a time

SensorimotorExperimentRunner's feedLayers method is optimized for taking sensorimotor sequences. Refactor it to create a separate function that can take a single sensorimotor transition, so that SensorimotorExperimentRunner can be used more easily in an online fashion.

This might warrant a rename to SensorimotorExperimentRunner as well (maybe to SensorimotorModel).

Refactor capacity test for parallelization

Allow running tests in parallel easily.

Create a General Temporal Memory implementation that uses FastTemporalMemory

Complement to numenta/nupic-legacy#1507.

Update capacity test to correctly test temporal pooler

Break the testing phase up with resets, to correctly test stability in temporal pooler.

Implement general temporal memory region

Namespace-prefix all names (arguments, variables, methods) in Monitor Mixins

To avoid collisions with the things they mixin to.

Create Monitor Mixin for Temporal Memory

To collect relevant metrics.

Fix broken travis-ci build job

Stuff is broken. Current problem is numpy version mismatch after installing matplotlib.

Store model state after experiments, and allow inspecting them later

Since experiments take long to run, it would be nice to be able to store the models and inspect them long after they are finished.

Capture speed in capacity tests

Record how long each test takes for performance monitoring.

Switch tests to use TemporalMemoryMonitorMixin

Depends on numenta/nupic-legacy#1370.

Tune parameters to make model less brittle

Subsample and tune thresholds to achieve graceful degradation when running out of resources.

Create unit test corresponding to simple_1D_test

Simplify General Temporal Memory code

Corresponding issue for numenta/nupic-legacy#1473.

Characterize TM+TP capacity with completely random sensory patterns

We want to see graphs of how temporal pooling performance (stability and discriminability) vary with changing either # of distinct worlds (images) or # of fixation points.

Run builds and tests in Travis-CI

Create .travis.yml that installs NuPIC from same binary nupic.regression uses
Run tests after build is complete
Update repos.yaml with travis: true

Combine general_temporal_memory.py and learn_on_one_cell_temporal_memory.py

Have the "learn on one cell" mode be an option as a keyword argument to the constructor of GeneralTemporalMemory.

Switch to new temporal_memory code

We want to move the TM code to the new temporal_memory implementation. The goal of this task is to allow us to delete TM_New.py from the repository. Specifically create a base class that adds distal dendrite learning and learn on one cell mode to temporal_memory code. Convert experiments to use this code.

Create test for multiple worlds having different cell representations

Create parallel job runner for capacity test

To make it easy to run many experiments in parallel.

Create experiment using new TM class plus pooling

Create sensorimotor experiment (similar to sm_1D_test) using new TM class plus pooling.

Ensure new temporal memory contains learn on one cell bug fix

Ensure new temporal memory contains learn on one cell bug fix. This is reflect in lines 809 to 825 of TM_SM.py:

        s = None
        if self.learnOnOneCell == True:
          # in learn on one cell mode, always learn on one cell per column
          # unless reset has just been called
          i = self.getSeqLearnCell(c)

        if not i:
          i,s = self.getBestMatchingCell(c,self.activeState['t-1'],
                                         self.distalDendriticInput['t-1'])

          if s is not None and s.isSequenceSegment():
            s.totalActivations += 1      # activationFrequency
            s.lastActiveIteration = self.iterationIdx
          else:
            # if best matching cell does not exist, then get least used cell
            i = self.getLeastUsedCell(c)

Allow running arbitrarily large capacity tests

Currently, there is a limit to how many worlds/elements can be in a capacity test, due to the pretty-printing of the elements. If we exceed this limit, just print ? instead of symbols, and allow running arbitrarily large tests.

Implement pooling region

Union pooler:
https://github.com/numenta/nupic.research/tree/master/union_pooling

This would be nice to support as a follow on:
https://github.com/numenta/nupic.research/blob/master/sensorimotor/sensorimotor/temporal_pooler.py

Debug sm_test_with_pooling

sm_test_with_pooling is not giving consistently good results on all patterns and with a larger number of patterns. This task is to debug and fix this.

Create metrics for evaluating Layer 4 sensorimotor inference

Implement metrics for sensorimotor inference. For perfect performance two criteria must be met:

Every element in a sensorimotor sequence should get predicted perfectly. This metric would operate on columns. Every sensory column should be predicted and no extra columns should be predicted.

Sensorimotor sequences through distinct static patterns should get completely distinct representations through the course of each sequence. This metric would operate at the level of cells. At every step, the SDR representing context at that point should be different from the SDR representing context at any point in any of the other sequences. We might exclude the very first element in each sequence since that is unpredicted.

Switch to using standard NuPIC encoders

Switch to using standard NuPIC encoders (Category and SDRCategory) for encoding sensory and motor patterns instead of PatternMachines

Capacity test: write [TM] or [TP] label with each header in csv

Otherwise it's hard to know which algorithm each metric belongs to.

Distinctness confusion reading doesn't make sense

Investigate this result:

Setting up a new experiment...
Done setting up experiment.

Training (worlds: 2, elements: 12)...
Fed 10 / 578 elements of the sequence in 0.41 seconds.
Fed 20 / 578 elements of the sequence in 0.38 seconds.
Fed 30 / 578 elements of the sequence in 0.41 seconds.
Fed 40 / 578 elements of the sequence in 0.38 seconds.
Fed 50 / 578 elements of the sequence in 0.40 seconds.
Fed 60 / 578 elements of the sequence in 0.38 seconds.
Fed 70 / 578 elements of the sequence in 0.40 seconds.
Fed 80 / 578 elements of the sequence in 0.41 seconds.
Fed 90 / 578 elements of the sequence in 0.38 seconds.
Fed 100 / 578 elements of the sequence in 0.41 seconds.
Fed 110 / 578 elements of the sequence in 0.42 seconds.
Fed 120 / 578 elements of the sequence in 0.44 seconds.
Fed 130 / 578 elements of the sequence in 0.43 seconds.
Fed 140 / 578 elements of the sequence in 0.43 seconds.
Fed 150 / 578 elements of the sequence in 0.57 seconds.
Fed 160 / 578 elements of the sequence in 0.63 seconds.
Fed 170 / 578 elements of the sequence in 0.64 seconds.
Fed 180 / 578 elements of the sequence in 0.62 seconds.
Fed 190 / 578 elements of the sequence in 0.62 seconds.
Fed 200 / 578 elements of the sequence in 0.62 seconds.
Fed 210 / 578 elements of the sequence in 0.62 seconds.
Fed 220 / 578 elements of the sequence in 0.62 seconds.
Fed 230 / 578 elements of the sequence in 0.62 seconds.
Fed 240 / 578 elements of the sequence in 0.63 seconds.
Fed 250 / 578 elements of the sequence in 0.62 seconds.
Fed 260 / 578 elements of the sequence in 0.65 seconds.
Fed 270 / 578 elements of the sequence in 0.65 seconds.
Fed 280 / 578 elements of the sequence in 0.65 seconds.
Fed 290 / 578 elements of the sequence in 0.52 seconds.
Fed 300 / 578 elements of the sequence in 0.43 seconds.
Fed 310 / 578 elements of the sequence in 0.41 seconds.
Fed 320 / 578 elements of the sequence in 0.44 seconds.
Fed 330 / 578 elements of the sequence in 0.41 seconds.
Fed 340 / 578 elements of the sequence in 0.43 seconds.
Fed 350 / 578 elements of the sequence in 0.40 seconds.
Fed 360 / 578 elements of the sequence in 0.43 seconds.
Fed 370 / 578 elements of the sequence in 0.43 seconds.
Fed 380 / 578 elements of the sequence in 0.41 seconds.
Fed 390 / 578 elements of the sequence in 0.43 seconds.
Fed 400 / 578 elements of the sequence in 0.43 seconds.
Fed 410 / 578 elements of the sequence in 0.43 seconds.
Fed 420 / 578 elements of the sequence in 0.43 seconds.
Fed 430 / 578 elements of the sequence in 0.47 seconds.
Fed 440 / 578 elements of the sequence in 0.61 seconds.
Fed 450 / 578 elements of the sequence in 0.64 seconds.
Fed 460 / 578 elements of the sequence in 0.66 seconds.
Fed 470 / 578 elements of the sequence in 0.65 seconds.
Fed 480 / 578 elements of the sequence in 0.65 seconds.
Fed 490 / 578 elements of the sequence in 0.70 seconds.
Fed 500 / 578 elements of the sequence in 0.74 seconds.
Fed 510 / 578 elements of the sequence in 0.68 seconds.
Fed 520 / 578 elements of the sequence in 0.67 seconds.
Fed 530 / 578 elements of the sequence in 0.66 seconds.
Fed 540 / 578 elements of the sequence in 0.67 seconds.
Fed 550 / 578 elements of the sequence in 0.67 seconds.
Fed 560 / 578 elements of the sequence in 0.67 seconds.
Fed 570 / 578 elements of the sequence in 0.67 seconds.
Done training.

+---------------------------------------------------------------+--------+--------+----------+---------------+--------------------+
|                             Metric                            |  min   |  max   |   sum    |      mean     | standard deviation |
+---------------------------------------------------------------+--------+--------+----------+---------------+--------------------+
|                      [TP] # active cells                      |   20   |   20   |  11520   |      20.0     |        0.0         |
|                    [TP] stability confusion                   |   0    |   40   | 5747664  | 35.0117199873 |   9.52273451876    |
|                  [TP] distinctness confusion                  |  110   |  110   |   220    |     110.0     |        0.0         |
|             [TP] connections per column (initial)             | 1766.0 | 1934.0 | 942963.0 | 1841.72460938 |   31.2957218622    |
|              [TP] connections per column (final)              | 1768.0 | 2021.0 | 948707.0 | 1852.94335938 |    41.789403127    |
|                     [TM] # active columns                     |   20   |   20   |  11480   |      20.0     |        0.0         |
|          [TM] # predicted => active columns (correct)         |   0    |   20   |   920    | 1.60278745645 |   5.43017693067    |
|          [TM] # predicted => inactive columns (extra)         |   0    |   0    |    0     |      0.0      |        0.0         |
|        [TM] # unpredicted => active columns (bursting)        |   0    |   20   |  10560   | 18.3972125436 |   5.43017693067    |
|           [TM] # predicted => active cells (correct)          |   0    |   20   |   920    | 1.60278745645 |   5.43017693067    |
|           [TM] # predicted => inactive cells (extra)          |   0    |   0    |    0     |      0.0      |        0.0         |
|                        [TM] # segments                        |   0    |  5280  | 1912240  | 3319.86111111 |   1566.42107388    |
|                        [TM] # synapses                        |   0    | 211200 | 76489600 | 132794.444444 |   62656.8429554    |
| [TM] # predicted => active cells per column for each sequence |   1    |   1    |   387    |      1.0      |        0.0         |
|   [TM] # sequences each predicted => active cells appears in  |   1    |   1    |   387    |      1.0      |        0.0         |
+---------------------------------------------------------------+--------+--------+----------+---------------+--------------------+

Update sm_1d_test to use Monitor Mixin

It's currently using the old TemporalMemoryInspectMixin.

Create simple example using ImageSensor region

Create simple example using ImageSensor region. This can serve as a base for how to use the Network API with our old image sensor classes.

Investigate build archive retrieval failure from AWS S3 on branches

There may be a way I can remove the AWS secret key if I change the S3 permissions. Need to look into it, because devs have no way of knowing if their changes pass CI on PRs until they are merged into master.

Experiment with alternate Temporal Memory connectivity

Instead of using as context (context-free sensor signal + motor signal) and disallowing lateral connections, experiment with using (motor signal) and allowing lateral connections.

Add metric for # connections per column in TP

We want to see the distributions of connections over columns, so a plot would also be nice.

Add option to use random category encoder in sm_sequences

Create simple runner class for running SM networks

Move some of the functionality from AbstractSensorimotorTest into a runner class that is not dependent on unittest. Update sm_1D_test to use this class.

Create ExhaustiveOneDAgent

Create ExhaustiveOneDAgent that walks through all possible transitions for a given OneDWorld.

Depends on numenta/nupic.research#51.

Switch tests to use SensorimotorExperimentRunner

Merge code from abstract_sensorimotor_test.py into SensorimotorExperimentRunner and refactor tests to use it.

Demonstrate stability for tiny image setup

Create simple vision experiment where we have a small number of images and small number of fixations. We want to see stable unique representations. This is mostly to test and debug the framework.

Create SP Mixin

Create a spatial pooler mixing class that monitors a few metrics:

The distribution of column activity (are all columns being used equally). This is very similar to the active duty cycle.

What is the average overlap for each column before inhibition?

Are we getting good SDR's? For two patterns that have N bits of overlap, how many bits of overlap do the SDR's have? This could be represented in an NxM overlap count matrix. OverlapCount[i,j] would be the number of times two patterns that had i bits of input overlap had j bits of SDR overlap. We should see a strong diagonal and a gradual drop off as you move away from the diagonal.

Add documentation

See comments here: numenta/nupic.research#57

Add more capacity to human-friendly representation of worlds

We currently support only A-Z + a-z + 0-9 as human-friendly representation of world elements. This restricts us to a small world size. Add more capacity to this.

Move private research code into public nupic.research repository

Clean up documentation for TemporalPooler

Clean up and update documentation for the TemporalPooler class. Some of the wording in there is a bit old. In particular we should explain exactly why the pooling state helps.

Move current position from World to Agent

Each Agent should keep track of its own position in its World, instead of the World keeping track of that information.

Implement simple class and metric for evaluating layer 3

Implement simple class and metric for evaluating layer 3 (pooling)

Update nupic installation after re-incorporating nupic-linux64 into build

See https://github.com/numenta/nupic.regression/issues/14. Whatever fix is made there needs to be made here as well.

Remove synPermActiveInactiveDec from TemporalPooler

The current TemporalPooler class has a parameter called synPermActiveInactiveDec with the associated rule:

For inactive columns, synapses connected to input bits that are on are
decreased by synPermActiveInactiveDec.

This task is to remove this rule, and all associated data structures such as _permanenceDecCache

In multiple words test, seeing perfect stability in some worlds, but not others

When testing with multiple worlds, no shared elements, I'm seeing perfect TP stability in some of them, while seeing imperfect TP stability in others. I would expect all of them to be imperfect in this case. Investigate this.

Update image scripts to use min/max enabled phase

This is a cleaner way to train the network in phases.