示例#1
0
文件: local.py 项目: openre/openre
    def __init__(self, config, net, domain_index):
        super(Domain, self).__init__(config, net, domain_index)

        self.ticks = 0
        self.synapse_count_by_domain = {}
        self.spike_learn_threshold \
                = self.net.config['synapse'].get('spike_learn_threshold', 0)
        self.spike_forget_threshold \
                = self.net.config['synapse'].get('spike_forget_threshold', 0)
        self.learn_rate \
                = self.net.config['synapse'].get('learn_rate', 0)
        self.learn_threshold \
                = self.net.config['synapse'].get('learn_threshold', 0)
        self.layers = []
        self.layers_vector = LayersVector()
        # domain layers config
        self.layers_config = deepcopy(self.config['layers'])
        # neurons vector. Metadata stored in layer.neurons_metadata
        self.neurons = NeuronsVector()
        self.remote_neuron_address = -1
        self.remote_neurons_metadata = NeuronsExtendableMetadata(0)

        # synapses vector
        self.synapse_address = -1
        self.synapses = SynapsesVector(
            0, self.net.config['synapse']['max_level'])
        self.synapses_metadata = None
        self.random = random.Random()
        self.seed = uuid.uuid4().hex
        self.pre_synapse_index = None
        self.post_synapse_index = None
        self.device = getattr(
            device,
            self.config['device'].get('type', 'OpenCL')
        )(self.config['device'])
        self.cache = {}
        # stats for domain (number of spikes)
        self.stat_vector = Vector()
        # fields:
        # 0 - total spikes (one per neuron) per self.config['stat_size'] ticks
        # 1 - number of the dead neurons
        # 2 - number of synapses with flag IS_STRENGTHENED
        # 3 - neurons tiredness = sum(layer.max_vitality - neuron.vitality)
        # 4 - synapse learn level
        self.stat_fields = 5
        stat_metadata = Metadata(
            (1, self.stat_fields),
            types.stat
        )
        self.stat_vector.add(stat_metadata)
        # stats for vectors
        self.layers_stat = Vector()

        self.transmitter_index = TransmitterIndex()
        self.receiver_index = ReceiverIndex()

        self.output_index = OutputIndex()

        logging.debug('Domain created (name: %s)', self.name)
