Exemple #1
0
 def test_compute_x_odd(self):
     with tasks.ParameterEstimation.Context(self.pe_mod,
                                            self.fname,
                                            context='pl',
                                            parameters='g') as context:
         context.set('method', 'nl2sol')
         context.set('tolerance', 1e-1)
         context.set('iteration_limit', 5)
         context.set('run_mode', True)
         context.set('pe_number', 10)
         config = context.get_config()
     pl = tasks.ParameterEstimation(config)
     data = viz.Parse(pl).data
     p = viz.PlotProfileLikelihoods(self.pe_mod, pl, 1.2)
     print(p.compute_x())
Exemple #2
0
 def test_parse(self):
     with tasks.ParameterEstimation.Context(self.pe_mod,
                                            self.fname,
                                            context='pl',
                                            parameters='g') as context:
         context.set('method', 'hooke_jeeves')
         context.set('tolerance', 1e-1)
         context.set('iteration_limit', 5)
         context.set('run_mode', True)
         context.set('pe_number', 10)
         config = context.get_config()
     pe = tasks.ParameterEstimation(config)
     data = viz.Parse(pe).data['A2B']
     expected = (10, 5)
     actual = data.shape
     self.assertEqual(expected, actual)
Exemple #3
0
 def test_plotcl(self):
     with tasks.ParameterEstimation.Context(self.pe_mod,
                                            self.fname,
                                            context='pl',
                                            parameters='g') as context:
         context.set('method', 'hooke_jeeves')
         context.set('run_mode', True)
         context.set('pe_number', 10)
         context.set('prefix', '_')
         context.set('nproc', 5)
         config = context.get_config()
     pl = tasks.ParameterEstimation(config)
     p = viz.PlotProfileLikelihoods(self.pe_mod, pl, self.rss)
     filename = os.path.join(os.path.dirname(__file__), 'plt.png')
     p.plot(x='all', y='RSS', ncol=2, filename=None)
     self.assertTrue(os.path.isfile(filename))
Exemple #4
0
 def test_compute_plot3(self):
     with tasks.ParameterEstimation.Context(self.pe_mod,
                                            self.fname,
                                            context='pl',
                                            parameters='g') as context:
         context.set('method', 'nl2sol')
         context.set('tolerance', 1e-1)
         context.set('iteration_limit', 5)
         context.set('run_mode', True)
         context.set('pe_number', 10)
         config = context.get_config()
     pl = tasks.ParameterEstimation(config)
     p = viz.PlotProfileLikelihoods(self.pe_mod, pl, self.rss)
     filename = os.path.join(os.path.dirname(__file__), 'plt.png')
     p.plot(x='all', y='C2A_k1', ncol=2, savefig=False, filename=filename)
     self.assertTrue(os.path.isfile(filename))
Exemple #5
0
 def test_num_data_points(self):
     with tasks.ParameterEstimation.Context(self.pe_mod,
                                            self.fname,
                                            context='pl',
                                            parameters='g') as context:
         context.set('method', 'nl2sol')
         context.set('tolerance', 1e-1)
         context.set('iteration_limit', 5)
         context.set('run_mode', True)
         context.set('pe_number', 10)
         config = context.get_config()
     pl = tasks.ParameterEstimation(config)
     p = viz.PlotProfileLikelihoods(self.pe_mod, pl, 1.2)
     expected = 99
     actual = p.num_data_points()
     self.assertEqual(expected, actual)
Exemple #6
0
    def test(self):
        """
        Returns:

        """
        with tasks.ParameterEstimation.Context(self.model,
                                               self.fname,
                                               context='pl',
                                               parameters='g') as context:
            context.set('method', 'hooke_jeeves')
            context.set('run_mode', True)
            config = context.get_config()
        pe = tasks.ParameterEstimation(config)
        expected = 11
        actual = viz.Parse(pe)['A2B'].shape[0]
        self.assertEqual(expected, actual)
