def set_stdp_calib(synram, calib):
    for row in range(pydls.Synapse_driver.num_drivers):
        for col in range(pydls.Neuron_index.num_neurons):
            synapse = synram.get(pydls.Synapse_row(row),
                                 pydls.Synapse_column(col))
            synapse.config(calib[row, col])
            synram.set(pydls.Synapse_row(row), pydls.Synapse_column(col),
                       synapse)
def make_synapse_array(synram):
    num_rows = pydls.Synapse_driver.num_drivers
    num_cols = pydls.Neuron_index.num_neurons
    synapse_array = numpy.zeros((num_rows, num_cols, 2), dtype=numpy.uint8)
    for row, col in itertools.product(range(num_rows), range(num_cols)):
        synapse = synram.get(pydls.Synapse_row(row), pydls.Synapse_column(col))
        synapse_array[row, col, 0] = synapse.weight()
        synapse_array[row, col, 1] = synapse.address()
    return synapse_array
def set_fixed_indegree(synram, weight, degree, address=0):
    nonzero_synapse = pydls.Synapse()
    nonzero_synapse.address(address)
    nonzero_synapse.weight(weight)
    for col in range(pydls.Neuron_index.num_neurons):
        perm = numpy.random.permutation(pydls.Neuron_index.num_neurons)
        perm = perm[:degree]
        for row in perm:
            synram.set(pydls.Synapse_row(row), pydls.Synapse_column(col),
                       nonzero_synapse)
def set_syndrv_inhibitory(syndrv, indexes):
    for index in indexes:
        syndrv.senx(pydls.Synapse_row(index), False)
        syndrv.seni(pydls.Synapse_row(index), True)
def set_correlation_switches(synram, config):
    switch = pydls.Synapse()
    switch.config(config)
    for col in range(pydls.Neuron_index.num_neurons):
        synram.set(pydls.Synapse_row(33), pydls.Synapse_column(col), switch)