示例#2
0
文件: local.py 项目: openre/openre
class Domain(DomainBase):
    """
    Домен (Domain) - содержит один и более слоев состоящих из нейронов,
    связанных друг с другом синапсами. Домен можно воспринимать как один процесс
    в операционной системе, реализующий частично или полностью какой либо
    функционал. В некоторых случаях домен может не содержать синапсов (например,
    если домен является источником данных с сенсоров)

    self.name: types.address - должен быть уникальным для всех доменов
    self.ticks: types.tick - номер тика с момента запуска. При 32 битах и 1000
                             тиков в секунду переполнение произойдет через 49
                             дней. При 64 битах через 584 млн. лет.
    self.spike_learn_threshold: types.tick - как близко друг к другу по времени
                                должен сработать pre и post нейрон, что бы
                                поменялся вес синапса в большую сторону.
                                0 - по умолчанию (сеть не обучается).
    self.spike_forget_threshold: types.tick - насколько сильной должна быть
                                 разница между pre.tick и post.tick что бы
                                 уменьшился вес синапса.
                                 0 - по умолчанию (сеть не забывает).
    self.layers - список слоев (class Layer) домена
    self.learn_rate: types.synapse_level - с какой скоростью увеличивается
                     synapse.learn если у нейронов синапса расстояние между
                     спайками меньше чем self.spike_learn_threshold
    self.learn_threshold: types.synapse_level - какой максимальный уровень может
                          быть у synapse.learn. При спайке synapse.learn
                          суммируется с synapse.level (кратковременная память)
                          и суммарный сигнал передается post-нейрону.
                          Минимальный уровень у synapse.learn == 0. При первом
                          достижении максимального уровня синапс должен
                          одноразово усиливаться (долговременная память).
    Жеательно что бы выполнялось условие:
        0 <= spike_learn_threshold <= spike_forget_threshold <= types.tick.max
    """
    def __init__(self, config, net, domain_index):
        super(Domain, self).__init__(config, net, domain_index)

        self.ticks = 0
        self.synapse_count_by_domain = {}
        self.spike_learn_threshold \
                = self.net.config['synapse'].get('spike_learn_threshold', 0)
        self.spike_forget_threshold \
                = self.net.config['synapse'].get('spike_forget_threshold', 0)
        self.learn_rate \
                = self.net.config['synapse'].get('learn_rate', 0)
        self.learn_threshold \
                = self.net.config['synapse'].get('learn_threshold', 0)
        self.layers = []
        self.layers_vector = LayersVector()
        # domain layers config
        self.layers_config = deepcopy(self.config['layers'])
        # neurons vector. Metadata stored in layer.neurons_metadata
        self.neurons = NeuronsVector()
        self.remote_neuron_address = -1
        self.remote_neurons_metadata = NeuronsExtendableMetadata(0)

        # synapses vector
        self.synapse_address = -1
        self.synapses = SynapsesVector(
            0, self.net.config['synapse']['max_level'])
        self.synapses_metadata = None
        self.random = random.Random()
        self.seed = uuid.uuid4().hex
        self.pre_synapse_index = None
        self.post_synapse_index = None
        self.device = getattr(
            device,
            self.config['device'].get('type', 'OpenCL')
        )(self.config['device'])
        self.cache = {}
        # stats for domain (number of spikes)
        self.stat_vector = Vector()
        # fields:
        # 0 - total spikes (one per neuron) per self.config['stat_size'] ticks
        # 1 - number of the dead neurons
        # 2 - number of synapses with flag IS_STRENGTHENED
        # 3 - neurons tiredness = sum(layer.max_vitality - neuron.vitality)
        # 4 - synapse learn level
        self.stat_fields = 5
        stat_metadata = Metadata(
            (1, self.stat_fields),
            types.stat
        )
        self.stat_vector.add(stat_metadata)
        # stats for vectors
        self.layers_stat = Vector()

        self.transmitter_index = TransmitterIndex()
        self.receiver_index = ReceiverIndex()

        self.output_index = OutputIndex()

        logging.debug('Domain created (name: %s)', self.name)

    def deploy_layers(self):
        """
        Create layers
        """
        logging.debug('Deploy domain (name: %s)', self.name)
        for layer_config in self.layers_config:
            layer = Layer(layer_config)
            self.neurons.add(layer.neurons_metadata)
            layer.address = layer.neurons_metadata.address
            self.layers.append(layer)
            layer_config['layer'] = layer
            self.layers_vector.add(layer.layer_metadata)
            layer_stat_metadata = Metadata(
                (1, self.stat_fields),
                types.stat
            )
            self.layers_stat.add(layer_stat_metadata)
        self.neurons.add(self.remote_neurons_metadata)
        for layer_config in self.layers_config:
            for connect in layer_config.get('connect', []):
                connect['domain_layers'] = []
            for layer in self.layers:
                for connect in layer_config.get('connect', []):
                    if connect['name'] == layer.name:
                        connect['domain_layers'].append(layer)
        logging.debug('Allocate layers vector')
        for layer_name, layer in enumerate(self.layers):
            self.layers_vector.threshold[layer_name] = layer.threshold
            self.layers_vector.relaxation[layer_name] = layer.relaxation
            self.layers_vector.spike_cost[layer_name] = layer.spike_cost
            self.layers_vector.max_vitality[layer_name] = layer.max_vitality

    def deploy_neurons(self):
        """
        Create neurons
        """
        logging.debug(
            'Total %s local neurons in domain',
            len(self.neurons)
        )
        self.create_neurons()

    def pre_deploy_synapses(self):
        """
        Init synapses vector
        """
        # allocate synapses buffer in memory
        self.synapses_metadata = SynapsesMetadata(0)
        self.synapses.add(self.synapses_metadata)

    def deploy_synapses_async(self):
        """
        Async version of deploy_synapses
        """
        ret = self.create_synapses()
        # Create synapses
        if isinstance(ret, GeneratorType):
            for res in ret:
                yield res

        domain_total_synapses = self.synapse_count_by_domain.get(self.name, 0)
        if not domain_total_synapses:
            logging.warn('No synapses in domain %s', self.name)
        logging.debug(
            'Total %s local synapses in domain',
            domain_total_synapses
        )

    def deploy_synapses(self):
        """
        Create synapses
        """
        list(self.deploy_synapses_async())

    def post_deploy_synapses(self):
        """
        Run after all domains is synced
        """
        # sync length between synapses multifield metadata fields
        self.synapses_metadata.sync_length(self.synapse_address+1)
        # sync self.neurons length after adding remote neurons
        self.remote_neurons_metadata.sync_length(self.remote_neuron_address+1)
        logging.debug(
            'Total %s neurons in domain %s',
            len(self.neurons),
            self.name
        )
        logging.debug(
            'Total %s synapses in domain %s',
            len(self.synapses),
            self.name
        )

    def deploy_indexes(self):
        """
        Create indexes
        """
        # create pre-neuron - synapse index
        logging.debug('Create pre-neuron - synapse index')
        self.pre_synapse_index = SynapsesIndex(
            len(self.neurons), self.synapses.pre)
        # create post-neuron - synapse index
        logging.debug('Create post-neuron - synapse index')
        self.post_synapse_index = SynapsesIndex(
            len(self.neurons), self.synapses.post)
        self.transmitter_index.shrink()
        self.receiver_index.shrink()
        logging.debug('Create output indexes')
        for layer in self.layers:
            self.output_index.add(layer)
        self.output_index.shrink()


    def deploy_device(self):
        """
        Upload data to device
        """
        logging.debug('Upload data to device')
        for vector in [
            self.layers_vector,
            self.neurons,
            self.synapses,
            self.pre_synapse_index,
            self.post_synapse_index,
            self.stat_vector,
            self.layers_stat,
            self.transmitter_index,
            self.receiver_index,
            self.output_index,
        ]:
            vector.create_device_data_pointer(self.device)
        logging.debug('Domain deployed (name: %s)', self.name)

    def create_synapses(self):
        """
        Создаем физически синапсы
        """
        logging.debug('Create synapses')
        # Domains synapses
        return self.connect_layers()

    def connect_layers(self):
        """
        Реализует непосредственное соединение слоев
        """
        self.random.seed(self.seed)
        layer_config_by_name = {}
        total_synapses = self.synapse_count_by_domain
        # cache
        self_connect_neurons = self.connect_neurons
        for layer_config in self.net.config['layers']:
            layer_config_by_name[layer_config['name']] = layer_config
        domain_index_to_name = []
        for domain_index, domain in enumerate(self.net.config['domains']):
            domain_index_to_name.append(domain['name'])
            total_synapses[domain['name']] = 0
            if domain['name'] == self.name:
                pre_domain_index = domain_index
        # cache neuron -> domain and neuron -> layer in domain
        if 'layer' not in self.cache:
            self.cache['layer'] = {}
            for layer_config in self.net.config['layers']:
                # heihgt x width x z,
                # where z == 0 is domain index in net and
                #       z == 1 is layer index in domain
                self.cache['layer'][layer_config['name']] = \
                    np.zeros(
                        (layer_config['height'], layer_config['width'], 2),
                        dtype=np.int
                    )
                self.cache['layer'][layer_config['name']] \
                        .fill(np.iinfo(np.int).max)
            for domain_index, domain in enumerate(self.net.config['domains']):
                layer_index = -1
                for layer in domain['layers']:
                    layer_index += 1
                    layer = deepcopy(layer)
                    layer_config = layer_config_by_name[layer['name']]
                    shape = layer.get(
                        'shape',
                        [0, 0, layer_config['width'], layer_config['height']]
                    )
                    if shape[0] < 0:
                        shape[0] = 0
                    if shape[1] < 0:
                        shape[1] = 0
                    if shape[0] + shape[2] > layer_config['width']:
                        shape[2] = layer_config['width'] - shape[0]
                    if shape[1] + shape[3] > layer_config['height']:
                        shape[3] = layer_config['height'] - shape[1]
                    layer_cache = \
                            self.cache['layer'][layer_config['name']]
                    for y in xrange(shape[1], shape[1] + shape[3]):
                        layer_cache_y = layer_cache[y]
                        for x in xrange(shape[0], shape[0] + shape[2]):
                            layer_cache_y[x][0] = domain_index
                            layer_cache_y[x][1] = layer_index

        # start connecting
        pre_layer_index = -1
        async_time = time.time()
        for layer_config in self.layers_config:
            pre_layer_index += 1
            # no connections with other layers
            if not layer_config.get('connect'):
                continue
            # pre layer. Connect only neurons in this domain
            layer = layer_config['layer']
            # precache method
            layer_to_address = layer.neurons_metadata.level.to_address
            for connect in layer_config.get('connect', []):
                shift = connect.get('shift', [0, 0])
                if callable(shift[0]):
                    def shift_x():
                        return shift[0]()
                else:
                    def shift_x():
                        return shift[0]
                if callable(shift[1]):
                    def shift_y():
                        return shift[1]()
                else:
                    def shift_y():
                        return shift[1]

                post_layer_config = layer_config_by_name[connect['name']]
                post_info_cache = self.cache['layer'][post_layer_config['name']]
                radius = connect.get('radius', max(
                    int(1.0 * layer_config['width'] \
                        / post_layer_config['width'] / 2),
                    int(1.0 * layer_config['height'] \
                        / post_layer_config['height'] / 2)
                ) + 1)
                def pre_layer_coords():
                    for pre_y in xrange(layer.y, layer.y + layer.height):
                        for pre_x in xrange(layer.x, layer.x + layer.width):
                            yield pre_y, pre_x
                for pre_y, pre_x in pre_layer_coords():
                    # Determine post x coordinate of neuron in post layer.
                    # Should be recalculated for every y because of possible
                    # random shift
                    if time.time() - async_time > 0.1:
                        async_time = time.time()
                        yield (pre_y, layer.width)
                    pre_neuron_address = layer_to_address(
                        pre_x - layer.x,
                        pre_y - layer.y
                    )
                    central_post_x = int(math.floor(
                        1.0 * pre_x / (layer_config['width']) \
                        * (post_layer_config['width'])
                        + (post_layer_config['width'] \
                           / layer_config['width'] / 2.0)
                    )) + shift_x()
                    # determine post y coordinate of neuron in post layer
                    central_post_y = int(math.floor(
                        1.0 * pre_y / (layer_config['height']) \
                        * (post_layer_config['height'])
                        + (post_layer_config['height'] \
                           / layer_config['height'] / 2.0)
                    )) + shift_y()
                    # for all neurons (in post layer) inside of the
                    # connect['radius'] with given central point
                    post_from_range_x = central_post_x - (radius - 1)
                    post_to_range_x = central_post_x + (radius - 1) + 1
                    if post_from_range_x < 0:
                        post_from_range_x = 0
                    if post_from_range_x >= post_layer_config['width']:
                        continue
                    if post_to_range_x < 0:
                        continue
                    if post_to_range_x > post_layer_config['width']:
                        post_to_range_x = post_layer_config['width']

                    post_from_range_y = central_post_y - (radius - 1)
                    post_to_range_y = central_post_y + (radius - 1) + 1
                    if post_from_range_y < 0:
                        post_from_range_y = 0
                    if post_from_range_y >= post_layer_config['height']:
                        continue
                    if post_to_range_y < 0:
                        continue
                    if post_to_range_y > post_layer_config['height']:
                        post_to_range_y = post_layer_config['height']
                    def post_layer_coords():
                        # for neurons in post layer
                        for post_y in xrange(
                            post_from_range_y,
                            post_to_range_y
                        ):
                            post_info_cache_y = post_info_cache[post_y]
                            for post_x in xrange(
                                post_from_range_x,
                                post_to_range_x
                            ):
                                inf = post_info_cache_y[post_x]
                                yield post_x, post_y, inf
                    for post_x, post_y, inf in post_layer_coords():
                        try:
                            # inf[0] - domain index
                            post_info_domain_name = domain_index_to_name[inf[0]]
                        except IndexError:
                            continue
                        # actually create connections
                        if post_info_domain_name == self.name:
                            # inf[1] - post layer index in domain
                            post_layer = self.layers[inf[1]]
                            self.synapse_address += 1
                            self_connect_neurons(
                                pre_neuron_address,
                                post_layer.neurons_metadata.level.to_address(
                                    post_x - post_layer.x,
                                    post_y - post_layer.y
                                ),
                                self.synapse_address
                            )
                        else:
                            # connect neurons with other domains
                            self.connect_remote_neurons(
                                pre_domain_index,
                                pre_layer_index,
                                pre_neuron_address,
                                int(inf[0]), # post domain index
                                int(inf[1]), # post layer index
                                post_x,
                                post_y
                            )
                        total_synapses[post_info_domain_name] += 1

    def create_neurons(self):
        """
        Создаем физически нейроны в ранее созданном векторе
        """
        logging.debug('Create neurons')
        for layer in self.layers:
            layer.create_neurons()

    def connect_neurons(self, pre_address, post_address, synapse_address):
        """
        Соединяем два нейрона с помощью синапса.
        """
        # Speedup this:
        #   synapses = self.synapses_metadata
        #   synapses.pre[synapse_address] = pre_address
        #   synapses.post[synapse_address] = post_address
        synapses_vector = self.synapses
        synapses_metadata = self.synapses_metadata
        if synapse_address >= synapses_metadata.pre.length:
            synapses_metadata.pre.resize()
            synapses_metadata.post.resize()
        synapses_vector.pre.data[synapse_address] = pre_address
        synapses_vector.post.data[synapse_address] = post_address

    def connect_remote_neurons(
        self,
        pre_domain_index, pre_layer_index, pre_neuron_address,
        post_domain_index, post_layer_index, post_x, post_y
    ):
        """
        Соединяем локальный нейрон с нейроном в другом домене
        self == pre_domain
        """
        # local pre neuron is transmitter
        self.neurons.flags[pre_neuron_address] |= IS_TRANSMITTER
        # get post_neuron_domain
        domain = self.net.domains[post_domain_index]
        # connect pre neuron with post neuron in post_neuron_domain
        domain.send_synapse(
            pre_domain_index, pre_layer_index, pre_neuron_address,
            post_layer_index, post_x, post_y)

    def send_synapse_pack(self, bytes=None):
        """
        Получаем сгруппированные данные и синапсах из удаленного домена
        """
        if not bytes:
            return
        packet = TransmitterVector()
        packet.from_bytes(bytes)
        for pos in range(packet.length):
            self.send_synapse(
                packet.pre_domain_index.data[pos],
                packet.pre_layer_index.data[pos],
                packet.pre_neuron_address.data[pos],
                packet.post_layer_index.data[pos],
                packet.post_x.data[pos],
                packet.post_y.data[pos]
            )
        # досылаем остатки
        for domain in self.net.domains:
            if isinstance(domain, RemoteDomainBase):
                domain.send_receiver_index_pack()

    def send_synapse(
        self,
        pre_domain_index, pre_layer_index, pre_neuron_address,
        post_layer_index, post_x, post_y):
        """
        Обрабатываем информацию о синапсе из другого домена
        self == post_domain
        """
        pre_domain = self.net.domains[pre_domain_index]
        pre_layer = pre_domain.layers[pre_layer_index]
        post_layer = self.layers[post_layer_index]
        local_pre_neuron_address \
                = self.receiver_index.get_local_address(
                    pre_domain_index, pre_neuron_address)
        # create IS_RECEIVER neuron
        if not local_pre_neuron_address:
            self.remote_neuron_address += 1
            # add pre_neuron to domain.remote_neurons_metadata if not added (use
            # create_neuron function)
            create_neuron(self.remote_neuron_address,
                          self.remote_neurons_metadata,
                          pre_layer,
                          pre_layer_index)
            # get local_pre_neuron_address
            local_pre_neuron_address = self.remote_neurons_metadata.level \
                    .to_address(self.remote_neuron_address, 0)
            if not self.receiver_index.add(
                local_pre_neuron_address,
                pre_domain_index,
                pre_neuron_address
            ):
                self.stat_inc('receiver_index_again')
            local_pre_neuron_receiver_index = self.receiver_index.pos
            # set IS_RECEIVER flag to pre_neuron
            self.remote_neurons_metadata.flags[self.remote_neuron_address] \
                    |= IS_RECEIVER
            # send local_pre_neuron_address back to source domain (pre_domain)
            pre_domain.send_receiver_index(self.index, pre_neuron_address,
                                           local_pre_neuron_address,
                                           local_pre_neuron_receiver_index)
            self.stat_inc('total_receiver_neurons')
            self.stat_set('send_synapse_time', datetime.datetime.utcnow())
        # get synapse_address
        self.synapse_address += 1
        self.connect_neurons(
            local_pre_neuron_address,
            post_layer.neurons_metadata.level.to_address(
                post_x - post_layer.x,
                post_y - post_layer.y
            ),
            self.synapse_address
        )

    def send_receiver_index_pack(self, bytes=None):
        """
        Получаем сгруппированные данные из удаленного домена
        """
        if not bytes:
            return
        packet = ReceiverVector()
        packet.from_bytes(bytes)
        for pos in xrange(packet.length):
            self.send_receiver_index(
                packet.post_domain_index.data[pos],
                packet.pre_neuron_address.data[pos],
                packet.remote_pre_neuron_address.data[pos],
                packet.remote_pre_neuron_receiver_index.data[pos]
            )

    def send_receiver_index(self, post_domain_index, pre_neuron_address,
                            remote_pre_neuron_address,
                            remote_pre_neuron_receiver_index):
        """
        Запоминаем remote_neuron_address (IS_RECEIVER) для pre_neuron_address
        (IS_TRANSMITTER)
        self == pre_domain
        """
        pre_domain = self
        if not pre_domain.transmitter_index.add(
            pre_neuron_address, post_domain_index, remote_pre_neuron_address,
            remote_pre_neuron_receiver_index
        ):
            pre_domain.stat_inc('transmitter_index_again')
        pre_domain.stat_inc('total_transmitter_neurons')
        pre_domain.stat_set('send_receiver_index_time',
                            datetime.datetime.utcnow())

    def send_spikes(self):
        """
        Получаем спайки из устройства (device) и отправляем их в другие домены.
        """
        # step 4
        self.device.tick_transmitter_index(self)
        # step 5
        self.transmitter_index.is_spiked.from_device(self.device)
        index = self.transmitter_index
        domains = self.net.domains
        remote_domain_data = index.remote_domain.data
        remote_receiver_index_data = index.remote_receiver_index.data
        register_spike = [domain.register_spike for domain in domains]
        for i, is_spiked in enumerate(index.is_spiked.data):
            if not is_spiked:
                continue
            receiver_neuron_index = remote_receiver_index_data[i]
            register_spike[remote_domain_data[i]](receiver_neuron_index)
        for post_domain in self.net.domains:
            if post_domain != self:
                # если post_domain локальный, то ничего не произойдет
                # если post_domain удаленный и у него накопились спайки,
                # то он опубликует эти спайки
                post_domain.register_spike_pack()

    def receive_spikes(self):
        """
        Получаем спайки из других доменов, формируем receiver index и копируем
        его в устройство (device).
        """
        # step 3
        # send to device info about new spikes
        self.receiver_index.is_spiked.to_device(self.device)
        self.device.tick_receiver_index(self)
        # get is_spiked filled with 0
        self.receiver_index.is_spiked.from_device(self.device)

    def register_spike_pack(self, bytes=None):
        """
        Обрабатываем спайки из удаленных доменов
        """
        if not bytes:
            return
        packet = SpikesVector()
        packet.from_bytes(bytes)
        self.stat_inc('spikes_received', packet.length)
        # speedup for commented version
        #for pos in range(packet.length):
        #    self.register_spike(
        #        packet.receiver_neuron_index.data[pos],
        #    )
        self.receiver_index.is_spiked.data[packet.receiver_neuron_index.data] \
                = 1


    def register_spike(self, receiver_neuron_index):
        """
        Записывает в домен пришедший спайк
        """
        # step 2
        self.receiver_index.is_spiked.data[receiver_neuron_index] = 1

    def register_input_layer_data(self, layer_index, data):
        """
        Регистрирует данные (в виде обычного или сериализованного numpy
        массива), пришедшие из других доменов.
        """
        if isinstance(self.device, device.IOBase):
            self.register_input_layer_data = self._register_input_io_data
        else:
            self.register_input_layer_data = self._register_input_layer_data
        return self.register_input_layer_data(layer_index, data)

    def _register_input_layer_data(self, layer_index, data):
        """
        Регистрирует данные (в виде обычного или сериализованного numpy
        массива), пришедшие из других доменов.
        """
        self.layers[layer_index].register_input_data(data, self.ticks)

    def _register_input_io_data(self, layer_index, data):
        """
        Сохраняет данные (в виде обычного или сериализованного numpy массива)
        для использования в IO устройствах, пришедшие из других доменов.
        """
        self.device.register_input_data(layer_index, data, self.ticks)


    def tick(self):
        """
        Один tick домена.
        0.
            - self.ticks++
            - self.total_spikes = 0 (эта информация накапливается в
                domain.stat_vector для поля 0)
        1. по всем слоям layer:
            - layer.total_spikes = 0 (эта информация накапливается в
                domain.layers_stat для поля 0)
            и по всем нейронам neuron в слое layer (device):
            - если neuron.flags & IS_DEAD - не обсчитываем нейрон
            - если флаг IS_SPIKED уже установлен - снимаем
            - если это IS_RECEIVER - заканчиваем обсчет нейрона
            - если neuron.level >= layer.threshold:
                - у neuron.flags устанавливаем флаг IS_SPIKED,
                - layer.total_spikes++
                - domain.total_spikes++
                - обнуляем neuron.level (либо уменьшаем neuron.level на
                  layer.threshold, что бы можно было сделать генераторы
                  импульсов. Тут надо подумать.)
                - neuron.tick = domain.tick
            в противном случае:
                - neuron.level -= layer.relaxation
            - если neuron.level < 0, то neuron.level = 0

        2. по всем сообщениям о спайках пришедшим из других доменов (cpu):
            - если сообщений не было - пропускаем шаг 3.
            - в противном случае формируем receiver index и копируем его в
              устройство (device)

        3. по всем записям в receiver index (device):
            - устанавливаем флаг IS_SPIKED у нейрона по адресу index.address[i]

        4. по всем записям в transmitter index (device):
            - если по адресу index.address у нейрона neuron.flags & IS_SPIKED,
              устанавливаем флаг IS_SPIKED у index.flags, в противном случае
              снимаем флаг

        5. получаем из устройства (device) transmitter index (cpu):
            - формируем сообщения для тех нейронов, у которых произошел спайк и
              асинхронно отправляем их в другие домены.

        6. по всем записям в pre_synapse_index.key (device):
            - если pre_synapse_index.key[i] == null - заканчиваем обсчет
            - если neuron.flags & IS_DEAD - обнуляем все синапсы
              (synapse.level = 0)
            - если не neuron.flags & IS_SPIKED, то заканчиваем обсчет
            - по всем записям в pre_synapse_index.value, относящимся к
              pre_synapse_index.key[i]:
                - если synapse.level == 0 - считаем что синапс мертв и не
                  обсчитываем дальше внутренний цикл
                - если post.flags & IS_DEAD - удаляем синапс (synapse.level = 0)
                  и не обсчитываем дальше внутренний цикл
                - если дошли до этого места, то neuron.flags & IS_SPIKED и
                  делаем:
                    - post.level += (neuron.flags & IS_INHIBITORY ?
                      -synapse.level : synapse.level)
                    # Обучение синапсов к post нейронам
                    - если neuron.tick - post.tick
                        < domain.spike_learn_threshold,
                      то увеличиваем вес синапса. Вес можно увеличивать,
                      например, как f(neuron.tick - post.tick), либо на
                      фиксированное значение
                    - если neuron.tick - post.tick
                        >= domain.spike_forget_threshold,
                      то уменьшаем вес синапса. Вес можно уменьшать, например,
                      как f(neuron.tick - post.tick), либо на фиксированное
                      значение
            - по всем записям в post_synapse_index.value, относящимся к
              post_synapse_index.key[i]:
                - если synapse.level == 0 - считаем что синапс мертв и не
                  обсчитываем дальше внутренний цикл
                - если pre.flags & IS_DEAD - удаляем синапс (synapse.level = 0)
                  и не обсчитываем дальше внутренний цикл
                # Обучение синапсов от pre нейронов
                - если neuron.tick - pre.tick <= domain.spike_learn_threshold,
                  то увеличиваем вес синапса. Вес можно увеличивать, например,
                  как f(neuron.tick - pre.tick), либо на фиксированное значение
                - если neuron.tick - pre.tick >= domain.spike_forget_threshold,
                  то уменьшаем вес синапса. Вес можно уменьшать, например, как
                  f(neuron.tick - pre.tick), либо на фиксированное значение

        """
        # step 0
        self.ticks += 1
        self.stat_set('ticks', self.ticks)
        # step 1
        self.device.tick_neurons(self)
        # step 2 & 3
        self.receive_spikes()
        # step 4 & 5
        self.send_spikes()
        # step 6
        self.device.tick_synapses(self)

    def clean(self):
        self.device.clean()