def test_unit_activate_decode():
unit = Unit(get_conf(
UNIT_INPUT_HEIGHT=2,
UNIT_INPUT_WIDTH=4,
UNIT_OUTPUT_WIDTH=4
))
messages = [
(
from_plain_signal(i % 4, 4),
from_plain_signal((i + 1) % 4, 4),
)
for i in range(100)
]
for message in messages:
unit.activate(message)
message = (
from_plain_signal(0, 4),
from_plain_signal(1, 4),
)
output_signal = unit.activate(message)
decoded_message = unit.decode(output_signal)
plain_message = list(map(to_plain_signal, decoded_message))
assert plain_message == [0, 1]
assert len(output_signal) == 4
def __init__(self, conf, data=None):
self.conf = conf
if data:
self.unit = Unit(conf, data=data["unit"])
else:
self.unit = Unit(conf)
def test_unit_restore():
unit = Unit(get_conf(
UNIT_INPUT_HEIGHT=2,
UNIT_INPUT_WIDTH=4,
UNIT_OUTPUT_WIDTH=4
))
messages = [
(
from_plain_signal(i % 4, 4),
from_plain_signal((i + 1) % 4, 4),
)
for i in range(100)
]
for message in messages:
unit.activate(message)
message = (
from_plain_signal(0, 4),
None
)
expected_message = (
from_plain_signal(0, 4),
from_plain_signal(1, 4),
)
restored_message = unit.restore(message)
assert restored_message[0] == expected_message[0], 'first signal should be exactly the same'
assert to_plain_signal(restored_message[1]) == to_plain_signal(expected_message[1])
def __init__(self, conf, data=None):
self.conf = conf
if data:
self.unit = Unit(conf, data=data['unit'])
else:
self.unit = Unit(conf)
def __init__(self, conf, data=None):
assert conf.TIME_UNIT_BASE_SIGNALS_NUMBER <= conf.UNIT_INPUT_HEIGHT
self.conf = conf
if data:
self.unit = Unit(conf, data=data['unit'])
else:
self.unit = Unit(conf)
self._buffer = Buffer([], size=self.conf.UNIT_INPUT_HEIGHT)
class TimeUnit:
"""
This type of unit accepts only one signal per activation, but can predict next signals
"""
KEY = 'time_unit'
def __init__(self, conf, data=None):
assert conf.TIME_UNIT_BASE_SIGNALS_NUMBER <= conf.UNIT_INPUT_HEIGHT
self.conf = conf
if data:
self.unit = Unit(conf, data=data['unit'])
else:
self.unit = Unit(conf)
self._buffer = Buffer([], size=self.conf.UNIT_INPUT_HEIGHT)
def get_data(self):
return {
'_key': self.KEY,
'unit': self.unit.get_data(),
}
def activate(self, signal, learn=True):
"""
Put signal to the unit
:param signal: signal to activate
:param learn: is learning enabled
:return: output signal of this unit
"""
self._buffer.push(signal)
learn = learn and all(self._buffer)
return self.unit.activate(tuple(self._buffer), learn=learn)
def reset(self):
"""
Forget all last signals (but not patterns).
While unit has not enough signals, prediction is not be possible
"""
self._buffer = Buffer([], size=self.conf.UNIT_INPUT_HEIGHT)
def get_prediction(self):
"""
:return: predicted signals
"""
signals_to_predict = self.conf.UNIT_INPUT_HEIGHT - self.conf.TIME_UNIT_BASE_SIGNALS_NUMBER
signals = list(self._buffer)[signals_to_predict:] + [None] * signals_to_predict
restored_signals = self.unit.restore(signals)
predicted_signals = restored_signals[-signals_to_predict:]
return predicted_signals
class SpaceUnit:
KEY = "space_unit"
def __init__(self, conf, data=None):
self.conf = conf
if data:
self.unit = Unit(conf, data=data["unit"])
else:
self.unit = Unit(conf)
def get_data(self):
return {"_key": self.KEY, "unit": self.unit.get_data()}
def activate(self, signals, learn=True):
return self.unit.activate(signals, learn=learn)
def decode(self, signal):
return self.unit.decode(signal)
class SpaceUnit:
KEY = 'space_unit'
def __init__(self, conf, data=None):
self.conf = conf
if data:
self.unit = Unit(conf, data=data['unit'])
else:
self.unit = Unit(conf)
def get_data(self):
return {
'_key': self.KEY,
'unit': self.unit.get_data(),
}
def activate(self, signals, learn=True):
return self.unit.activate(signals, learn=learn)
def decode(self, signal):
return self.unit.decode(signal)
def test_unit_restore():
unit = Unit(
get_conf(UNIT_INPUT_HEIGHT=2, UNIT_INPUT_WIDTH=4, UNIT_OUTPUT_WIDTH=4))
messages = [(
from_plain_signal(i % 4, 4),
from_plain_signal((i + 1) % 4, 4),
) for i in range(100)]
for message in messages:
unit.activate(message)
message = (from_plain_signal(0, 4), None)
expected_message = (
from_plain_signal(0, 4),
from_plain_signal(1, 4),
)
restored_message = unit.restore(message)
assert restored_message[0] == expected_message[
0], 'first signal should be exactly the same'
assert to_plain_signal(restored_message[1]) == to_plain_signal(
expected_message[1])
def test_unit_activate_decode():
unit = Unit(
get_conf(UNIT_INPUT_HEIGHT=2, UNIT_INPUT_WIDTH=4, UNIT_OUTPUT_WIDTH=4))
messages = [(
from_plain_signal(i % 4, 4),
from_plain_signal((i + 1) % 4, 4),
) for i in range(100)]
for message in messages:
unit.activate(message)
message = (
from_plain_signal(0, 4),
from_plain_signal(1, 4),
)
output_signal = unit.activate(message)
decoded_message = unit.decode(output_signal)
plain_message = list(map(to_plain_signal, decoded_message))
assert plain_message == [0, 1]
assert len(output_signal) == 4