コード例 #6
0
    def CreateNetwork(self, weightMatrix=[], exitatory=None, inhibitory=None):
        '''Wire the network'''

        #Network layout

        #The address of this spike determines which state neuron was firing
        #syn address 0 - (nStates - 1) -> addresses for state neurons
        #syn address nStates - (nstates + nActions) -> addresses for action neurons

        #This makes up the recurrent connections. The diagonal elements contain the recurrent connections
        #Synram contains the synapses -> access with row and column
        #The state neurons are connected on the diagonal elements in the synram
        for stateNeuronID in range(self.nStates):
            syn = self.chip.synram.get(dls.Synapse_row(stateNeuronID),
                                       dls.Synapse_column(stateNeuronID))
            syn.weight(63)  # 6bit max weight to ensure spiking
            syn.address(self.recurrentSpikeAddress)  # address
            self.chip.synram.set(dls.Synapse_row(stateNeuronID),
                                 dls.Synapse_column(stateNeuronID), syn)

        #This makes up the off-diagonal elements
        for stateNeuronID in range(self.nStates):
            neuronID = stateNeuronID + 1

            if neuronID == self.nStates:
                neuronID = 0

            syn = self.chip.synram.get(dls.Synapse_row(neuronID),
                                       dls.Synapse_column(stateNeuronID))
            syn.weight(63)  # 6bit max weight to ensure spiking
            syn.address(stateNeuronID)  # address
            self.chip.synram.set(dls.Synapse_row(neuronID),
                                 dls.Synapse_column(stateNeuronID), syn)

        #The action neurons get fully connected to the state neurons
        for actionNeuron in range(self.nActions):
            #if actionNeuron != 2:
            #    continue
            actionNeuronID = self.nStates + actionNeuron
            for stateNeuronID in range(self.nStates):
                syn = self.chip.synram.get(dls.Synapse_row(stateNeuronID),
                                           dls.Synapse_column(actionNeuronID))

                if weightMatrix == []:
                    if exitatory != None:
                        syn.weight(
                            exitatory
                        )  # 6bit #initialise the weights somewhere in the middle
                    else:
                        syn.weight(35)
                else:
                    print str(stateNeuronID) + ' | ' + str(
                        actionNeuronID) + ':' + str(
                            weightMatrix[stateNeuronID][actionNeuronID])
                    syn.weight(weightMatrix[stateNeuronID][actionNeuronID])

                syn.address(self.recurrentSpikeAddress)  # address
                self.chip.synram.set(dls.Synapse_row(stateNeuronID),
                                     dls.Synapse_column(actionNeuronID), syn)
                self.chip.rate_counter.enable(dls.Neuron_index(stateNeuronID),
                                              False)

            self.chip.rate_counter.enable(dls.Neuron_index(actionNeuronID),
                                          True)

        #Configure the action synapse drivers as inhibitory
        for rest in range(self.nStates, 32):
            self.chip.syndrv_config.senx(dls.Synapse_row(rest), False)
            self.chip.syndrv_config.seni(dls.Synapse_row(rest), True)

        #Configure inhibitory weights for action neurons
        #Here they are only inhibitory for the state neurons
        for actionNeuron in range(self.nActions):
            actionNeuronID = self.nStates + actionNeuron
            for neuronID in range(self.nStates):
                syn = self.chip.synram.get(dls.Synapse_row(actionNeuronID),
                                           dls.Synapse_column(neuronID))
                syn.weight(63)
                syn.address(self.recurrentSpikeAddress)  # address
                self.chip.synram.set(dls.Synapse_row(actionNeuronID),
                                     dls.Synapse_column(neuronID), syn)

            for neuronID in range(self.nStates, self.nStates + self.nActions):
                syn = self.chip.synram.get(dls.Synapse_row(actionNeuronID),
                                           dls.Synapse_column(neuronID))
                if inhibitory != None or self.inhibitory != None:
                    if self.inhibitory == None:
                        self.inhibitory = inhibitory
                    syn.weight(
                        self.inhibitory
                    )  # 6bit #initialise the weights somewhere in the middle
                else:
                    syn.weight(63)
                syn.address(self.recurrentSpikeAddress)  # address
                self.chip.synram.set(dls.Synapse_row(actionNeuronID),
                                     dls.Synapse_column(neuronID), syn)

        #Set the pulse length to 1
        self.chip.syndrv_config.pulse_length(1)

        #For now leave the first neuron empty to not mix up external inputs with state neuron spikes
        #Enable the output config for the state and action neurons
        for neuronID in range(self.nStates + self.nActions):
            neuron = self.chip.neurons.get(dls.Neuron_index(neuronID))
            #neuron.enable_out(True)
            self.chip.neurons.set(dls.Neuron_index(neuronID), neuron)

        self.chip.rate_counter.clear_on_read(True)
        '''Think about addressing and timing of 'recurrent' spikes'''
        self.fpga_conf = dls.Config_reg()
        self.fpga_conf.spike_router_enable = True
        self.router = dls.Spike_router_bypass(
            self.recurrentSpikeCumulationTime, self.recurrentSpikeAddress)

        pass
