Example #1
0
    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))
Example #2
0
 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()
Example #3
0
    def test_subsample_aln_chunkwise(self):
        model = ALNModel(seed=42)
        model.params["sigma_ou"] = 0.0
        model.params["duration"] = 1000  # 1000 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(chunksize=3000)
        full_output = model.output.copy()

        # subsample the model (same seed)
        model = ALNModel(seed=42)
        model.params["sigma_ou"] = 0.0
        model.params["duration"] = 1000  # 1000 ms
        model.params["dt"] = 0.1  # 0.1 ms
        model.params["sampling_dt"] = 10.0  # 10 ms
        model.run(chunksize=3000)
        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"
Example #4
0
    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)
Example #5
0
 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)
Example #6
0
    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))
Example #7
0
    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")
Example #8
0
    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))
Example #9
0
    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")
Example #10
0
    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))
Example #11
0
 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())
Example #12
0
 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())
Example #13
0
 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)
Example #14
0
 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)
Example #15
0
 def test_sampling_dt_invalid(self):
     model = ALNModel()
     model.params["sampling_dt"] = -30
     with self.assertRaises(ValueError):
         model.run()
Example #16
0
 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()