Exemple #7
0
    def test_run(self):
        """
        Returns:

        """
        with tasks.ParameterEstimation.Context(self.pe_mod,
                                               self.fname,
                                               context='pl',
                                               parameters='g') as context:
            context.set('method', 'nl2sol')
            context.set('run_mode', True)
            context.set('pe_number', 12)
            config = context.get_config()
        pe = tasks.ParameterEstimation(config)
        expected = 12
        data = viz.Parse(pe)['A2B']
        actual = data.shape[0]
        self.assertEqual(expected, actual)
Exemple #8
0
    def setUp(self):
        super(ProfileLikelihoodTests, self).setUp()
        self.fname = os.path.join(os.path.dirname(__file__), 'timecourse.txt')
        self.data = self.model.simulate(0, 10, 1, report_name=self.fname)

        with tasks.ParameterEstimation.Context(self.model,
                                               self.fname,
                                               context='s',
                                               parameters='g') as context:
            context.set('method', 'hooke_jeeves')
            context.set('run_mode', True)
            context.set('randomize_start_values', True)
            config = context.get_config()
        self.pe = tasks.ParameterEstimation(config)
        data = viz.Parse(self.pe).data
        self.rss = data.loc[0, 'RSS']
        self.pe_mod = self.pe.models['test_model'].model
        self.pe_mod.insert_parameters(df=data, index=0, inplace=True)
Exemple #9
0
 def test_compute_x(self):
     with tasks.ParameterEstimation.Context(self.pe_mod,
                                            self.fname,
                                            context='pl',
                                            parameters='g') as context:
         context.set('method', 'nl2sol')
         context.set('tolerance', 1e-1)
         context.set('iteration_limit', 5)
         context.set('run_mode', True)
         context.set('pe_number', 10)
         config = context.get_config()
     pl = tasks.ParameterEstimation(config)
     data = viz.Parse(pl).data
     p = viz.PlotProfileLikelihoods(self.pe_mod, pl, 1.2)
     x = p.compute_x()
     expected = (10, 5)
     actual = x.shape
     self.assertEqual(expected, actual)
Exemple #10
0
    def setUp(self):
        super(BoxPlotTests, self).setUp()

        fname = os.path.join(os.path.dirname(__file__), 'report1.txt')
        data = self.model.simulate(0, 50, 1, report_name=fname)

        with tasks.ParameterEstimation.Context(
                self.model, fname, context='s', parameters='g',
        ) as context:
            context.set('method', 'genetic_algorithm')
            context.set('population_size', 2)
            context.set('number_of_generations', 5)
            context.set('copy_number', 2)
            context.set('pe_number', 2)
            context.set('run_mode', True)
            config = context.get_config()

        self.pe = tasks.ParameterEstimation(config)
Exemple #11
0
    def setUp(self):
        super(ProfileLikelihoodTests, self).setUp()
        ant_str = """
        model new_model
            R1: A -> B ; _k1*A;
            R2: B -> A; k2*B;
            R3: C -> D; _k3*C*B;
            R4: D -> C; k4*D;
            
            A = 100;
            B = 0;
            _k1=0.1;
            k2 = 0.01
            _k3 = 0.01
            k4 = 1
        end
        """
        self.copasi_file = os.path.join(os.path.dirname(__file__),
                                        'test_model.cps')
        self.model = model.loada(ant_str, self.copasi_file)
        self.fname = os.path.join(os.path.dirname(__file__), 'timecourse.txt')
        self.data = self.model.simulate(0, 10, 1, report_name=self.fname)

        with tasks.ParameterEstimation.Context(self.model,
                                               self.fname,
                                               context='s',
                                               parameters='g') as context:
            context.set('method', 'hooke_jeeves')
            context.set('run_mode', True)
            context.set('prefix', '_')
            context.set('randomize_start_values', True)
            config = context.get_config()
        self.pe = tasks.ParameterEstimation(config)
        data = viz.Parse(self.pe).data['test_model']
        self.rss = data.loc[0, 'RSS']
        self.pe_mod = self.pe.models['test_model'].model
        self.pe_mod.insert_parameters(df=data, index=0, inplace=True)