コード例 #7
0
    def EvaluateNetwork(self, maxIteration, verbose=True):
        '''Collect the results and evaluate the network'''

        #Print the spikes
        spike_train = self.spikes_builder.get_spikes()

        spike_times = []
        spike_address = []
        for spike in spike_train:
            spike_times.append(spike.time)
            spike_address.append(spike.address)
            #print 'A ' + str(spike.address) + ' T: ' + str(spike.time)

        #print str(len(spike_train)) + ' were sent'
        #print list(set(spike_address))

        mailbox_result = self.mailbox_handle.get()
        status = self.status_handle.get()

        if status.sleep() != True:
            print 'PPU did not finish!'

        if verbose:
            for spike in spike_train:
                print 'Adr ' + str(spike.address) + ' Time: ' + str(spike.time)

            #Print the mailbox content
            if False:
                utils.print_mailbox_string(mailbox_result)
            else:
                utils.print_mailbox(mailbox_result)

        #Read the mailbox and collect the results
        stateOffset = 0x000
        actionOffset = 0x800
        iterationCounterOffset = 0xffc

        states = utils.convertByteListToInt8(
            utils.readRange_mailbox(mailbox_result, stateOffset,
                                    stateOffset + maxIteration), False)
        actions = utils.convertByteListToInt8(
            utils.readRange_mailbox(mailbox_result, actionOffset,
                                    actionOffset + maxIteration), False)
        iterationCounter = utils.convertByteListToInt(
            utils.readRange_mailbox(mailbox_result, iterationCounterOffset,
                                    iterationCounterOffset + 4), False)

        if iterationCounter[0] != 2000:
            print 'Iteration counter was wrong! ' + str(iterationCounter[0])
            raise Exception('Iteration counter was wrong!')

        #Compute the rewards based on the state and action pair
        rewards = [0]
        for i in range(1, len(states)):
            rewards.append(self.R[actions[i - 1]][states[i - 1]][states[i]])

        if verbose:
            print 'Executed iterations: ' + str(iterationCounter[0])
            print rewards

        synram = self.synram_handle.get()

        policy = []
        Q_table = []
        for state in range(self.nStates):
            weights = [
                synram.get(dls.Synapse_row(state),
                           dls.Synapse_column(self.nStates +
                                              actionNeuron)).weight()
                for actionNeuron in range(self.nActions)
            ]
            Q_table.append(weights)
            maxQIndex = np.argmax(weights)
            policy.append(maxQIndex)

        weights = []
        for row in range(32):
            rowStr = ''
            weights.append([
                synram.get(dls.Synapse_row(row),
                           dls.Synapse_column(col)).weight()
                for col in range(32)
            ])
            for col in range(32):
                rowStr += '{:2d}, '.format(
                    synram.get(dls.Synapse_row(row),
                               dls.Synapse_column(col)).weight())

            if verbose:
                print rowStr

        weights = np.array(weights)

        if verbose:
            print policy

        return spike_times, spike_address, states, actions, rewards, policy, weights, Q_table
