def test_nsga2(self):
logging.info("\t > Evolution: Testing ALN single node ...")
start = time.time()
def evaluateSimulation(traj):
rid = traj.id
logging.info("Running run id {}".format(rid))
model = evolution.getModelFromTraj(traj)
model.params["dt"] = 0.2
model.params["duration"] = 2 * 1000.0
model.run()
# -------- fitness evaluation here --------
# example: get dominant frequency of activity
frs, powers = func.getPowerSpectrum(
model.rates_exc[:, -int(1000 / model.params["dt"]):],
model.params["dt"],
)
domfr = frs[np.argmax(powers)]
fitness = abs(domfr - 25) # let's try to find a 25 Hz oscillation
fitness_tuple = ()
fitness_tuple += (fitness, )
# multi objective
fitness_tuple += (fitness, )
return fitness_tuple, model.outputs
alnModel = ALNModel()
alnModel.run(bold=True)
pars = ParameterSpace(["mue_ext_mean", "mui_ext_mean"],
[[0.0, 4.0], [0.0, 4.0]])
evolution = Evolution(
evaluateSimulation,
pars,
algorithm="nsga2",
model=alnModel,
weightList=[-1.0, 1.0],
POP_INIT_SIZE=4,
POP_SIZE=4,
NGEN=2,
filename="test_nsga2.hdf",
)
evolution.run(verbose=False)
evolution.info(plot=False)
traj = evolution.loadResults()
gens, all_scores = evolution.getScoresDuringEvolution()
# overview of current population
evolution.dfPop
# overview of all past individuals
evolution.dfEvolution
end = time.time()
logging.info("\t > Done in {:.2f} s".format(end - start))
def test_functional_connectivity(self):
# assert log warning was issued
root_logger = logging.getLogger()
with self.assertLogs(root_logger, level="ERROR") as cm:
fcs = self.signal.functional_connectivity()
self.assertEqual(
cm.output,
[
"ERROR:root:Cannot compute functional connectivity from one timeseries."
],
)
# should be None when computing on one timeseries
self.assertEqual(None, fcs)
# now proper example with network - 3D case
ds = Dataset("gw")
aln = ALNModel(Cmat=ds.Cmat, Dmat=ds.Dmat)
# in ms, simulates for 2 minutes
aln.params["duration"] = 2 * 1000
aln.run()
network_sig = RatesSignal.from_model_output(aln)
fcs = network_sig.functional_connectivity()
self.assertTrue(isinstance(fcs, xr.DataArray))
correct_shape = (network_sig.shape[0], network_sig.shape[1],
network_sig.shape[1])
self.assertTupleEqual(fcs.shape, correct_shape)
# 2D case
fc = network_sig["rates_exc"].functional_connectivity()
self.assertTrue(isinstance(fc, xr.DataArray))
correct_shape = (network_sig.shape[1], network_sig.shape[1])
self.assertTupleEqual(fc.shape, correct_shape)
def setUpClass(cls):
ds = Dataset("gw")
aln = ALNModel(Cmat=ds.Cmat, Dmat=ds.Dmat)
# Resting state fits
aln.params["mue_ext_mean"] = 1.57
aln.params["mui_ext_mean"] = 1.6
aln.params["sigma_ou"] = 0.09
aln.params["b"] = 5.0
aln.params["duration"] = 0.2 * 60 * 1000
aln.run(bold=True, chunkwise=True)
cls.model = aln
cls.ds = Dataset("gw")
cls.single_node = ALNModel()
def test_single_node(self):
logging.info("\t > ALN: Testing single node ...")
start = time.time()
aln = ALNModel()
aln.params["duration"] = 10.0 * 1000
aln.params["sigma_ou"] = 0.1 # add some noise
# load new initial parameters
aln.run(bold=True)
# access outputs
aln.xr()
aln.xr("BOLD")
end = time.time()
logging.info("\t > Done in {:.2f} s".format(end - start))
def setUpClass(cls):
ds = Dataset("hcp")
model = ALNModel(Cmat=ds.Cmat, Dmat=ds.Dmat)
model.params.duration = 11 * 1000 # ms
model.params.dt = 0.2
parameters = ParameterSpace(
{
"mue_ext_mean": np.linspace(0, 3, 2),
"mui_ext_mean": np.linspace(0, 3, 2),
"b": [0.0, 10.0],
},
kind="grid",
)
search = BoxSearch(
model=model,
parameterSpace=parameters,
filename=f"test_exploration_utils_{randomString(20)}.hdf")
search.run(chunkwise=True, bold=True)
search.loadResults()
cls.model = model
cls.search = search
cls.ds = ds
def test_model_imports(self):
from neurolib.models.hopf import HopfModel
hopf = HopfModel()
from neurolib.models.aln import ALNModel
aaln = ALNModel()
from neurolib.models.fhn import FHNModel
def test_sampling_dt_lower_than_duration(self):
model = ALNModel()
model.params["dt"] = 0.1 # 0.1 ms
model.params["duration"] = 10
model.params["sampling_dt"] = 30
with self.assertRaises(AssertionError):
model.run()
def setUpClass(cls):
ds = Dataset("gw")
aln = ALNModel(Cmat=ds.Cmat, Dmat=ds.Dmat, simulateBOLD=True, chunkSize=500)
# Resting state fits
aln.params["mue_ext_mean"] = 1.57
aln.params["mui_ext_mean"] = 1.6
aln.params["sigma_ou"] = 0.09
aln.params["b"] = 5.0
aln.params["duration"] = 0.2 * 60 * 1000
aln.run()
cls.model = aln
cls.ds = Dataset("gw")
def brainanal(self):
print("You're choose Brain Analytics \n")
#Frekuensi Brain
modelf = ALNModel()
modelf.params['sigma_ou'] = 0.5 #Add some noise from brain
modelf.run()
plotmodel.plot(modelf.t, model.output.T)
print("Frekuensi Brain accept some noise \n")
#Data activity Brain
datasetmodel = DataSet("gw")
modelactivity = ALNModel(Cmat=datasetmodel.Cmat,
Dmat=datasetmodel.Dmat)
modelactivity.params[
'duration'] = 1 * 60 * 1000 #Time simulation brain activity #One minutes simulation
modelactivity.run(bold=True)
print("Simulation activity sel on Brain \n")
def test_onstep_input_autochunk(self):
"""Tests passing an input array to a model."""
model = ALNModel()
model.params["duration"] = 1000
duration_dt = int(model.params["duration"] / model.params["dt"])
ous = np.zeros((model.params["N"], duration_dt))
# prepare input
inp_x = np.zeros((model.params["N"], duration_dt))
inp_y = np.zeros((model.params["N"], duration_dt))
for n in range(model.params["N"]):
fr = 1
inp_x[n, :] = np.sin(np.linspace(0, fr * 2 * np.pi,
duration_dt)) * 0.1
for i in range(duration_dt):
inputs = [inp_x[:, i], inp_y[:, i]]
model.autochunk(inputs=inputs, append_outputs=True)
def test_network(self):
logging.info("\t > ALN: Testing brain network (chunkwise integration and BOLD" " simulation) ...")
start = time.time()
ds = Dataset("gw")
aln = ALNModel(Cmat=ds.Cmat, Dmat=ds.Dmat)
aln.params["duration"] = 10 * 1000
aln.run(chunkwise=True, bold=True, append_outputs=True)
# access outputs
aln.xr()
aln.xr("BOLD")
end = time.time()
logging.info("\t > Done in {:.2f} s".format(end - start))
def setUpClass(cls):
np.random.seed(42)
aln = ALNModel()
# simulate 10 seconds
aln.params["duration"] = 10.0 * 1000
aln.params["sigma_ou"] = 0.1 # add some noise
aln.run()
# init RatesSignal
cls.signal = RatesSignal.from_model_output(aln)
def test_subsample_aln(self):
model = ALNModel()
model.params["duration"] = 100 # 100 ms
model.params["dt"] = 0.1 # 0.1 ms
# default behaviour should be no subsampling
self.assertIs(model.params.get("sampling_dt", None), None)
model.run()
full_output = model.output.copy()
# subsample the same model
model.params["sampling_dt"] = 10 # 10 ms
model.run()
subsample_output = model.output.copy()
sample_every = int(model.params["sampling_dt"] / model.params["dt"])
self.assertEqual(
full_output[:, ::sample_every].shape[1], subsample_output.shape[1]
), "Subsampling returned unexpected output shape"
self.assertTrue(
(full_output[:, ::sample_every] == subsample_output).all()
), "Subsampling returned unexpected output values"
def test_single_node(self):
start = time.time()
model = ALNModel()
parameters = ParameterSpace({"mue_ext_mean": np.linspace(0, 3, 2), "mui_ext_mean": np.linspace(0, 3, 2)})
search = BoxSearch(model, parameters, filename="test_single_nodes.hdf")
search.run()
search.loadResults()
for i in search.dfResults.index:
search.dfResults.loc[i, "max_r"] = np.max(
search.results[i]["rates_exc"][:, -int(1000 / model.params["dt"]) :]
)
end = time.time()
logging.info("\t > Done in {:.2f} s".format(end - start))
def setUpClass(cls):
# def test_brain_network_postprocessing(self):
ds = Dataset("hcp")
model = ALNModel(Cmat=ds.Cmat, Dmat=ds.Dmat)
# Resting state fits
model.params["mue_ext_mean"] = 1.57
model.params["mui_ext_mean"] = 1.6
model.params["sigma_ou"] = 0.09
model.params["b"] = 5.0
model.params["signalV"] = 2
model.params["dt"] = 0.2
model.params["duration"] = 0.2 * 60 * 1000
# multi stage evaluation function
def evaluateSimulation(traj):
model = search.getModelFromTraj(traj)
model.randomICs()
model.params["dt"] = 0.2
model.params["duration"] = 4 * 1000.0
model.run(bold=True)
result_dict = {"outputs": model.outputs}
search.saveToPypet(result_dict, traj)
# define and run exploration
parameters = ParameterSpace({
"mue_ext_mean": np.linspace(0, 3, 2),
"mui_ext_mean": np.linspace(0, 3, 2)
})
search = BoxSearch(
evalFunction=evaluateSimulation,
model=model,
parameterSpace=parameters,
filename=f"test_brain_postprocessing_{randomString(20)}.hdf",
)
search.run()
cls.model = model
cls.search = search
cls.ds = ds
def test_compare_w_neurolib_native_model(self):
"""
Compare with neurolib's native ALN model.
"""
# run this model
aln_multi = self._create_node()
multi_result = aln_multi.run(
DURATION, DT, ZeroInput(aln_multi.num_noise_variables).as_array(DURATION, DT), backend="numba"
)
# run neurolib's model
aln_neurolib = ALNModel(seed=SEED)
aln_neurolib.params["duration"] = DURATION
aln_neurolib.params["dt"] = DT
aln_neurolib.params["mue_ext_mean"] = 0.0
aln_neurolib.params["mui_ext_mean"] = 0.0
aln_neurolib.run()
for (var_multi, var_neurolib) in NEUROLIB_VARIABLES_TO_TEST:
corr_mat = np.corrcoef(aln_neurolib[var_neurolib], multi_result[var_multi].values.T)
self.assertTrue(np.greater(corr_mat, CORR_THRESHOLD).all())
def test_single_node(self):
logging.info("\t > ALN: Testing single node ...")
start = time.time()
aln = ALNModel()
aln.params["duration"] = 2.0 * 1000
aln.params["sigma_ou"] = 0.1 # add some noise
aln.run()
end = time.time()
logging.info("\t > Done in {:.2f} s".format(end - start))
def test_single_node(self):
logging.info("\t > BoxSearch: Testing ALN single node ...")
start = time.time()
aln = ALNModel()
parameters = ParameterSpace({
"mue_ext_mean": np.linspace(0, 3, 2),
"mui_ext_mean": np.linspace(0, 3, 2)
})
search = BoxSearch(aln, parameters)
search.run()
search.loadResults()
for i in search.dfResults.index:
search.dfResults.loc[i, "max_r"] = np.max(
search.results[i]["rates_exc"][:,
-int(1000 / aln.params["dt"]):])
end = time.time()
logging.info("\t > Done in {:.2f} s".format(end - start))
def test_sampling_dt_invalid(self):
model = ALNModel()
model.params["sampling_dt"] = -30
with self.assertRaises(ValueError):
model.run()
def test_sampling_dt_smaller_than_dt(self):
model = ALNModel()
model.params["dt"] = 10 # 0.1 ms
model.params["sampling_dt"] = 9
with self.assertRaises(AssertionError):
model.run()
def test_compare_w_neurolib_native_model(self):
"""
Compare with neurolib's native ALN model.
Marked with xfail, since sometimes fail on specific python version on
Linux, no idea why, but the model works...
"""
aln_multi = ALNNetwork(self.SC,
self.DELAYS,
exc_seed=SEED,
inh_seed=SEED)
multi_result = aln_multi.run(
DURATION,
DT,
ZeroInput(aln_multi.num_noise_variables).as_array(DURATION, DT),
backend="numba")
# run neurolib's model
aln_neurolib = ALNModel(Cmat=self.SC, Dmat=self.DELAYS, seed=SEED)
aln_neurolib.params["duration"] = DURATION
aln_neurolib.params["dt"] = DT
# there is no "global coupling" parameter in MultiModel
aln_neurolib.params["K_gl"] = 1.0
# delays <-> length matrix
aln_neurolib.params["signalV"] = 1.0
aln_neurolib.params["sigma_ou"] = 0.0
aln_neurolib.params["mue_ext_mean"] = 0.0
aln_neurolib.params["mui_ext_mean"] = 0.0
# match initial state at least for current - this seems to be enough
aln_neurolib.params["mufe_init"] = np.array([
aln_multi[0][0].initial_state[0], aln_multi[1][0].initial_state[0]
])
aln_neurolib.params["mufi_init"] = np.array([
aln_multi[0][1].initial_state[0], aln_multi[1][1].initial_state[0]
])
aln_neurolib.run()
for (var_multi, var_neurolib) in NEUROLIB_VARIABLES_TO_TEST:
for node_idx in range(len(aln_multi)):
corr_mat = np.corrcoef(
aln_neurolib[var_neurolib][node_idx, :],
multi_result[var_multi].values.T[node_idx, :])
print(corr_mat)
self.assertTrue(np.greater(corr_mat, CORR_THRESHOLD).all())
def test_sampling_dt_divisible_last_chunksize(self):
model = ALNModel()
model.params["dt"] = 0.1 # 0.1 ms
model.params["sampling_dt"] = 0.21
with self.assertRaises(AssertionError):
model.run(chunksize=210)
def test_sampling_dt_greater_than_chunksize(self):
model = ALNModel()
model.params["dt"] = 0.1 # 0.1 ms
model.params["sampling_dt"] = 30
with self.assertRaises(AssertionError):
model.run(chunksize=210)
def test_brain_network(self):
from neurolib.utils.loadData import Dataset
ds = Dataset("hcp")
aln = ALNModel(Cmat=ds.Cmat, Dmat=ds.Dmat, bold=True)
# Resting state fits
aln.params["mue_ext_mean"] = 1.57
aln.params["mui_ext_mean"] = 1.6
aln.params["sigma_ou"] = 0.09
aln.params["b"] = 5.0
aln.params["signalV"] = 2
aln.params["dt"] = 0.2
aln.params["duration"] = 0.2 * 60 * 1000
# multi stage evaluation function
def evaluateSimulation(traj):
model = search.getModelFromTraj(traj)
defaultDuration = model.params["duration"]
invalid_result = {"fc": [0] * len(ds.BOLDs)}
# -------- stage wise simulation --------
# Stage 1 : simulate for a few seconds to see if there is any activity
# ---------------------------------------
model.params["dt"] = 0.1
model.params["duration"] = 3 * 1000.0
model.run()
# check if stage 1 was successful
if np.max(model.rates_exc[:, model.t > 500]) > 300 or np.max(
model.rates_exc[:, model.t > 500]) < 10:
search.saveOutputsToPypet(invalid_result, traj)
return invalid_result, {}
# Stage 2: simulate BOLD for a few seconds to see if it moves
# ---------------------------------------
model.params["dt"] = 0.2
model.params["duration"] = 20 * 1000.0
model.run(bold=True)
if np.std(model.BOLD.BOLD[:, 5:10]) < 0.001:
search.saveOutputsToPypet(invalid_result, traj)
return invalid_result, {}
# Stage 3: full and final simulation
# ---------------------------------------
model.params["dt"] = 0.2
model.params["duration"] = defaultDuration
model.run()
# -------- evaluation here --------
scores = []
for i, fc in enumerate(ds.FCs): # range(len(ds.FCs)):
fc_score = func.matrix_correlation(
func.fc(model.BOLD.BOLD[:, 5:]), fc)
scores.append(fc_score)
meanScore = np.mean(scores)
result_dict = {"fc": meanScore}
search.saveOutputsToPypet(result_dict, traj)
# define and run exploration
parameters = ParameterSpace({
"mue_ext_mean": np.linspace(0, 3, 2),
"mui_ext_mean": np.linspace(0, 3, 2)
})
search = BoxSearch(evalFunction=evaluateSimulation,
model=aln,
parameterSpace=parameters)
search.run()