Exemple #12
0
            #context.set('randomize_start_values', True)
            context.set('separator', ',')
            context.set('method', 'hooke_jeeves')
            context.set('pl_lower_bound', 1000)
            context.set('pl_upper_bound', 1000)
            #context.set('population_size', 50)
            #context.set('number_of_generations', 300)
            context.set('run_mode', True)  ##defaults to False
            context.set('pe_number', 3)  ## number of repeat items in scan task
            #context.set('copy_number', 2)  ## number of times to copy model
            #context.set('problem', 'Problem1')
            #context.set('fit', 3)
            #context.set('prefix', 'k')
        config = context.get_config()

        pe = tasks.ParameterEstimation(config)

        #myPctMod.open()
        data = viz.Parse(pe)
        print(data)

    myExMod = model.loada(model_string_ex, copasi_ex_filename)

    def my_add_cols(inFName, outFName, sState, i1State, i2State):
        myData = pd.read_csv(
            os.path.join(os.path.dirname(working_directory), 'data', inFName))
        myData.insert(len(myData.columns), 'S_indep', sState)
        myData.insert(len(myData.columns), 'I1_indep', i1State)
        myData.insert(len(myData.columns), 'I2_indep', i2State)
        myData.rename(columns={
            "pN": "Np",
Exemple #13
0
    def setUp(self):
        ant1 = """

        model first()
            compartment Cell = 1;

            R1: A => B ; Cell * k1 * A;
            R2: B => C ; Cell * k2 * B;
            R3: C => A ; Cell * k3 * C;

            k1 = 0.1;
            k2 = 0.1;
            k3 = 0.1;

            A = 100;
            B = 0;
            C = 0;
        end
        """

        ant2 = """

        model second()
            compartment Cell = 1;

            R1: A => B ; Cell * k1 * A;
            R2: B => C ; Cell * k2 * B;
            R3: B => A ; Cell * k3 * B;

            k1 = 0.1;
            k2 = 0.1;
            k3 = 0.1;

            A = 100;
            B = 0;
            C = 0;
        end
        """
        self.fname1 = os.path.join(os.path.dirname(__file__), 'first.cps')
        self.fname2 = os.path.join(os.path.dirname(__file__), 'second.cps')

        with model.BuildAntimony(self.fname1) as loader:
            self.mod1 = loader.load(ant1)

        with model.BuildAntimony(self.fname2) as loader:
            self.mod2 = loader.load(ant2)

        self.fname1 = os.path.join(os.path.dirname(__file__), 'dataset1.txt')
        self.fname2 = os.path.join(os.path.dirname(__file__), 'dataset2.txt')

        self.mod1.simulate(0, 9, 1, report_name=self.fname1)
        self.mod2.simulate(0, 9, 1, report_name=self.fname2)

        with tasks.ParameterEstimation.Context(
                [self.mod1, self.mod2], [self.fname1, self.fname2],
                context='s', parameters='g'
        ) as context:
            self.config = context.get_config()

        config_dct = dict(
            models=dict(
                first=dict(
                    copasi_file=self.mod1.copasi_file,
                ),
                second=dict(
                    copasi_file=self.mod2.copasi_file
                )
            ),
            datasets=dict(
                experiments=dict(
                    first_exp=dict(
                        filename=self.fname1
                    ),
                    second_exp=dict(
                        filename=self.fname2
                    )
                )
            ),
            items=dict(
                fit_items='g'
            ),
            settings=dict(
                working_directory=os.path.dirname(__file__),
                run_mode=True,
                method='genetic_algorithm',
                population_size=5,
                number_of_generations=25
            )
        )
        self.config = tasks.ParameterEstimation.Config(**config_dct)
        self.pe = tasks.ParameterEstimation(self.config)