def activity(task):
drawall = len(task) == 2
fname = task[0]
sfname = "analyzer_settings.txt"
wind_size = int(fs.load_parameter(sfname, "WINDOWSIZE", 7))
pstart = int(fs.load_parameter(sfname, "PACKSTART", 79))
pend = int(fs.load_parameter(sfname, "PACKEND", 21))
columns = int(fs.load_parameter(sfname, "HISTCOLUMNS", 7))
params = (wind_size, pstart, pend)
alldata = fs.load_matrix(fname)
if alldata is not None:
packs = []
start_ind = 0
flag = True
while flag:
pack = find_pack(alldata, start_ind, params)
if pack is not None:
packs.append(pack)
start_ind = pack[1]
else:
flag = False
packs = list(map(lambda x: alldata[x[0]:x[1]], packs))
if drawall:
draw_activity(alldata, "all activity")
p_act_data = [get_population_activity(alldata)]
fs.save_matrix(p_act_data, "output/analyzer/all activity.txt")
process_burst(alldata, 0, columns)
for i in range(len(packs)):
process_burst(packs[i], i+1, columns)
draw_activity(packs[i], "pack " + str(i+1) + " activity")
else:
print("cannot read file '" + fname + "'", flush=True)
def __init__(self):
super().__init__()
uic.loadUi("GUI/forms/main_form.ui", self)
self.init_ui()
self.worker = NetworkWorker(self)
# TODO: load settings here
self.create_new_network()
buf = 0
if fs.load_parameter(SETTINGS_FILEPATH, KEY_BUFFERED_OUTPUT_VALUE, DEFAULT_BUFFERED_OUTPUT_VALUE) == "True":
buf = int(fs.load_parameter(SETTINGS_FILEPATH, KEY_BUFFERED_OUTPUT_VALUE, DEFAULT_BUFFERED_OUTPUT_VALUE))
self.set_buffer(buf)
if self.ntw.getNoize()[0]:
self.NoizeTypeComboBox.setCurrentIndex(0)
self.NoizeValueSpinBox.setMaximum(100)
self.NoizeValueSpinBox.setValue(self.ntw.getNoize()[1])
else:
self.NoizeTypeComboBox.setCurrentIndex(1)
self.NoizeValueSpinBox.setMaximum(self.ntw.get_neurons_count())
self.NoizeValueSpinBox.setValue(self.ntw.getNoize()[1])
self.worker.set_save_to_file(True)
self.show()
def create_new_network(self):
neurs = int(fs.load_parameter(SETTINGS_FILEPATH, KEY_NEURONS_COUNT, DEFAULT_NEURONS_COUNT))
elects = int(fs.load_parameter(SETTINGS_FILEPATH, KEY_ELECTRODES_COUNT, DEFAULT_ELECTRODES_COUNT))
neurs_con = int(fs.load_parameter(SETTINGS_FILEPATH, KEY_NEURONS_CONNECTIONS, DEFAULT_NEURONS_CONNECTIONS))
elects_con = int(
fs.load_parameter(SETTINGS_FILEPATH, KEY_ELECTRODES_CONNECTIONS, DEFAULT_ELECTRODES_CONNECTIONS)
)
self.ntw = Network(self.worker)
self.ntw.add_electrodes(elects)
self.ntw.add_neurons(neurs)
self.ntw.add_connections(True, neurs_con, 0, neurs - 1, 0, neurs - 1)
self.ntw.add_connections(False, elects_con, 0, neurs_con - 1, 0, elects - 1)
self.ntw.setNoize(True, 5)
self.ntw.setNoize(DEFAULT_NOIZE_TYPE, DEFAULT_NOIZE_VAL)
print("New network created")
def dynamics(task):
try:
numbers = list(map(lambda x: int(x), task))
fname = "analyzer_settings.txt"
neurs = int(fs.load_parameter(fname, "NEURONS", 100))
elects = int(fs.load_parameter(fname, "ELECTRODES", 30))
cons = int(fs.load_parameter(fname, "CONNECTIONS", 2000))
elecons = int(fs.load_parameter(fname, "ELECONS", 150))
noize = int(fs.load_parameter(fname, "NOIZEVAL", 5))
dtesttime = int(fs.load_parameter(fname, "DYNTESTTIME", 2000))
data = []
states = []
for i in range(len(numbers)):
states.append([])
class Callback:
@staticmethod
def draw_info(info):
data.append(info)
callback = Callback()
ntw = Network(callback)
ntw.add_neurons(neurs)
ntw.add_electrodes(elects)
ntw.add_connections(True, cons, 0, neurs - 1, 0, neurs - 1)
ntw.add_connections(False, elecons, 0, cons - 1, 0, elects - 1)
ntw.setNoize(True, noize)
for i in range(dtesttime):
ntw.step()
state = ntw.get_state()
for j in range(len(numbers)):
states[j].append(state[3 + numbers[j]])
# processing data
value_dynamics = []
for n_states in states:
potential = []
strength = []
resource = []
incoming_current = []
for state in n_states:
potential.append(state[0])
strength.append(state[1])
resource.append(state[2])
incoming_current.append(state[3])
neuron_data = [potential, strength, resource, incoming_current]
value_dynamics.append(neuron_data)
fs.save_matrix(data, "output/analyzer/dynamics_activity.txt")
for i in range(len(numbers)):
fs.save_matrix([value_dynamics[i][0]], "output/analyzer/dynamics_" + str(numbers[i]) + "_potential" + ".txt")
fs.save_matrix([value_dynamics[i][1]], "output/analyzer/dynamics_" + str(numbers[i]) + "_strength" + ".txt")
fs.save_matrix([value_dynamics[i][2]], "output/analyzer/dynamics_" + str(numbers[i]) + "_resource" + ".txt")
fs.save_matrix([value_dynamics[i][3]], "output/analyzer/dynamics_" + str(numbers[i]) + "_current" + ".txt")
except Exception as e:
print("error: " + str(e), flush=True)
def __init__(self, parent):
super().__init__()
self.__parent = parent
parent.setEnabled(False)
parent.worker.pause()
uic.loadUi('GUI/forms/settings_form.ui', self)
self.init_ui()
# buffer
self.BufferGroupBox.setChecked("True" == fs.load_parameter(KEY_BUFFERED_OUTPUT_FLAG, DEFAULT_BUFFERED_OUTPUT_FLAG))
self.BufferValue.setValue(int(fs.load_parameter(KEY_BUFFERED_OUTPUT_VALUE, DEFAULT_BUFFERED_OUTPUT_VALUE)))
self.StartupTabs.setCurrentIndex(int(fs.load_parameter(KEY_SETTINGS_TAB, DEFAULT_SETTINGS_TAB)))
# 1 page
self.NeuronsCountBox.setValue(int(fs.load_parameter(KEY_NEURONS_COUNT, DEFAULT_NEURONS_COUNT)))
self.ElectrodesCountBox.setValue(int(fs.load_parameter(KEY_ELECTRODES_COUNT, DEFAULT_ELECTRODES_COUNT)))
self.ElectrodesConnectionsBox.setValue(int(fs.load_parameter(KEY_ELECTRODES_CONNECTIONS, DEFAULT_ELECTRODES_CONNECTIONS)))
self.NeuronsConnectionsBox.setValue(int(fs.load_parameter(KEY_NEURONS_CONNECTIONS, DEFAULT_NEURONS_CONNECTIONS)))
# 2 page
self.LoadTypeComboBox.setCurrentIndex(int(fs.load_parameter(KEY_LOAD_NETWORK_COMBOBOX, DEFAULT_LOAD_NETWORK_COMBOBOX)));
self.__restore_state_flag = "True" == fs.load_parameter(KEY_RESTORE_STATE_FLAG, DEFAULT_RESTORE_STATE_FLAG)
self.RestoreStateCheckBox.setChecked(self.__restore_state_flag)
self.__savedFiles = get_saved_files()
self.SelectSavedFileComboBox.addItems(self.__savedFiles)
saved_file = fs.load_parameter(KEY_SAVED_FILE,DEFAULT_SAVED_FILE)
for i in range(len(self.__savedFiles)):
if self.__savedFiles[i] == saved_file:
self.SelectSavedFileComboBox.setCurrentIndex(i+1)
break;
self.sub_load_type_combobox(self.LoadTypeComboBox.currentIndex())
self.ElectrodesMatrixLineEdit.setText(fs.load_parameter(KEY_ELECTRODES_MATRIX_PATH, DEFAULT_ELECTRODES_MATRIX_PATH))
self.NeuronsMatrixLineEdit.setText(fs.load_parameter(KEY_NEURONS_MATRIX_PATH, DEFAULT_NEURONS_MATRIX_PATH))
self.show()
def parameter(task):
id = task[0]
mn = task[1]
mx = task[2]
if len(task) == 4:
st = task[3]
else:
st = 1
val = mn
pool = [mn]
while mx - mn - st > EVALUATIONS_EPSILON:
mn += st
pool.append(mn)
pool.append(mx)
fname = "analyzer_settings.txt"
neurs = int(fs.load_parameter(fname, "NEURONS", 100))
elects = int(fs.load_parameter(fname, "ELECTRODES", 30))
cons = int(fs.load_parameter(fname, "CONNECTIONS", 2000))
elecons = int(fs.load_parameter(fname, "ELECONS", 150))
noize = int(fs.load_parameter(fname, "NOIZEVAL", 5))
testtime = int(fs.load_parameter(fname, "TESTTIME", 500))
tests = int(fs.load_parameter(fname, "TESTS", 10))
wind_size = int(fs.load_parameter(fname, "WINDOWSIZE", 7))
pstart = int(fs.load_parameter(fname, "PACKSTART", 79))
pend = int(fs.load_parameter(fname, "PACKEND", 21))
params = (wind_size, pstart, pend)
data = []
pool_burst_len = []
pool_noburst_len = []
pool_burst_percent = []
class Callback:
@staticmethod
def draw_info(info):
data.append(info)
for i in range(len(pool)):
sbl = 0
snbl = 0
sbp = 0
for j in range(tests):
data = []
callback = Callback()
ntw = Network(callback)
ntw.add_neurons(neurs)
ntw.add_electrodes(elects)
ntw.add_connections(True, cons, 0, neurs - 1, 0, neurs - 1)
ntw.add_connections(False, elecons, 0, cons - 1, 0, elects - 1)
ntw.setNoize(True, noize)
ntw.set_parameter(id, pool[i])
for k in range(testtime):
ntw.step()
bl, nbl, bp = analyze_activity(data, params)
sbl += bl
snbl +=nbl
sbp += bp
sbl /= tests
snbl /= tests
sbp /= tests
pool_burst_len.append(sbl)
pool_noburst_len.append(snbl)
pool_burst_percent.append(sbp)
lims = [0, max(max(pool_burst_len), max(pool_noburst_len))]
plt.xlabel("parameter " + str(id))
plt.ylabel("burst period length")
plt.ylim(lims)
plt.plot(pool, pool_burst_len)
plt.savefig("output/analyzer/id " + str(id) + " burst length" + ".png")
plt.close()
plt.xlabel("parameter " + str(id))
plt.ylabel("interburst period length")
plt.ylim(lims)
plt.plot(pool, pool_noburst_len)
plt.savefig("output/analyzer/id " + str(id) + " interburst length" + ".png")
plt.close()
plt.xlabel("parameter " + str(id))
plt.ylabel("burst percent")
plt.ylim([0, 1])
plt.plot(pool, pool_burst_percent)
plt.savefig("output/analyzer/id " + str(id) + " burst percent" + ".png")
plt.close()
output = "id {0}\nvalues: {1}\nburst length: {2}\ninterburst length: {3}\nburst percent {4}"\
.format(id, pool, pool_burst_len, pool_noburst_len, pool_burst_percent)
fs.write_file("output/analyzer/id " + str(id) + " testing results" + ".txt", output)
