HTM Learning, try it in 5 minute

Хотите без особой теории сразу попробовать обучить иерархическую временную память и распознать «паттерн» во времени?

Ну тогда пройди «мини туториал».

Задача: Есть последовательность сигналов, скажем, A->B->C->D->E.  Так они обычно повторяются.

Надо обучить алгоритм так, чтобы он предсказывал следующий сигнал.

Для step-by-step понадобится только  установленный Docker. Погнали? 

Не знаю как под виндой, наверное ООчень похоже, а запускаем просто:

sudo docker run -it --rm numenta/nupic bash

Вроде есть все зависимости, но не помешает обновить, чтоб вы понимали что там (необязательно)

#####  nupic.research.core
# https://hub.docker.com/r/numenta/nupic/
# docker pull numenta/nupic
pip install --upgrade pip
git clone https://github.com/numenta/nupic.research.core.git
cd nupic.research.core
pip install -r bindings/py/requirements.txt
pip install pycapnp==0.5.8
python setup.py install

##### nupic.research
#git clone https://github.com/numenta/htmresearch.git
#cd htmresearch
# pip install --upgrade Cython
#python setup.py develop --user
## or just     pip install nupic htmresearch
# Ну нафиг, это жесть - добавляет к образу гигабайты (torch, tensorflow, tqdm,  astor, fas, Pillowб биндинги, куча всего)
#pip install nupic htmresearch
## Test installation
#cd ../nupic.research
#cd htmresearch
#python -c "from htmresearch.algorithms.extended_temporal_memory import ExtendedTemporalMemory"

 

Запускаем Питон

python

В питоне в интерактивном режиме набираем скетч

import numpy
from nupic.algorithms.backtracking_tm import BacktrackingTM
tm = BacktrackingTM(numberOfCols=50, cellsPerColumn=2,
                    initialPerm=0.5, connectedPerm=0.5,
                    minThreshold=10, newSynapseCount=10,
                    permanenceInc=0.1, permanenceDec=0.0,
                    activationThreshold=8,
                    globalDecay=0, burnIn=1,
                    checkSynapseConsistency=False,
                    pamLength=10)
                    


>>> tm
<nupic.algorithms.backtracking_tm.BacktrackingTM object at 0x7fa631bd9a90>

x = numpy.zeros((5, tm.numberOfCols), dtype="uint32")

>>> x
array([[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, 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]], dtype=uint32)

Здесь импортировали Temporal Pooler — как раз эта штука и обучает HTM, TP создает в «HTM мозгу» связи.

А вот SpatialPooler мы будем в ручную сейчас эмулировать, чтобы было понятно/

На вход в HTM поступают данные закодированные буквально БИТАМИ. Число битов совпадает с числом «колонок мозга»  т.е. должно быть постоянно.

HTM проектируется сразу под нужное число колонок для определенных входных данных.  Каждый бит имеет смысл и должен активироваться во входном наборе тогда, когда данный смысл имеется. Например если кодируется понедельник, то есть смысл его кодировать так, чтобы у понедельника были уникальные биты, и часть битов вторника и воскресенья , так как они рядом  в неделе располагаются. Вторник должен немного битами заезжать на среду и понедельник — это по смыслу близкие вещи.
У нас сигналы A,B,C,D,E это как совсем разные категории — они не должны наезжать друг на друга, наши категории совсем разные по смыслу (это упрощает пример) .

Все это обычно кодирует SpatialPooler, конкретная его реализация, принимает на вход данные, а на выходе получаем вектор битов.

Сделаем кодирование сигналов ручками:

x[0,0:10]  = 1   # Input SDR representing "A", corresponding to columns 0-9
x[1,10:20] = 1   # Input SDR representing "B", corresponding to columns 10-19
x[2,20:30] = 1   # Input SDR representing "C", corresponding to columns 20-29
x[3,30:40] = 1   # Input SDR representing "D", corresponding to columns 30-39
x[4,40:50] = 1   # Input SDR representing "E", corresponding to columns 40-49

Далее прогоняем эту последовательность раз 10 в режиме обучения (первый True), пока без шума — лучше запомнит.

for i in range(10):
    for j in range(5):
            tm.compute(x[j], enableLearn = True, enableInference = False)
    tm.reset()

tm.reset здесь можно не делать, но он немного помогает учебе, как бы указывая, что последовательность закончилась (внутри некоторые коэффициенты истории сбрасывает)

Теперь дадим ему вектор на вход, скажем A (x[0]) без обучения, и посмотрим, что HTM будет предвидеть?

tm.compute(x[0], enableLearn=False, enableInference=True)

Попросим состояние

>>> tm.printStates(printPrevious=False, printLearnState=False)
Inference Active state
1111111111 0000000000 0000000000 0000000000 0000000000 
0000000000 0000000000 0000000000 0000000000 0000000000 
Inference Predicted state
0000000000 0000000000 0000000000 0000000000 0000000000 
0000000000 1111111111 0000000000 0000000000 0000000000

Видите, что предсказано `0000000000 1111111111 0000000000 0000000000 0000000000 ` — но ведь это же наше B.

Какие конкретно биты предсказаны можно узнать и так:

def formatRow(x):
    s = ''
    for c in range(len(x)):
        if c > 0 and c % 10 == 0:
            s += ' '
        s += str(x[c])
    s += ' '
    return s

predictedCells = tm.getPredictedState()

>>> print formatRow(predictedCells.max(axis=1).nonzero())
[10 11 12 13 14 15 16 17 18 19]

Ну вот, дали A на вход, а HTM уже ожидает\предсказывает  B.

Задача решена ? Интерес возник?

Чтобы понять как оно работает я хорошую книгу нашел,  она на яндекс диске https://yadi.sk/i/yFnKJnd4FM92Hw