コード例 #8
0
    def play_bandit_batch(self, bandit_probabilities, n_pulls, n_runs,
                          hyperparameters, learning_rule, connector):
        n_batch = 1
        mailbox = dls.Mailbox()
        bandit_probabilities_machine = (bandit_probabilities * 2**32).astype(
            np.int)
        set_env(mailbox, bandit_probabilities_machine, n_pulls, n_runs,
                n_batch, learning_rule)

        n_arms = int(len(bandit_probabilities) / n_runs)
        action_inhibition = int(hyperparameters['action_inhibition'])
        stim_inhibition = int(hyperparameters['stim_inhibition'])

        weights = np.zeros((32, 32), dtype=np.int)
        addresses = np.zeros((32, 32), dtype=np.int)

        weights[self.stimulate_row, :] = 10
        weights[self.stimulate_row, self.stimulate_row] = 63
        addresses[self.stimulate_row,
                  self.stimulate_row] = connector.recurrent_address

        for i in mapping:
            # weights[i, :n_arms] = action_inhibition
            weights[i, :] = action_inhibition
            weights[
                i,
                self.stimulate_row] = stim_inhibition  # same for state neuron
            weights[i, i] = 0
            addresses[i, :] = connector.recurrent_address
            addresses[self.stimulate_row, i] = connector.recurrent_address
        addresses[self.stimulate_row, :n_arms] = connector.recurrent_address
        synapses.setup_synram(weights, addresses, connector.chip)
        pre_builder = dls.Dls_program_builder()
        pre_builder.set_time(0)
        pre_builder.set_chip(connector.chip)
        pre_builder.wait_for(1000000)
        pre_builder.halt()
        #print('-- before tranfer')
        pre_builder.transfer(connector.connection, 0x0)
        #print('-- before execute')
        pre_builder.execute(connector.connection, 0x0)
        #print('-- before safefetch')
        # pre_builder.fetch(connector.connection)
        safe_fetch(pre_builder, connector.connection)
        #print('-- after safefetch')
        # self.logger.info('executed pre_builder')

        # Playback memory program
        builder = dls.Dls_program_builder()
        builder.set_synram_config_reg(connector.synram_config_reg)
        builder.set_mailbox(mailbox)
        builder.set_ppu_program(learning_rule.dls_program)
        builder.set_ppu_control_reg(connector.ppu_control_reg_end)
        builder.set_ppu_control_reg(connector.ppu_control_reg_start)
        builder.set_time(0)
        builder.wait_until(self.wait)
        status_handle = builder.get_ppu_status_reg()
        builder.set_ppu_control_reg(connector.ppu_control_reg_end)
        mailbox_handle = builder.get_mailbox()
        synram_handle = builder.get_synram()
        builder.halt()

        # Transfer execute and copy back results
        #print('-- before transfer')
        builder.transfer(connector.connection, 0x0)
        #print('-- before execute')
        builder.execute(connector.connection, 0x0)
        #print('-- before safefetch')
        # builder.fetch(connector.connection)
        safe_fetch(builder, connector.connection)
        #print('-- after safefetch')
        # self.logger.info('program executed')
        if False:
            synram = synram_handle.get()
            weight_matrix = np.zeros((32, 32), dtype=np.int)
            for row in range(32):
                for col in range(32):
                    syn = synram.get(dls.Synapse_row(row),
                                     dls.Synapse_column(col))
                    weight_matrix[row, col] = syn.weight()
                    print('{:2d}'.format(syn.weight()), end=' ')
                print()
        spike_train = builder.get_spikes()
        spike_n = np.zeros((len(spike_train), 2), np.int)
        for i, spike in enumerate(spike_train):
            spike_n[i, 0] = spike.time
            spike_n[i, 1] = spike.address

        # Check status register
        status_reg_result = status_handle.get()
        if status_reg_result.sleep() is not True:
            raise BanditException('PPU did not stop')

        # results
        mailbox_result = mailbox_handle.get()

        a_r = np.zeros((n_runs, n_batch, n_pulls, 2), np.int)
        sampled_probs = np.zeros((n_runs, n_batch, n_arms))
        mailbox_bytes = list(bytes_of_mailbox(mailbox_result))

        all_expected_regrets = []
        for run_index in range(n_runs):
            batch_expected_regrets = []
            for batch_index in range(n_batch):
                for i in range(n_pulls):
                    byte = mailbox_bytes[i + n_pulls *
                                         (batch_index + run_index * n_batch)]
                    action = byte & 0x3f
                    if action >= n_arms:
                        if self.logger is not None:
                            self.logger.info(
                                'Wrong Action in Mailbox! Ignoring Current Run...'
                            )
                        if False:
                            for i, b in enumerate(mailbox_bytes):
                                if i % 16 == 0:
                                    print()
                                print('{:02x}'.format(b), end=' ')
                        raise BanditException('Mailbox has wrong values')
                    reward = 1 if (byte & 0x80) != 0 else 0
                    a_r[run_index, batch_index, i, :] = reward, action

                for i in range(n_arms):
                    a_ind = np.where(a_r[run_index, batch_index, :, 1] == i)[0]
                    p = np.mean(a_r[run_index, batch_index, a_ind, 0])
                    sampled_probs[run_index, batch_index, i] = p

                p_max = np.max(
                    bandit_probabilities[run_index * n_arms:(run_index + 1) *
                                         n_arms])
                expected_regret = 0
                for t_action in a_r[run_index, batch_index, :, 1]:
                    expected_regret += p_max - bandit_probabilities[
                        run_index * n_arms + t_action]
                batch_expected_regrets.append(expected_regret)
            all_expected_regrets.append(batch_expected_regrets)

        results = dict(a_r=a_r,
                       sampled_probs=sampled_probs,
                       mailbox_bytes=mailbox_bytes,
                       spikes=spike_n)

        all_expected_regrets = np.array(all_expected_regrets)
        return np.mean(all_expected_regrets), results