Test your AI Agents with the all-new Agent to Agent Testing Platform.Learn More

How to use param_names method in Slash

Best Python code snippet using slash

test_problems.py

Source:test_problems.py

1#2# This file is part of the chi repository3# (https://github.com/DavAug/chi/) which is released under the4# BSD 3-clause license. See accompanying LICENSE.md for copyright notice and5# full license details.6#7import copy8import unittest9import numpy as np10import pandas as pd11import pints12import chi13from chi.library import ModelLibrary14class TestProblemModellingControllerPDProblem(unittest.TestCase):15    """16    Tests the chi.ProblemModellingController class on a PD modelling17    problem.18    """19    @classmethod20    def setUpClass(cls):21        # Create test dataset22        ids_v = [0, 0, 0, 1, 1, 1, 2, 2]23        times_v = [0, 1, 2, 2, np.nan, 4, 1, 3]24        volumes = [np.nan, 0.3, 0.2, 0.5, 0.1, 0.2, 0.234, np.nan]25        ids_c = [0, 0, 1, 1]26        times_c = [0, 1, 2, np.nan]27        cytokines = [3.4, 0.3, 0.5, np.nan]28        ids_d = [0, 1, 1, 1, 2, 2]29        times_d = [0, np.nan, 4, 1, 3, 3]30        dose = [3.4, np.nan, 0.5, 0.5, np.nan, np.nan]31        duration = [0.01, np.nan, 0.31, np.nan, 0.5, np.nan]32        ids_cov = [0, 1, 2]33        times_cov = [np.nan, 1, np.nan]34        age = [10, 14, 12]35        cls.data = pd.DataFrame({36            'ID': ids_v + ids_c + ids_d + ids_cov,37            'Time': times_v + times_c + times_d + times_cov,38            'Observable':39                ['Tumour volume'] * 8 + ['IL 6'] * 4 + [np.nan] * 6 +40                ['Age'] * 3,41            'Value': volumes + cytokines + [np.nan] * 6 + age,42            'Dose': [np.nan] * 12 + dose + [np.nan] * 3,43            'Duration': [np.nan] * 12 + duration + [np.nan] * 3})44        # Test case I: create PD modelling problem45        lib = ModelLibrary()46        path = lib.tumour_growth_inhibition_model_koch()47        cls.pd_model = chi.PharmacodynamicModel(path)48        cls.error_model = chi.ConstantAndMultiplicativeGaussianErrorModel()49        cls.pd_problem = chi.ProblemModellingController(50            cls.pd_model, cls.error_model)51        # Test case II: create PKPD modelling problem52        lib = ModelLibrary()53        path = lib.erlotinib_tumour_growth_inhibition_model()54        cls.pkpd_model = chi.PharmacokineticModel(path)55        cls.pkpd_model.set_outputs([56            'central.drug_concentration',57            'myokit.tumour_volume'])58        cls.error_models = [59            chi.ConstantAndMultiplicativeGaussianErrorModel(),60            chi.ConstantAndMultiplicativeGaussianErrorModel()]61        cls.pkpd_problem = chi.ProblemModellingController(62            cls.pkpd_model, cls.error_models,63            outputs=[64                'central.drug_concentration',65                'myokit.tumour_volume'])66    def test_bad_input(self):67        # Mechanistic model has wrong type68        mechanistic_model = 'wrong type'69        with self.assertRaisesRegex(TypeError, 'The mechanistic model'):70            chi.ProblemModellingController(71                mechanistic_model, self.error_model)72        # Error model has wrong type73        error_model = 'wrong type'74        with self.assertRaisesRegex(TypeError, 'Error models have to be'):75            chi.ProblemModellingController(76                self.pd_model, error_model)77        error_models = ['wrong', 'type']78        with self.assertRaisesRegex(TypeError, 'Error models have to be'):79            chi.ProblemModellingController(80                self.pd_model, error_models)81        # Wrong number of error models82        error_model = chi.ConstantAndMultiplicativeGaussianErrorModel()83        with self.assertRaisesRegex(ValueError, 'Wrong number of error'):84            chi.ProblemModellingController(85                self.pkpd_model, error_model)86        error_models = [87            chi.ConstantAndMultiplicativeGaussianErrorModel(),88            chi.ConstantAndMultiplicativeGaussianErrorModel()]89        with self.assertRaisesRegex(ValueError, 'Wrong number of error'):90            chi.ProblemModellingController(91                self.pd_model, error_models)92    def test_fix_parameters(self):93        # Test case I: PD model94        # Fix model parameters95        name_value_dict = dict({96            'myokit.drug_concentration': 0,97            'Sigma base': 1})98        self.pd_problem.fix_parameters(name_value_dict)99        self.assertEqual(self.pd_problem.get_n_parameters(), 5)100        param_names = self.pd_problem.get_parameter_names()101        self.assertEqual(len(param_names), 5)102        self.assertEqual(param_names[0], 'myokit.tumour_volume')103        self.assertEqual(param_names[1], 'myokit.kappa')104        self.assertEqual(param_names[2], 'myokit.lambda_0')105        self.assertEqual(param_names[3], 'myokit.lambda_1')106        self.assertEqual(param_names[4], 'Sigma rel.')107        # Free and fix a parameter108        name_value_dict = dict({109            'myokit.lambda_1': 2,110            'Sigma base': None})111        self.pd_problem.fix_parameters(name_value_dict)112        self.assertEqual(self.pd_problem.get_n_parameters(), 5)113        param_names = self.pd_problem.get_parameter_names()114        self.assertEqual(len(param_names), 5)115        self.assertEqual(param_names[0], 'myokit.tumour_volume')116        self.assertEqual(param_names[1], 'myokit.kappa')117        self.assertEqual(param_names[2], 'myokit.lambda_0')118        self.assertEqual(param_names[3], 'Sigma base')119        self.assertEqual(param_names[4], 'Sigma rel.')120        # Free all parameters again121        name_value_dict = dict({122            'myokit.lambda_1': None,123            'myokit.drug_concentration': None})124        self.pd_problem.fix_parameters(name_value_dict)125        self.assertEqual(self.pd_problem.get_n_parameters(), 7)126        param_names = self.pd_problem.get_parameter_names()127        self.assertEqual(len(param_names), 7)128        self.assertEqual(param_names[0], 'myokit.tumour_volume')129        self.assertEqual(param_names[1], 'myokit.drug_concentration')130        self.assertEqual(param_names[2], 'myokit.kappa')131        self.assertEqual(param_names[3], 'myokit.lambda_0')132        self.assertEqual(param_names[4], 'myokit.lambda_1')133        self.assertEqual(param_names[5], 'Sigma base')134        self.assertEqual(param_names[6], 'Sigma rel.')135        # Fix parameters before setting a population model136        problem = copy.copy(self.pd_problem)137        name_value_dict = dict({138            'myokit.tumour_volume': 1,139            'myokit.drug_concentration': 0,140            'myokit.kappa': 1,141            'myokit.lambda_1': 2})142        problem.fix_parameters(name_value_dict)143        problem.set_population_model(144            pop_models=[145                chi.HeterogeneousModel(),146                chi.PooledModel(),147                chi.LogNormalModel()])148        problem.set_data(149            self.data,150            output_observable_dict={'myokit.tumour_volume': 'Tumour volume'})151        n_ids = 3152        self.assertEqual(problem.get_n_parameters(), 2 * n_ids + 1 + 2)153        param_names = problem.get_parameter_names()154        self.assertEqual(len(param_names), 9)155        self.assertEqual(param_names[0], 'ID 0: myokit.lambda_0')156        self.assertEqual(param_names[1], 'ID 1: myokit.lambda_0')157        self.assertEqual(param_names[2], 'ID 2: myokit.lambda_0')158        self.assertEqual(param_names[3], 'Pooled Sigma base')159        self.assertEqual(param_names[4], 'ID 0: Sigma rel.')160        self.assertEqual(param_names[5], 'ID 1: Sigma rel.')161        self.assertEqual(param_names[6], 'ID 2: Sigma rel.')162        self.assertEqual(param_names[7], 'Mean log Sigma rel.')163        self.assertEqual(param_names[8], 'Std. log Sigma rel.')164        # Fix parameters after setting a population model165        # (Only population models can be fixed)166        name_value_dict = dict({167            'ID 1: myokit.lambda_0': 1,168            'ID 2: myokit.lambda_0': 4,169            'Pooled Sigma base': 2})170        problem.fix_parameters(name_value_dict)171        # self.assertEqual(problem.get_n_parameters(), 8)172        param_names = problem.get_parameter_names()173        self.assertEqual(len(param_names), 8)174        self.assertEqual(param_names[0], 'ID 0: myokit.lambda_0')175        self.assertEqual(param_names[1], 'ID 1: myokit.lambda_0')176        self.assertEqual(param_names[2], 'ID 2: myokit.lambda_0')177        self.assertEqual(param_names[3], 'ID 0: Sigma rel.')178        self.assertEqual(param_names[4], 'ID 1: Sigma rel.')179        self.assertEqual(param_names[5], 'ID 2: Sigma rel.')180        self.assertEqual(param_names[6], 'Mean log Sigma rel.')181        self.assertEqual(param_names[7], 'Std. log Sigma rel.')182        # Test case II: PKPD model183        # Fix model parameters184        name_value_dict = dict({185            'myokit.kappa': 0,186            'central.drug_concentration Sigma base': 1})187        self.pkpd_problem.fix_parameters(name_value_dict)188        self.assertEqual(self.pkpd_problem.get_n_parameters(), 9)189        param_names = self.pkpd_problem.get_parameter_names()190        self.assertEqual(len(param_names), 9)191        self.assertEqual(param_names[0], 'central.drug_amount')192        self.assertEqual(param_names[1], 'myokit.tumour_volume')193        self.assertEqual(param_names[2], 'central.size')194        self.assertEqual(param_names[3], 'myokit.critical_volume')195        self.assertEqual(param_names[4], 'myokit.elimination_rate')196        self.assertEqual(param_names[5], 'myokit.lambda')197        self.assertEqual(198            param_names[6], 'central.drug_concentration Sigma rel.')199        self.assertEqual(param_names[7], 'myokit.tumour_volume Sigma base')200        self.assertEqual(param_names[8], 'myokit.tumour_volume Sigma rel.')201        # Free and fix a parameter202        name_value_dict = dict({203            'myokit.lambda': 2,204            'myokit.kappa': None})205        self.pkpd_problem.fix_parameters(name_value_dict)206        self.assertEqual(self.pkpd_problem.get_n_parameters(), 9)207        param_names = self.pkpd_problem.get_parameter_names()208        self.assertEqual(len(param_names), 9)209        self.assertEqual(param_names[0], 'central.drug_amount')210        self.assertEqual(param_names[1], 'myokit.tumour_volume')211        self.assertEqual(param_names[2], 'central.size')212        self.assertEqual(param_names[3], 'myokit.critical_volume')213        self.assertEqual(param_names[4], 'myokit.elimination_rate')214        self.assertEqual(param_names[5], 'myokit.kappa')215        self.assertEqual(216            param_names[6], 'central.drug_concentration Sigma rel.')217        self.assertEqual(param_names[7], 'myokit.tumour_volume Sigma base')218        self.assertEqual(param_names[8], 'myokit.tumour_volume Sigma rel.')219        # Free all parameters again220        name_value_dict = dict({221            'myokit.lambda': None,222            'central.drug_concentration Sigma base': None})223        self.pkpd_problem.fix_parameters(name_value_dict)224        self.assertEqual(self.pkpd_problem.get_n_parameters(), 11)225        param_names = self.pkpd_problem.get_parameter_names()226        self.assertEqual(len(param_names), 11)227        self.assertEqual(param_names[0], 'central.drug_amount')228        self.assertEqual(param_names[1], 'myokit.tumour_volume')229        self.assertEqual(param_names[2], 'central.size')230        self.assertEqual(param_names[3], 'myokit.critical_volume')231        self.assertEqual(param_names[4], 'myokit.elimination_rate')232        self.assertEqual(param_names[5], 'myokit.kappa')233        self.assertEqual(param_names[6], 'myokit.lambda')234        self.assertEqual(235            param_names[7], 'central.drug_concentration Sigma base')236        self.assertEqual(237            param_names[8], 'central.drug_concentration Sigma rel.')238        self.assertEqual(param_names[9], 'myokit.tumour_volume Sigma base')239        self.assertEqual(param_names[10], 'myokit.tumour_volume Sigma rel.')240    def test_fix_parameters_bad_input(self):241        # Input is not a dictionary242        name_value_dict = 'Bad type'243        with self.assertRaisesRegex(ValueError, 'The name-value dictionary'):244            self.pd_problem.fix_parameters(name_value_dict)245    def test_get_covariate_names(self):246        # Test case I: PD model247        problem = copy.deepcopy(self.pd_problem)248        # I.1: No population model249        names = problem.get_covariate_names()250        self.assertEqual(len(names), 0)251        # I.2: Population model but no covariate population model252        pop_models = [chi.PooledModel()] * 7253        problem.set_population_model(pop_models)254        names = problem.get_covariate_names()255        self.assertEqual(len(names), 0)256        names = problem.get_covariate_names(unique=False)257        self.assertEqual(len(names), 7)258        self.assertEqual(names[0], [])259        self.assertEqual(names[1], [])260        self.assertEqual(names[2], [])261        self.assertEqual(names[3], [])262        self.assertEqual(names[3], [])263        self.assertEqual(names[3], [])264        self.assertEqual(names[3], [])265        # I.3: With covariate models266        cov_pop_model1 = chi.CovariatePopulationModel(267            chi.GaussianModel(),268            chi.LogNormalLinearCovariateModel(n_covariates=2)269        )270        cov_pop_model1.set_covariate_names(['Age', 'Sex'])271        cov_pop_model2 = chi.CovariatePopulationModel(272            chi.GaussianModel(),273            chi.LogNormalLinearCovariateModel(n_covariates=3)274        )275        cov_pop_model2.set_covariate_names(['SNP', 'Age', 'Height'])276        pop_models = [277            chi.PooledModel(),278            cov_pop_model1,279            chi.PooledModel(),280            cov_pop_model2,281            cov_pop_model1,282            chi.PooledModel(),283            chi.PooledModel()284        ]285        problem.set_population_model(pop_models)286        names = problem.get_covariate_names()287        self.assertEqual(len(names), 4)288        self.assertEqual(names[0], 'Age')289        self.assertEqual(names[1], 'Sex')290        self.assertEqual(names[2], 'SNP')291        self.assertEqual(names[3], 'Height')292        names = problem.get_covariate_names(unique=False)293        self.assertEqual(len(names), 7)294        self.assertEqual(names[0], [])295        self.assertEqual(names[1], ['Age', 'Sex'])296        self.assertEqual(names[2], [])297        self.assertEqual(names[3], ['SNP', 'Age', 'Height'])298        self.assertEqual(names[4], ['Age', 'Sex'])299        self.assertEqual(names[5], [])300        self.assertEqual(names[6], [])301    def test_get_dosing_regimens(self):302        # Test case I: PD problem303        problem = copy.deepcopy(self.pd_problem)304        # No data has been set305        regimens = problem.get_dosing_regimens()306        self.assertIsNone(regimens)307        # Set data, but because PD model, no dosing regimen can be set308        problem.set_data(self.data, {'myokit.tumour_volume': 'Tumour volume'})309        regimens = problem.get_dosing_regimens()310        self.assertIsNone(regimens)311        # Test case II: PKPD problem312        problem = copy.deepcopy(self.pkpd_problem)313        # No data has been set314        regimens = problem.get_dosing_regimens()315        self.assertIsNone(regimens)316        # Data has been set, but duration is ignored317        problem.set_data(318            self.data,319            output_observable_dict={320                'myokit.tumour_volume': 'Tumour volume',321                'central.drug_concentration': 'IL 6'},322            dose_duration_key=None)323        regimens = problem.get_dosing_regimens()324        self.assertIsInstance(regimens, dict)325        # Data has been set with duration information326        problem.set_data(327            self.data,328            output_observable_dict={329                'myokit.tumour_volume': 'Tumour volume',330                'central.drug_concentration': 'IL 6'})331        regimens = problem.get_dosing_regimens()332        self.assertIsInstance(regimens, dict)333    def test_get_log_prior(self):334        # Log-prior is extensively tested with get_log_posterior335        # method336        self.assertIsNone(self.pd_problem.get_log_prior())337    def test_get_log_posterior(self):338        # Test case I: Create posterior with no fixed parameters339        problem = copy.deepcopy(self.pd_problem)340        # Set data which does not provide measurements for all IDs341        problem.set_data(342            self.data,343            output_observable_dict={'myokit.tumour_volume': 'IL 6'})344        problem.set_log_prior([345            pints.HalfCauchyLogPrior(0, 1)]*7)346        # Get all posteriors347        posteriors = problem.get_log_posterior()348        self.assertEqual(len(posteriors), 2)349        self.assertEqual(posteriors[0].n_parameters(), 7)350        self.assertEqual(posteriors[0].get_id(), 'ID 0')351        self.assertEqual(posteriors[1].n_parameters(), 7)352        self.assertEqual(posteriors[1].get_id(), 'ID 1')353        # Set data that has measurements for all IDs354        problem.set_data(355            self.data,356            output_observable_dict={'myokit.tumour_volume': 'Tumour volume'})357        problem.set_log_prior([358            pints.HalfCauchyLogPrior(0, 1)]*7)359        # Get all posteriors360        posteriors = problem.get_log_posterior()361        self.assertEqual(len(posteriors), 3)362        self.assertEqual(posteriors[0].n_parameters(), 7)363        self.assertEqual(posteriors[0].get_id(), 'ID 0')364        self.assertEqual(posteriors[1].n_parameters(), 7)365        self.assertEqual(posteriors[1].get_id(), 'ID 1')366        self.assertEqual(posteriors[2].n_parameters(), 7)367        self.assertEqual(posteriors[2].get_id(), 'ID 2')368        # Get only one posterior369        posterior = problem.get_log_posterior(individual='0')370        self.assertIsInstance(posterior, chi.LogPosterior)371        self.assertEqual(posterior.n_parameters(), 7)372        self.assertEqual(posterior.get_id(), 'ID 0')373        # Test case II: Fix some parameters374        name_value_dict = dict({375            'myokit.drug_concentration': 0,376            'myokit.kappa': 1})377        problem.fix_parameters(name_value_dict)378        problem.set_log_prior([379            pints.HalfCauchyLogPrior(0, 1)]*5)380        # Get all posteriors381        posteriors = problem.get_log_posterior()382        self.assertEqual(len(posteriors), 3)383        self.assertEqual(posteriors[0].n_parameters(), 5)384        self.assertEqual(posteriors[0].get_id(), 'ID 0')385        self.assertEqual(posteriors[1].n_parameters(), 5)386        self.assertEqual(posteriors[1].get_id(), 'ID 1')387        self.assertEqual(posteriors[2].n_parameters(), 5)388        self.assertEqual(posteriors[2].get_id(), 'ID 2')389        # Get only one posterior390        posterior = problem.get_log_posterior(individual='1')391        self.assertIsInstance(posterior, chi.LogPosterior)392        self.assertEqual(posterior.n_parameters(), 5)393        self.assertEqual(posterior.get_id(), 'ID 1')394        # Set a population model395        cov_pop_model = chi.CovariatePopulationModel(396            chi.GaussianModel(),397            chi.LogNormalLinearCovariateModel(n_covariates=1)398        )399        cov_pop_model.set_covariate_names(['Age'], True)400        pop_models = [401            chi.PooledModel(),402            chi.HeterogeneousModel(),403            chi.PooledModel(),404            chi.PooledModel(),405            cov_pop_model]406        problem.set_population_model(pop_models)407        problem.set_log_prior([408            pints.HalfCauchyLogPrior(0, 1)]*9)409        posterior = problem.get_log_posterior()410        self.assertIsInstance(posterior, chi.HierarchicalLogPosterior)411        self.assertEqual(posterior.n_parameters(), 12)412        names = posterior.get_parameter_names()413        ids = posterior.get_id()414        self.assertEqual(len(names), 12)415        self.assertEqual(len(ids), 12)416        self.assertEqual(names[0], 'Pooled myokit.tumour_volume')417        self.assertIsNone(ids[0])418        self.assertEqual(names[1], 'myokit.lambda_0')419        self.assertEqual(ids[1], 'ID 0')420        self.assertEqual(names[2], 'myokit.lambda_0')421        self.assertEqual(ids[2], 'ID 1')422        self.assertEqual(names[3], 'myokit.lambda_0')423        self.assertEqual(ids[3], 'ID 2')424        self.assertEqual(names[4], 'Pooled myokit.lambda_1')425        self.assertIsNone(ids[4])426        self.assertEqual(names[5], 'Pooled Sigma base')427        self.assertIsNone(ids[5])428        self.assertEqual(names[6], 'Sigma rel. Eta')429        self.assertEqual(ids[6], 'ID 0')430        self.assertEqual(names[7], 'Sigma rel. Eta')431        self.assertEqual(ids[7], 'ID 1')432        self.assertEqual(names[8], 'Sigma rel. Eta')433        self.assertEqual(ids[8], 'ID 2')434        self.assertEqual(names[9], 'Base mean log Sigma rel.')435        self.assertIsNone(ids[9])436        self.assertEqual(names[10], 'Std. log Sigma rel.')437        self.assertIsNone(ids[10])438        self.assertEqual(names[11], 'Shift Age Sigma rel.')439        self.assertIsNone(ids[11])440        # Make sure that selecting an individual is ignored for population441        # models442        posterior = problem.get_log_posterior(individual='some individual')443        self.assertIsInstance(posterior, chi.HierarchicalLogPosterior)444        self.assertEqual(posterior.n_parameters(), 12)445        names = posterior.get_parameter_names()446        ids = posterior.get_id()447        self.assertEqual(len(names), 12)448        self.assertEqual(len(ids), 12)449        self.assertEqual(names[0], 'Pooled myokit.tumour_volume')450        self.assertIsNone(ids[0])451        self.assertEqual(names[1], 'myokit.lambda_0')452        self.assertEqual(ids[1], 'ID 0')453        self.assertEqual(names[2], 'myokit.lambda_0')454        self.assertEqual(ids[2], 'ID 1')455        self.assertEqual(names[3], 'myokit.lambda_0')456        self.assertEqual(ids[3], 'ID 2')457        self.assertEqual(names[4], 'Pooled myokit.lambda_1')458        self.assertIsNone(ids[4])459        self.assertEqual(names[5], 'Pooled Sigma base')460        self.assertIsNone(ids[5])461        self.assertEqual(names[6], 'Sigma rel. Eta')462        self.assertEqual(ids[6], 'ID 0')463        self.assertEqual(names[7], 'Sigma rel. Eta')464        self.assertEqual(ids[7], 'ID 1')465        self.assertEqual(names[8], 'Sigma rel. Eta')466        self.assertEqual(ids[8], 'ID 2')467        self.assertEqual(names[9], 'Base mean log Sigma rel.')468        self.assertIsNone(ids[9])469        self.assertEqual(names[10], 'Std. log Sigma rel.')470        self.assertIsNone(ids[10])471        self.assertEqual(names[11], 'Shift Age Sigma rel.')472        self.assertIsNone(ids[11])473    def test_get_log_posteriors_bad_input(self):474        problem = copy.deepcopy(self.pd_problem)475        # No log-prior has been set476        problem.set_data(477            self.data,478            output_observable_dict={'myokit.tumour_volume': 'Tumour volume'})479        with self.assertRaisesRegex(ValueError, 'The log-prior has not'):480            problem.get_log_posterior()481        # The selected individual does not exist482        individual = 'Not existent'483        problem.set_log_prior([pints.HalfCauchyLogPrior(0, 1)]*7)484        with self.assertRaisesRegex(ValueError, 'The individual cannot'):485            problem.get_log_posterior(individual)486    def test_get_n_parameters(self):487        # Test case I: PD model488        # Test case I.1: No population model489        # Test default flag490        problem = copy.deepcopy(self.pd_problem)491        n_parameters = problem.get_n_parameters()492        self.assertEqual(n_parameters, 7)493        # Test exclude population model True494        n_parameters = problem.get_n_parameters(exclude_pop_model=True)495        self.assertEqual(n_parameters, 7)496        # Test exclude bottom-level model True497        n_parameters = problem.get_n_parameters(exclude_bottom_level=True)498        self.assertEqual(n_parameters, 7)499        # Test case I.2: Population model500        pop_models = [501            chi.PooledModel(),502            chi.PooledModel(),503            chi.HeterogeneousModel(),504            chi.PooledModel(),505            chi.PooledModel(),506            chi.LogNormalModel(),507            chi.LogNormalModel()]508        problem.set_population_model(pop_models)509        n_parameters = problem.get_n_parameters()510        self.assertEqual(n_parameters, 8)511        # Test exclude population model True512        n_parameters = problem.get_n_parameters(exclude_pop_model=True)513        self.assertEqual(n_parameters, 7)514        # Test exclude bottom-level model True515        n_parameters = problem.get_n_parameters(exclude_bottom_level=True)516        self.assertEqual(n_parameters, 8)517        # Test case I.3: Set data518        problem.set_data(519            self.data,520            output_observable_dict={'myokit.tumour_volume': 'Tumour volume'})521        n_parameters = problem.get_n_parameters()522        self.assertEqual(n_parameters, 17)523        # Test exclude population model True524        n_parameters = problem.get_n_parameters(exclude_pop_model=True)525        self.assertEqual(n_parameters, 7)526        # Test exclude bottom-level model True527        n_parameters = problem.get_n_parameters(exclude_bottom_level=True)528        self.assertEqual(n_parameters, 11)529        # Test case II: PKPD model530        # Test case II.1: No population model531        # Test default flag532        problem = copy.deepcopy(self.pkpd_problem)533        n_parameters = problem.get_n_parameters()534        self.assertEqual(n_parameters, 11)535        # Test exclude population model True536        n_parameters = problem.get_n_parameters(exclude_pop_model=True)537        self.assertEqual(n_parameters, 11)538        # Test exclude bottom-level model True539        n_parameters = problem.get_n_parameters(exclude_bottom_level=True)540        self.assertEqual(n_parameters, 11)541        # Test case II.2: Population model542        pop_models = [543            chi.PooledModel(),544            chi.PooledModel(),545            chi.HeterogeneousModel(),546            chi.PooledModel(),547            chi.PooledModel(),548            chi.LogNormalModel(),549            chi.LogNormalModel(),550            chi.PooledModel(),551            chi.PooledModel(),552            chi.PooledModel(),553            chi.PooledModel()]554        problem.set_population_model(pop_models)555        n_parameters = problem.get_n_parameters()556        self.assertEqual(n_parameters, 12)557        # Test exclude population model True558        n_parameters = problem.get_n_parameters(exclude_pop_model=True)559        self.assertEqual(n_parameters, 11)560        # Test exclude bottom-level model True561        n_parameters = problem.get_n_parameters(exclude_bottom_level=True)562        self.assertEqual(n_parameters, 12)563        # Test case II.3: Set data564        problem.set_data(565            self.data,566            output_observable_dict={567                'myokit.tumour_volume': 'Tumour volume',568                'central.drug_concentration': 'IL 6'})569        n_parameters = problem.get_n_parameters()570        self.assertEqual(n_parameters, 21)571        # Test exclude population model True572        n_parameters = problem.get_n_parameters(exclude_pop_model=True)573        self.assertEqual(n_parameters, 11)574        # Test exclude bottom-level model True575        n_parameters = problem.get_n_parameters(exclude_bottom_level=True)576        self.assertEqual(n_parameters, 15)577    def test_get_parameter_names(self):578        # Test case I: PD model579        problem = copy.deepcopy(self.pd_problem)580        # Test case I.1: No population model581        # Test default flag582        param_names = problem.get_parameter_names()583        self.assertEqual(len(param_names), 7)584        self.assertEqual(param_names[0], 'myokit.tumour_volume')585        self.assertEqual(param_names[1], 'myokit.drug_concentration')586        self.assertEqual(param_names[2], 'myokit.kappa')587        self.assertEqual(param_names[3], 'myokit.lambda_0')588        self.assertEqual(param_names[4], 'myokit.lambda_1')589        self.assertEqual(param_names[5], 'Sigma base')590        self.assertEqual(param_names[6], 'Sigma rel.')591        # Check that also works with exclude pop params flag592        param_names = problem.get_parameter_names(exclude_pop_model=True)593        self.assertEqual(len(param_names), 7)594        self.assertEqual(param_names[0], 'myokit.tumour_volume')595        self.assertEqual(param_names[1], 'myokit.drug_concentration')596        self.assertEqual(param_names[2], 'myokit.kappa')597        self.assertEqual(param_names[3], 'myokit.lambda_0')598        self.assertEqual(param_names[4], 'myokit.lambda_1')599        self.assertEqual(param_names[5], 'Sigma base')600        self.assertEqual(param_names[6], 'Sigma rel.')601        # Check that also works with exclude bottom-level flag602        param_names = problem.get_parameter_names(exclude_bottom_level=True)603        self.assertEqual(len(param_names), 7)604        self.assertEqual(param_names[0], 'myokit.tumour_volume')605        self.assertEqual(param_names[1], 'myokit.drug_concentration')606        self.assertEqual(param_names[2], 'myokit.kappa')607        self.assertEqual(param_names[3], 'myokit.lambda_0')608        self.assertEqual(param_names[4], 'myokit.lambda_1')609        self.assertEqual(param_names[5], 'Sigma base')610        self.assertEqual(param_names[6], 'Sigma rel.')611        # Test case I.2: Population model612        cov_population_model = chi.CovariatePopulationModel(613            chi.GaussianModel(), chi.LogNormalLinearCovariateModel())614        pop_models = [615            chi.PooledModel(),616            chi.PooledModel(),617            chi.HeterogeneousModel(),618            chi.PooledModel(),619            chi.PooledModel(),620            cov_population_model,621            chi.LogNormalModel()]622        problem.set_population_model(pop_models)623        param_names = problem.get_parameter_names()624        self.assertEqual(len(param_names), 8)625        self.assertEqual(param_names[0], 'Pooled myokit.tumour_volume')626        self.assertEqual(param_names[1], 'Pooled myokit.drug_concentration')627        self.assertEqual(param_names[2], 'Pooled myokit.lambda_0')628        self.assertEqual(param_names[3], 'Pooled myokit.lambda_1')629        self.assertEqual(param_names[4], 'Base mean log Sigma base')630        self.assertEqual(param_names[5], 'Std. log Sigma base')631        self.assertEqual(param_names[6], 'Mean log Sigma rel.')632        self.assertEqual(param_names[7], 'Std. log Sigma rel.')633        # Test exclude population model True634        param_names = problem.get_parameter_names(exclude_pop_model=True)635        self.assertEqual(len(param_names), 7)636        self.assertEqual(param_names[0], 'myokit.tumour_volume')637        self.assertEqual(param_names[1], 'myokit.drug_concentration')638        self.assertEqual(param_names[2], 'myokit.kappa')639        self.assertEqual(param_names[3], 'myokit.lambda_0')640        self.assertEqual(param_names[4], 'myokit.lambda_1')641        self.assertEqual(param_names[5], 'Sigma base')642        self.assertEqual(param_names[6], 'Sigma rel.')643        # Test exclude bottom-level True644        param_names = problem.get_parameter_names(exclude_bottom_level=True)645        self.assertEqual(len(param_names), 8)646        self.assertEqual(param_names[0], 'Pooled myokit.tumour_volume')647        self.assertEqual(param_names[1], 'Pooled myokit.drug_concentration')648        self.assertEqual(param_names[2], 'Pooled myokit.lambda_0')649        self.assertEqual(param_names[3], 'Pooled myokit.lambda_1')650        self.assertEqual(param_names[4], 'Base mean log Sigma base')651        self.assertEqual(param_names[5], 'Std. log Sigma base')652        self.assertEqual(param_names[6], 'Mean log Sigma rel.')653        self.assertEqual(param_names[7], 'Std. log Sigma rel.')654        # Test case I.3: Set data655        problem.set_data(656            self.data,657            output_observable_dict={'myokit.tumour_volume': 'Tumour volume'})658        param_names = problem.get_parameter_names()659        self.assertEqual(len(param_names), 17)660        self.assertEqual(param_names[0], 'Pooled myokit.tumour_volume')661        self.assertEqual(param_names[1], 'Pooled myokit.drug_concentration')662        self.assertEqual(param_names[2], 'ID 0: myokit.kappa')663        self.assertEqual(param_names[3], 'ID 1: myokit.kappa')664        self.assertEqual(param_names[4], 'ID 2: myokit.kappa')665        self.assertEqual(param_names[5], 'Pooled myokit.lambda_0')666        self.assertEqual(param_names[6], 'Pooled myokit.lambda_1')667        self.assertEqual(param_names[7], 'ID 0: Sigma base Eta')668        self.assertEqual(param_names[8], 'ID 1: Sigma base Eta')669        self.assertEqual(param_names[9], 'ID 2: Sigma base Eta')670        self.assertEqual(param_names[10], 'Base mean log Sigma base')671        self.assertEqual(param_names[11], 'Std. log Sigma base')672        self.assertEqual(param_names[12], 'ID 0: Sigma rel.')673        self.assertEqual(param_names[13], 'ID 1: Sigma rel.')674        self.assertEqual(param_names[14], 'ID 2: Sigma rel.')675        self.assertEqual(param_names[15], 'Mean log Sigma rel.')676        self.assertEqual(param_names[16], 'Std. log Sigma rel.')677        # Test exclude population model True678        param_names = problem.get_parameter_names(exclude_pop_model=True)679        self.assertEqual(len(param_names), 7)680        self.assertEqual(param_names[0], 'myokit.tumour_volume')681        self.assertEqual(param_names[1], 'myokit.drug_concentration')682        self.assertEqual(param_names[2], 'myokit.kappa')683        self.assertEqual(param_names[3], 'myokit.lambda_0')684        self.assertEqual(param_names[4], 'myokit.lambda_1')685        self.assertEqual(param_names[5], 'Sigma base')686        self.assertEqual(param_names[6], 'Sigma rel.')687        # Test exclude bottom-level True688        param_names = problem.get_parameter_names(exclude_bottom_level=True)689        self.assertEqual(len(param_names), 11)690        self.assertEqual(param_names[0], 'Pooled myokit.tumour_volume')691        self.assertEqual(param_names[1], 'Pooled myokit.drug_concentration')692        self.assertEqual(param_names[2], 'ID 0: myokit.kappa')693        self.assertEqual(param_names[3], 'ID 1: myokit.kappa')694        self.assertEqual(param_names[4], 'ID 2: myokit.kappa')695        self.assertEqual(param_names[5], 'Pooled myokit.lambda_0')696        self.assertEqual(param_names[6], 'Pooled myokit.lambda_1')697        self.assertEqual(param_names[7], 'Base mean log Sigma base')698        self.assertEqual(param_names[8], 'Std. log Sigma base')699        self.assertEqual(param_names[9], 'Mean log Sigma rel.')700        self.assertEqual(param_names[10], 'Std. log Sigma rel.')701        # Test case II: PKPD model702        problem = copy.deepcopy(self.pkpd_problem)703        # Test case II.1: No population model704        # Test default flag705        param_names = problem.get_parameter_names()706        self.assertEqual(len(param_names), 11)707        self.assertEqual(param_names[0], 'central.drug_amount')708        self.assertEqual(param_names[1], 'myokit.tumour_volume')709        self.assertEqual(param_names[2], 'central.size')710        self.assertEqual(param_names[3], 'myokit.critical_volume')711        self.assertEqual(param_names[4], 'myokit.elimination_rate')712        self.assertEqual(param_names[5], 'myokit.kappa')713        self.assertEqual(param_names[6], 'myokit.lambda')714        self.assertEqual(715            param_names[7], 'central.drug_concentration Sigma base')716        self.assertEqual(717            param_names[8], 'central.drug_concentration Sigma rel.')718        self.assertEqual(param_names[9], 'myokit.tumour_volume Sigma base')719        self.assertEqual(param_names[10], 'myokit.tumour_volume Sigma rel.')720        # Test exclude population model True721        param_names = problem.get_parameter_names(exclude_pop_model=True)722        self.assertEqual(len(param_names), 11)723        self.assertEqual(param_names[0], 'central.drug_amount')724        self.assertEqual(param_names[1], 'myokit.tumour_volume')725        self.assertEqual(param_names[2], 'central.size')726        self.assertEqual(param_names[3], 'myokit.critical_volume')727        self.assertEqual(param_names[4], 'myokit.elimination_rate')728        self.assertEqual(param_names[5], 'myokit.kappa')729        self.assertEqual(param_names[6], 'myokit.lambda')730        self.assertEqual(731            param_names[7], 'central.drug_concentration Sigma base')732        self.assertEqual(733            param_names[8], 'central.drug_concentration Sigma rel.')734        self.assertEqual(param_names[9], 'myokit.tumour_volume Sigma base')735        self.assertEqual(param_names[10], 'myokit.tumour_volume Sigma rel.')736        # Test exclude population model True737        param_names = problem.get_parameter_names(exclude_bottom_level=True)738        self.assertEqual(len(param_names), 11)739        self.assertEqual(param_names[0], 'central.drug_amount')740        self.assertEqual(param_names[1], 'myokit.tumour_volume')741        self.assertEqual(param_names[2], 'central.size')742        self.assertEqual(param_names[3], 'myokit.critical_volume')743        self.assertEqual(param_names[4], 'myokit.elimination_rate')744        self.assertEqual(param_names[5], 'myokit.kappa')745        self.assertEqual(param_names[6], 'myokit.lambda')746        self.assertEqual(747            param_names[7], 'central.drug_concentration Sigma base')748        self.assertEqual(749            param_names[8], 'central.drug_concentration Sigma rel.')750        self.assertEqual(param_names[9], 'myokit.tumour_volume Sigma base')751        self.assertEqual(param_names[10], 'myokit.tumour_volume Sigma rel.')752        # Test case II.2: Population model753        cov_pop_model = chi.CovariatePopulationModel(754            chi.GaussianModel(),755            chi.LogNormalLinearCovariateModel(n_covariates=1)756        )757        cov_pop_model.set_covariate_names(['Age'], True)758        pop_models = [759            chi.PooledModel(),760            chi.PooledModel(),761            chi.HeterogeneousModel(),762            chi.PooledModel(),763            chi.PooledModel(),764            chi.LogNormalModel(),765            chi.LogNormalModel(),766            chi.PooledModel(),767            cov_pop_model,768            chi.PooledModel(),769            chi.PooledModel()]770        problem.set_population_model(pop_models)771        param_names = problem.get_parameter_names()772        self.assertEqual(len(param_names), 14)773        self.assertEqual(param_names[0], 'Pooled central.drug_amount')774        self.assertEqual(param_names[1], 'Pooled myokit.tumour_volume')775        self.assertEqual(param_names[2], 'Pooled myokit.critical_volume')776        self.assertEqual(param_names[3], 'Pooled myokit.elimination_rate')777        self.assertEqual(param_names[4], 'Mean log myokit.kappa')778        self.assertEqual(param_names[5], 'Std. log myokit.kappa')779        self.assertEqual(param_names[6], 'Mean log myokit.lambda')780        self.assertEqual(param_names[7], 'Std. log myokit.lambda')781        self.assertEqual(782            param_names[8], 'Pooled central.drug_concentration Sigma base')783        self.assertEqual(784            param_names[9],785            'Base mean log central.drug_concentration Sigma rel.')786        self.assertEqual(787            param_names[10], 'Std. log central.drug_concentration Sigma rel.')788        self.assertEqual(789            param_names[11], 'Shift Age central.drug_concentration Sigma rel.')790        self.assertEqual(791            param_names[12], 'Pooled myokit.tumour_volume Sigma base')792        self.assertEqual(793            param_names[13], 'Pooled myokit.tumour_volume Sigma rel.')794        # Test exclude population model True795        param_names = problem.get_parameter_names(exclude_pop_model=True)796        self.assertEqual(len(param_names), 11)797        self.assertEqual(param_names[0], 'central.drug_amount')798        self.assertEqual(param_names[1], 'myokit.tumour_volume')799        self.assertEqual(param_names[2], 'central.size')800        self.assertEqual(param_names[3], 'myokit.critical_volume')801        self.assertEqual(param_names[4], 'myokit.elimination_rate')802        self.assertEqual(param_names[5], 'myokit.kappa')803        self.assertEqual(param_names[6], 'myokit.lambda')804        self.assertEqual(805            param_names[7], 'central.drug_concentration Sigma base')806        self.assertEqual(807            param_names[8], 'central.drug_concentration Sigma rel.')808        self.assertEqual(param_names[9], 'myokit.tumour_volume Sigma base')809        self.assertEqual(param_names[10], 'myokit.tumour_volume Sigma rel.')810        # Test exclude bottom-level True811        param_names = problem.get_parameter_names(exclude_bottom_level=True)812        self.assertEqual(len(param_names), 14)813        self.assertEqual(param_names[0], 'Pooled central.drug_amount')814        self.assertEqual(param_names[1], 'Pooled myokit.tumour_volume')815        self.assertEqual(param_names[2], 'Pooled myokit.critical_volume')816        self.assertEqual(param_names[3], 'Pooled myokit.elimination_rate')817        self.assertEqual(param_names[4], 'Mean log myokit.kappa')818        self.assertEqual(param_names[5], 'Std. log myokit.kappa')819        self.assertEqual(param_names[6], 'Mean log myokit.lambda')820        self.assertEqual(param_names[7], 'Std. log myokit.lambda')821        self.assertEqual(822            param_names[8], 'Pooled central.drug_concentration Sigma base')823        self.assertEqual(824            param_names[9],825            'Base mean log central.drug_concentration Sigma rel.')826        self.assertEqual(827            param_names[10], 'Std. log central.drug_concentration Sigma rel.')828        self.assertEqual(829            param_names[11], 'Shift Age central.drug_concentration Sigma rel.')830        self.assertEqual(831            param_names[12], 'Pooled myokit.tumour_volume Sigma base')832        self.assertEqual(833            param_names[13], 'Pooled myokit.tumour_volume Sigma rel.')834        # Test case II.3: Set data835        problem.set_data(836            self.data,837            output_observable_dict={838                'myokit.tumour_volume': 'Tumour volume',839                'central.drug_concentration': 'IL 6'})840        param_names = problem.get_parameter_names()841        self.assertEqual(len(param_names), 26)842        self.assertEqual(param_names[0], 'Pooled central.drug_amount')843        self.assertEqual(param_names[1], 'Pooled myokit.tumour_volume')844        self.assertEqual(param_names[2], 'ID 0: central.size')845        self.assertEqual(param_names[3], 'ID 1: central.size')846        self.assertEqual(param_names[4], 'ID 2: central.size')847        self.assertEqual(param_names[5], 'Pooled myokit.critical_volume')848        self.assertEqual(param_names[6], 'Pooled myokit.elimination_rate')849        self.assertEqual(param_names[7], 'ID 0: myokit.kappa')850        self.assertEqual(param_names[8], 'ID 1: myokit.kappa')851        self.assertEqual(param_names[9], 'ID 2: myokit.kappa')852        self.assertEqual(param_names[10], 'Mean log myokit.kappa')853        self.assertEqual(param_names[11], 'Std. log myokit.kappa')854        self.assertEqual(param_names[12], 'ID 0: myokit.lambda')855        self.assertEqual(param_names[13], 'ID 1: myokit.lambda')856        self.assertEqual(param_names[14], 'ID 2: myokit.lambda')857        self.assertEqual(param_names[15], 'Mean log myokit.lambda')858        self.assertEqual(param_names[16], 'Std. log myokit.lambda')859        self.assertEqual(860            param_names[17], 'Pooled central.drug_concentration Sigma base')861        self.assertEqual(862            param_names[18],863            'ID 0: central.drug_concentration Sigma rel. Eta')864        self.assertEqual(865            param_names[19],866            'ID 1: central.drug_concentration Sigma rel. Eta')867        self.assertEqual(868            param_names[20],869            'ID 2: central.drug_concentration Sigma rel. Eta')870        self.assertEqual(871            param_names[21],872            'Base mean log central.drug_concentration Sigma rel.')873        self.assertEqual(874            param_names[22], 'Std. log central.drug_concentration Sigma rel.')875        self.assertEqual(876            param_names[23], 'Shift Age central.drug_concentration Sigma rel.')877        self.assertEqual(878            param_names[24], 'Pooled myokit.tumour_volume Sigma base')879        self.assertEqual(880            param_names[25], 'Pooled myokit.tumour_volume Sigma rel.')881        # Test exclude population model True882        param_names = problem.get_parameter_names(exclude_pop_model=True)883        self.assertEqual(len(param_names), 11)884        self.assertEqual(param_names[0], 'central.drug_amount')885        self.assertEqual(param_names[1], 'myokit.tumour_volume')886        self.assertEqual(param_names[2], 'central.size')887        self.assertEqual(param_names[3], 'myokit.critical_volume')888        self.assertEqual(param_names[4], 'myokit.elimination_rate')889        self.assertEqual(param_names[5], 'myokit.kappa')890        self.assertEqual(param_names[6], 'myokit.lambda')891        self.assertEqual(892            param_names[7], 'central.drug_concentration Sigma base')893        self.assertEqual(894            param_names[8], 'central.drug_concentration Sigma rel.')895        self.assertEqual(param_names[9], 'myokit.tumour_volume Sigma base')896        self.assertEqual(param_names[10], 'myokit.tumour_volume Sigma rel.')897        # Test exclude bottom-level True898        param_names = problem.get_parameter_names(exclude_bottom_level=True)899        self.assertEqual(len(param_names), 17)900        self.assertEqual(param_names[0], 'Pooled central.drug_amount')901        self.assertEqual(param_names[1], 'Pooled myokit.tumour_volume')902        self.assertEqual(param_names[2], 'ID 0: central.size')903        self.assertEqual(param_names[3], 'ID 1: central.size')904        self.assertEqual(param_names[4], 'ID 2: central.size')905        self.assertEqual(param_names[5], 'Pooled myokit.critical_volume')906        self.assertEqual(param_names[6], 'Pooled myokit.elimination_rate')907        self.assertEqual(param_names[7], 'Mean log myokit.kappa')908        self.assertEqual(param_names[8], 'Std. log myokit.kappa')909        self.assertEqual(param_names[9], 'Mean log myokit.lambda')910        self.assertEqual(param_names[10], 'Std. log myokit.lambda')911        self.assertEqual(912            param_names[11], 'Pooled central.drug_concentration Sigma base')913        self.assertEqual(914            param_names[12],915            'Base mean log central.drug_concentration Sigma rel.')916        self.assertEqual(917            param_names[13], 'Std. log central.drug_concentration Sigma rel.')918        self.assertEqual(919            param_names[14], 'Shift Age central.drug_concentration Sigma rel.')920        self.assertEqual(921            param_names[15], 'Pooled myokit.tumour_volume Sigma base')922        self.assertEqual(923            param_names[16], 'Pooled myokit.tumour_volume Sigma rel.')924    def test_get_predictive_model(self):925        # Test case I: PD model926        problem = copy.deepcopy(self.pd_problem)927        # Test case I.1: No population model928        predictive_model = problem.get_predictive_model()929        self.assertIsInstance(predictive_model, chi.PredictiveModel)930        # Exclude population model931        predictive_model = problem.get_predictive_model(932            exclude_pop_model=True)933        self.assertIsInstance(predictive_model, chi.PredictiveModel)934        # Test case I.2: Population model935        problem.set_population_model([936            chi.PooledModel(),937            chi.PooledModel(),938            chi.HeterogeneousModel(),939            chi.PooledModel(),940            chi.PooledModel(),941            chi.LogNormalModel(),942            chi.LogNormalModel()])943        predictive_model = problem.get_predictive_model()944        self.assertIsInstance(945            predictive_model, chi.PopulationPredictiveModel)946        # Exclude population model947        predictive_model = problem.get_predictive_model(948            exclude_pop_model=True)949        self.assertNotIsInstance(950            predictive_model, chi.PopulationPredictiveModel)951        self.assertIsInstance(predictive_model, chi.PredictiveModel)952        # Test case II: PKPD model953        problem = copy.deepcopy(self.pkpd_problem)954        # Test case II.1: No population model955        predictive_model = problem.get_predictive_model()956        self.assertIsInstance(predictive_model, chi.PredictiveModel)957        # Exclude population model958        predictive_model = problem.get_predictive_model(959            exclude_pop_model=True)960        self.assertIsInstance(predictive_model, chi.PredictiveModel)961        # Test case II.2: Population model962        problem.set_population_model([963            chi.PooledModel(),964            chi.PooledModel(),965            chi.HeterogeneousModel(),966            chi.PooledModel(),967            chi.PooledModel(),968            chi.LogNormalModel(),969            chi.LogNormalModel(),970            chi.PooledModel(),971            chi.PooledModel(),972            chi.PooledModel(),973            chi.PooledModel()])974        predictive_model = problem.get_predictive_model()975        self.assertIsInstance(976            predictive_model, chi.PopulationPredictiveModel)977        # Exclude population model978        predictive_model = problem.get_predictive_model(979            exclude_pop_model=True)980        self.assertNotIsInstance(981            predictive_model, chi.PopulationPredictiveModel)982        self.assertIsInstance(predictive_model, chi.PredictiveModel)983    def test_set_data(self):984        # Set data with explicit output-observable map985        problem = copy.deepcopy(self.pd_problem)986        output_observable_dict = {'myokit.tumour_volume': 'Tumour volume'}987        problem.set_data(self.data, output_observable_dict)988        # Set data with implicit output-observable map989        mask = self.data['Observable'] == 'Tumour volume'990        problem.set_data(self.data[mask])991        # Set data with explicit covariate mapping992        cov_pop_model = chi.CovariatePopulationModel(993            chi.GaussianModel(),994            chi.LogNormalLinearCovariateModel(n_covariates=1)995        )996        cov_pop_model.set_covariate_names(['Sex'], True)997        pop_models = [cov_pop_model] * 7998        problem.set_population_model(pop_models)999        covariate_dict = {'Sex': 'Age'}1000        problem.set_data(self.data, output_observable_dict, covariate_dict)1001    def test_set_data_bad_input(self):1002        # Data has the wrong type1003        data = 'Wrong type'1004        with self.assertRaisesRegex(TypeError, 'Data has to be a'):1005            self.pd_problem.set_data(data)1006        # Data has the wrong ID key1007        data = self.data.rename(columns={'ID': 'Some key'})1008        with self.assertRaisesRegex(ValueError, 'Data does not have the'):1009            self.pkpd_problem.set_data(data)1010        # Data has the wrong time key1011        data = self.data.rename(columns={'Time': 'Some key'})1012        with self.assertRaisesRegex(ValueError, 'Data does not have the'):1013            self.pkpd_problem.set_data(data)1014        # Data has the wrong observable key1015        data = self.data.rename(columns={'Observable': 'Some key'})1016        with self.assertRaisesRegex(ValueError, 'Data does not have the'):1017            self.pkpd_problem.set_data(data)1018        # Data has the wrong value key1019        data = self.data.rename(columns={'Value': 'Some key'})1020        with self.assertRaisesRegex(ValueError, 'Data does not have the'):1021            self.pkpd_problem.set_data(data)1022        # Data has the wrong dose key1023        data = self.data.rename(columns={'Dose': 'Some key'})1024        with self.assertRaisesRegex(ValueError, 'Data does not have the'):1025            self.pkpd_problem.set_data(data)1026        # Data has the wrong duration key1027        data = self.data.rename(columns={'Duration': 'Some key'})1028        with self.assertRaisesRegex(ValueError, 'Data does not have the'):1029            self.pkpd_problem.set_data(data)1030        # The output-observable map does not contain a model output1031        output_observable_dict = {'some output': 'some observable'}1032        with self.assertRaisesRegex(ValueError, 'The output <central.drug'):1033            self.pkpd_problem.set_data(self.data, output_observable_dict)1034        # The output-observable map references a observable that is not in the1035        # dataframe1036        output_observable_dict = {'myokit.tumour_volume': 'some observable'}1037        with self.assertRaisesRegex(ValueError, 'The observable <some'):1038            self.pd_problem.set_data(self.data, output_observable_dict)1039        # The model outputs and dataframe observable cannot be trivially mapped1040        with self.assertRaisesRegex(ValueError, 'The observable <central.'):1041            self.pkpd_problem.set_data(self.data)1042        # Covariate map does not contain all model covariates1043        problem = copy.deepcopy(self.pd_problem)1044        cov_pop_model1 = chi.CovariatePopulationModel(1045            chi.GaussianModel(),1046            chi.LogNormalLinearCovariateModel(n_covariates=1)1047        )1048        cov_pop_model1.set_covariate_names(['Age'], True)1049        cov_pop_model2 = chi.CovariatePopulationModel(1050            chi.GaussianModel(),1051            chi.LogNormalLinearCovariateModel(n_covariates=1)1052        )1053        cov_pop_model2.set_covariate_names(['Sex'], True)1054        pop_models = [cov_pop_model1] * 4 + [cov_pop_model2] * 31055        problem.set_population_model(pop_models)1056        output_observable_dict = {'myokit.tumour_volume': 'Tumour volume'}1057        covariate_dict = {'Age': 'Age', 'Something': 'else'}1058        with self.assertRaisesRegex(ValueError, 'The covariate <Sex> could'):1059            problem.set_data(1060                self.data,1061                output_observable_dict=output_observable_dict,1062                covariate_dict=covariate_dict)1063        # Covariate dict maps to covariate that is not in the dataframe1064        covariate_dict = {'Age': 'Age', 'Sex': 'Does not exist'}1065        with self.assertRaisesRegex(ValueError, 'The covariate <Does not ex'):1066            problem.set_data(1067                self.data,1068                output_observable_dict=output_observable_dict,1069                covariate_dict=covariate_dict)1070        # There are no covariate values provided for an ID1071        data = self.data.copy()1072        mask = (data.ID == 1) | (data.Observable == 'Age')1073        data.loc[mask, 'Value'] = np.nan1074        pop_models = [cov_pop_model1] * 71075        problem.set_population_model(pop_models)1076        with self.assertRaisesRegex(ValueError, 'There are either 0 or more'):1077            problem.set_data(1078                data,1079                output_observable_dict=output_observable_dict)1080        # There is more than one covariate value provided for an ID1081        data = self.data.copy()1082        mask = data.Observable == 'Age'1083        data.loc[mask, 'ID'] = 01084        pop_models = [cov_pop_model1] * 71085        problem.set_population_model(pop_models)1086        with self.assertRaisesRegex(ValueError, 'There are either 0 or more'):1087            problem.set_data(1088                data,1089                output_observable_dict=output_observable_dict)1090    def test_set_log_prior(self):1091        # Test case I: PD model1092        problem = copy.deepcopy(self.pd_problem)1093        problem.set_data(self.data, {'myokit.tumour_volume': 'Tumour volume'})1094        log_priors = [pints.HalfCauchyLogPrior(0, 1)] * 71095        # Map priors to parameters automatically1096        problem.set_log_prior(log_priors)1097        # Specify prior parameter map explicitly1098        param_names = [1099            'myokit.kappa',1100            'Sigma base',1101            'Sigma rel.',1102            'myokit.tumour_volume',1103            'myokit.lambda_1',1104            'myokit.drug_concentration',1105            'myokit.lambda_0']1106        problem.set_log_prior(log_priors, param_names)1107    def test_set_log_prior_bad_input(self):1108        problem = copy.deepcopy(self.pd_problem)1109        # No data has been set1110        with self.assertRaisesRegex(ValueError, 'The data has not'):1111            problem.set_log_prior('some prior')1112        # Wrong log-prior type1113        problem.set_data(self.data, {'myokit.tumour_volume': 'Tumour volume'})1114        log_priors = ['Wrong', 'type']1115        with self.assertRaisesRegex(ValueError, 'All marginal log-priors'):1116            problem.set_log_prior(log_priors)1117        # Number of log priors does not match number of parameters1118        log_priors = [1119            pints.GaussianLogPrior(0, 1), pints.HalfCauchyLogPrior(0, 1)]1120        with self.assertRaisesRegex(ValueError, 'One marginal log-prior'):1121            problem.set_log_prior(log_priors)1122        # Dimensionality of joint log-pior does not match number of parameters1123        prior = pints.ComposedLogPrior(1124            pints.GaussianLogPrior(0, 1), pints.GaussianLogPrior(0, 1))1125        log_priors = [1126            prior,1127            pints.UniformLogPrior(0, 1),1128            pints.UniformLogPrior(0, 1),1129            pints.UniformLogPrior(0, 1),1130            pints.UniformLogPrior(0, 1),1131            pints.UniformLogPrior(0, 1),1132            pints.UniformLogPrior(0, 1)]1133        with self.assertRaisesRegex(ValueError, 'The joint log-prior'):1134            problem.set_log_prior(log_priors)1135        # Specified parameter names do not match the model parameters1136        params = ['wrong', 'params']1137        log_priors = [pints.HalfCauchyLogPrior(0, 1)] * 71138        with self.assertRaisesRegex(ValueError, 'The specified parameter'):1139            problem.set_log_prior(log_priors, params)1140    def test_set_population_model(self):1141        # Test case I: PD model1142        problem = copy.deepcopy(self.pd_problem)1143        problem.set_data(self.data, {'myokit.tumour_volume': 'Tumour volume'})1144        pop_models = [1145            chi.PooledModel(),1146            chi.PooledModel(),1147            chi.HeterogeneousModel(),1148            chi.PooledModel(),1149            chi.PooledModel(),1150            chi.PooledModel(),1151            chi.LogNormalModel()]1152        # Test case I.1: Don't specify order1153        problem.set_population_model(pop_models)1154        self.assertEqual(problem.get_n_parameters(), 13)1155        param_names = problem.get_parameter_names()1156        self.assertEqual(len(param_names), 13)1157        self.assertEqual(param_names[0], 'Pooled myokit.tumour_volume')1158        self.assertEqual(param_names[1], 'Pooled myokit.drug_concentration')1159        self.assertEqual(param_names[2], 'ID 0: myokit.kappa')1160        self.assertEqual(param_names[3], 'ID 1: myokit.kappa')1161        self.assertEqual(param_names[4], 'ID 2: myokit.kappa')1162        self.assertEqual(param_names[5], 'Pooled myokit.lambda_0')1163        self.assertEqual(param_names[6], 'Pooled myokit.lambda_1')1164        self.assertEqual(param_names[7], 'Pooled Sigma base')1165        self.assertEqual(param_names[8], 'ID 0: Sigma rel.')1166        self.assertEqual(param_names[9], 'ID 1: Sigma rel.')1167        self.assertEqual(param_names[10], 'ID 2: Sigma rel.')1168        self.assertEqual(param_names[11], 'Mean log Sigma rel.')1169        self.assertEqual(param_names[12], 'Std. log Sigma rel.')1170        # Test case I.2: Specify order1171        parameter_names = [1172            'Sigma base',1173            'myokit.drug_concentration',1174            'myokit.lambda_1',1175            'myokit.kappa',1176            'myokit.tumour_volume',1177            'Sigma rel.',1178            'myokit.lambda_0']1179        problem.set_population_model(pop_models, parameter_names)1180        self.assertEqual(problem.get_n_parameters(), 13)1181        param_names = problem.get_parameter_names()1182        self.assertEqual(len(param_names), 13)1183        self.assertEqual(param_names[0], 'Pooled myokit.tumour_volume')1184        self.assertEqual(param_names[1], 'Pooled myokit.drug_concentration')1185        self.assertEqual(param_names[2], 'Pooled myokit.kappa')1186        self.assertEqual(param_names[3], 'ID 0: myokit.lambda_0')1187        self.assertEqual(param_names[4], 'ID 1: myokit.lambda_0')1188        self.assertEqual(param_names[5], 'ID 2: myokit.lambda_0')1189        self.assertEqual(param_names[6], 'Mean log myokit.lambda_0')1190        self.assertEqual(param_names[7], 'Std. log myokit.lambda_0')1191        self.assertEqual(param_names[8], 'ID 0: myokit.lambda_1')1192        self.assertEqual(param_names[9], 'ID 1: myokit.lambda_1')1193        self.assertEqual(param_names[10], 'ID 2: myokit.lambda_1')1194        self.assertEqual(param_names[11], 'Pooled Sigma base')1195        self.assertEqual(param_names[12], 'Pooled Sigma rel.')1196        # Test case I.3: With covariates1197        cov_pop_model = chi.CovariatePopulationModel(1198            chi.GaussianModel(),1199            chi.LogNormalLinearCovariateModel(n_covariates=1)1200        )1201        cov_pop_model.set_covariate_names(['Age'], True)1202        pop_models = [1203            chi.PooledModel(),1204            chi.PooledModel(),1205            chi.HeterogeneousModel(),1206            chi.PooledModel(),1207            cov_pop_model,1208            chi.PooledModel(),1209            chi.LogNormalModel()]1210        problem.set_population_model(pop_models)1211        self.assertEqual(problem.get_n_parameters(), 18)1212        param_names = problem.get_parameter_names()1213        self.assertEqual(len(param_names), 18)1214        self.assertEqual(param_names[0], 'Pooled myokit.tumour_volume')1215        self.assertEqual(param_names[1], 'Pooled myokit.drug_concentration')1216        self.assertEqual(param_names[2], 'ID 0: myokit.kappa')1217        self.assertEqual(param_names[3], 'ID 1: myokit.kappa')1218        self.assertEqual(param_names[4], 'ID 2: myokit.kappa')1219        self.assertEqual(param_names[5], 'Pooled myokit.lambda_0')1220        self.assertEqual(param_names[6], 'ID 0: myokit.lambda_1 Eta')1221        self.assertEqual(param_names[7], 'ID 1: myokit.lambda_1 Eta')1222        self.assertEqual(param_names[8], 'ID 2: myokit.lambda_1 Eta')1223        self.assertEqual(param_names[9], 'Base mean log myokit.lambda_1')1224        self.assertEqual(param_names[10], 'Std. log myokit.lambda_1')1225        self.assertEqual(param_names[11], 'Shift Age myokit.lambda_1')1226        self.assertEqual(param_names[12], 'Pooled Sigma base')1227        self.assertEqual(param_names[13], 'ID 0: Sigma rel.')1228        self.assertEqual(param_names[14], 'ID 1: Sigma rel.')1229        self.assertEqual(param_names[15], 'ID 2: Sigma rel.')1230        self.assertEqual(param_names[16], 'Mean log Sigma rel.')1231        self.assertEqual(param_names[17], 'Std. log Sigma rel.')1232        # Test case II: PKPD model1233        problem = copy.deepcopy(self.pkpd_problem)1234        problem.set_data(1235            self.data,1236            output_observable_dict={1237                'central.drug_concentration': 'IL 6',1238                'myokit.tumour_volume': 'Tumour volume'})1239        pop_models = [1240            chi.LogNormalModel(),1241            chi.LogNormalModel(),1242            chi.LogNormalModel(),1243            chi.PooledModel(),1244            chi.PooledModel(),1245            chi.HeterogeneousModel(),1246            chi.PooledModel(),1247            chi.PooledModel(),1248            chi.LogNormalModel(),1249            chi.PooledModel(),1250            chi.LogNormalModel()]1251        # Test case I.1: Don't specify order1252        problem.set_population_model(pop_models)1253        self.assertEqual(problem.get_n_parameters(), 33)1254        param_names = problem.get_parameter_names()1255        self.assertEqual(len(param_names), 33)1256        self.assertEqual(param_names[0], 'ID 0: central.drug_amount')1257        self.assertEqual(param_names[1], 'ID 1: central.drug_amount')1258        self.assertEqual(param_names[2], 'ID 2: central.drug_amount')1259        self.assertEqual(param_names[3], 'Mean log central.drug_amount')1260        self.assertEqual(param_names[4], 'Std. log central.drug_amount')1261        self.assertEqual(param_names[5], 'ID 0: myokit.tumour_volume')1262        self.assertEqual(param_names[6], 'ID 1: myokit.tumour_volume')1263        self.assertEqual(param_names[7], 'ID 2: myokit.tumour_volume')1264        self.assertEqual(param_names[8], 'Mean log myokit.tumour_volume')1265        self.assertEqual(param_names[9], 'Std. log myokit.tumour_volume')1266        self.assertEqual(param_names[10], 'ID 0: central.size')1267        self.assertEqual(param_names[11], 'ID 1: central.size')1268        self.assertEqual(param_names[12], 'ID 2: central.size')1269        self.assertEqual(param_names[13], 'Mean log central.size')1270        self.assertEqual(param_names[14], 'Std. log central.size')1271        self.assertEqual(param_names[15], 'Pooled myokit.critical_volume')1272        self.assertEqual(param_names[16], 'Pooled myokit.elimination_rate')1273        self.assertEqual(param_names[17], 'ID 0: myokit.kappa')1274        self.assertEqual(param_names[18], 'ID 1: myokit.kappa')1275        self.assertEqual(param_names[19], 'ID 2: myokit.kappa')1276        self.assertEqual(param_names[20], 'Pooled myokit.lambda')1277        self.assertEqual(1278            param_names[21], 'Pooled central.drug_concentration Sigma base')1279        self.assertEqual(1280            param_names[22], 'ID 0: central.drug_concentration Sigma rel.')1281        self.assertEqual(1282            param_names[23], 'ID 1: central.drug_concentration Sigma rel.')1283        self.assertEqual(1284            param_names[24], 'ID 2: central.drug_concentration Sigma rel.')1285        self.assertEqual(1286            param_names[25], 'Mean log central.drug_concentration Sigma rel.')1287        self.assertEqual(1288            param_names[26], 'Std. log central.drug_concentration Sigma rel.')1289        self.assertEqual(1290            param_names[27], 'Pooled myokit.tumour_volume Sigma base')1291        self.assertEqual(1292            param_names[28], 'ID 0: myokit.tumour_volume Sigma rel.')1293        self.assertEqual(1294            param_names[29], 'ID 1: myokit.tumour_volume Sigma rel.')1295        self.assertEqual(1296            param_names[30], 'ID 2: myokit.tumour_volume Sigma rel.')1297        self.assertEqual(1298            param_names[31], 'Mean log myokit.tumour_volume Sigma rel.')1299        self.assertEqual(1300            param_names[32], 'Std. log myokit.tumour_volume Sigma rel.')1301    def test_set_population_model_bad_input(self):1302        # Population models have the wrong type1303        pop_models = ['bad', 'type']1304        with self.assertRaisesRegex(TypeError, 'The population models'):1305            self.pd_problem.set_population_model(pop_models)1306        # Number of population models is not correct1307        pop_models = [chi.PooledModel()]1308        with self.assertRaisesRegex(ValueError, 'The number of population'):1309            self.pd_problem.set_population_model(pop_models)1310        # Specified parameter names do not coincide with model1311        pop_models = [chi.PooledModel()] * 71312        parameter_names = ['wrong names'] * 71313        with self.assertRaisesRegex(ValueError, 'The parameter names'):1314            self.pd_problem.set_population_model(pop_models, parameter_names)1315        # User is warned that data is reset as a result of unclear covariate1316        # mapping1317        self.pd_problem.set_data(1318            self.data,1319            output_observable_dict={1320                'central.drug_concentration': 'IL 6',1321                'myokit.tumour_volume': 'Tumour volume'})1322        cov_pop_model = chi.CovariatePopulationModel(1323            chi.GaussianModel(),1324            chi.LogNormalLinearCovariateModel(n_covariates=1)1325        )1326        pop_models = [cov_pop_model] * 71327        with self.assertWarns(UserWarning):1328            self.pd_problem.set_population_model(pop_models)1329class TestInverseProblem(unittest.TestCase):1330    """1331    Tests the chi.InverseProblem class.1332    """1333    @classmethod1334    def setUpClass(cls):1335        # Create test data1336        cls.times = [1, 2, 3, 4, 5]1337        cls.values = [1, 2, 3, 4, 5]1338        # Set up inverse problem1339        path = ModelLibrary().tumour_growth_inhibition_model_koch()1340        cls.model = chi.PharmacodynamicModel(path)1341        cls.problem = chi.InverseProblem(cls.model, cls.times, cls.values)1342    def test_bad_model_input(self):1343        model = 'bad model'1344        with self.assertRaisesRegex(ValueError, 'Model has to be an instance'):1345            chi.InverseProblem(model, self.times, self.values)1346    def test_bad_times_input(self):1347        times = [-1, 2, 3, 4, 5]1348        with self.assertRaisesRegex(ValueError, 'Times cannot be negative.'):1349            chi.InverseProblem(self.model, times, self.values)1350        times = [5, 4, 3, 2, 1]1351        with self.assertRaisesRegex(ValueError, 'Times must be increasing.'):1352            chi.InverseProblem(self.model, times, self.values)1353    def test_bad_values_input(self):1354        values = [1, 2, 3, 4, 5, 6, 7]1355        with self.assertRaisesRegex(ValueError, 'Values array must have'):1356            chi.InverseProblem(self.model, self.times, values)1357        values = [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]1358        with self.assertRaisesRegex(ValueError, 'Values array must have'):1359            chi.InverseProblem(self.model, self.times, values)1360    def test_evaluate(self):1361        parameters = [0.1, 1, 1, 1, 1]1362        output = self.problem.evaluate(parameters)1363        n_times = 51364        n_outputs = 11365        self.assertEqual(output.shape, (n_times, n_outputs))1366    def test_evaluateS1(self):1367        parameters = [0.1, 1, 1, 1, 1]1368        with self.assertRaises(NotImplementedError):1369            self.problem.evaluateS1(parameters)1370    def test_n_ouputs(self):1371        self.assertEqual(self.problem.n_outputs(), 1)1372    def test_n_parameters(self):1373        self.assertEqual(self.problem.n_parameters(), 5)1374    def test_n_times(self):1375        n_times = len(self.times)1376        self.assertEqual(self.problem.n_times(), n_times)1377    def test_times(self):1378        times = self.problem.times()1379        n_times = len(times)1380        self.assertEqual(n_times, 5)1381        self.assertEqual(times[0], self.times[0])1382        self.assertEqual(times[1], self.times[1])1383        self.assertEqual(times[2], self.times[2])1384        self.assertEqual(times[3], self.times[3])1385        self.assertEqual(times[4], self.times[4])1386    def test_values(self):1387        values = self.problem.values()1388        n_times = 51389        n_outputs = 11390        self.assertEqual(values.shape, (n_times, n_outputs))1391        self.assertEqual(values[0], self.values[0])1392        self.assertEqual(values[1], self.values[1])1393        self.assertEqual(values[2], self.values[2])1394        self.assertEqual(values[3], self.values[3])1395        self.assertEqual(values[4], self.values[4])1396if __name__ == '__main__':...

track_model_train.py

Source:track_model_train.py

1from __future__ import absolute_import, division, print_function2import numpy as np3import caffe4from caffe import layers as L5from caffe import params as P6channel_mean = np.array([123.68, 116.779, 103.939], dtype=np.float32)7###############################################################################8# Helper Methods9###############################################################################10def conv_relu(bottom, nout, ks=3, stride=1, pad=1, param_names=('conv_w', 'conv_b'), bias_term=True, fix_param=False, finetune=False):11    if fix_param:12        mult = [dict(name=param_names[0], lr_mult=0, decay_mult=0), dict(name=param_names[1], lr_mult=0, decay_mult=0)]13        conv = L.Convolution(bottom, kernel_size=ks, stride=stride,14                             num_output=nout, pad=pad, param=mult)15    else:16        if finetune:17            mult = [dict(name=param_names[0], lr_mult=0.1, decay_mult=1), dict(name=param_names[1], lr_mult=0.2, decay_mult=0)]18            conv = L.Convolution(bottom, kernel_size=ks, stride=stride,19                                 num_output=nout, pad=pad, param=mult)20        else:21            mult = [dict(name=param_names[0], lr_mult=1, decay_mult=1), dict(name=param_names[1], lr_mult=2, decay_mult=0)]22            filler = dict(type='xavier')23            conv = L.Convolution(bottom, kernel_size=ks, stride=stride,24                                 num_output=nout, pad=pad, bias_term=bias_term,25                                 param=mult, weight_filler=filler)26    return conv, L.ReLU(conv, in_place=True)27def conv(bottom, nout, ks=3, stride=1, pad=1, param_names=('conv_w', 'conv_b'), bias_term=True, fix_param=False, finetune=False):28    if fix_param:29        mult = [dict(name=param_names[0], lr_mult=0, decay_mult=0), dict(name=param_names[1], lr_mult=0, decay_mult=0)]30        conv = L.Convolution(bottom, kernel_size=ks, stride=stride,31                             num_output=nout, pad=pad, param=mult)32    else:33        if finetune:34            mult = [dict(name=param_names[0], lr_mult=0.1, decay_mult=1), dict(name=param_names[1], lr_mult=0.2, decay_mult=0)]35            conv = L.Convolution(bottom, kernel_size=ks, stride=stride,36                                 num_output=nout, pad=pad, param=mult)37        else:38            mult = [dict(name=param_names[0], lr_mult=1, decay_mult=1), dict(name=param_names[1], lr_mult=2, decay_mult=0)]39            filler = dict(type='xavier')40            conv = L.Convolution(bottom, kernel_size=ks, stride=stride,41                                 num_output=nout, pad=pad, bias_term=bias_term,42                                 param=mult, weight_filler=filler)43    return conv44def max_pool(bottom, ks=2, stride=2):45    return L.Pooling(bottom, pool=P.Pooling.MAX, kernel_size=ks, stride=stride)46################################################################################47# Model Generation48###############################################################################49def generate_scores(split, config):50    n = caffe.NetSpec()51    dataset = config.dataset52    batch_size = config.N53    mode_str = str(dict(dataset=dataset, split=split, batch_size=batch_size))54    n.image1, n.image2, n.label, n.sample_weights, n.feat_crop = L.Python(module=config.data_provider,55                                                                          layer=config.data_provider_layer,56                                                                          param_str=mode_str,57                                                                          ntop=5)58    ################################59    # the base net (VGG-16) branch 160    n.conv1_1, n.relu1_1 = conv_relu(n.image1, 64,61                                     param_names=('conv1_1_w', 'conv1_1_b'),62                                     fix_param=True,63                                     finetune=False)64    n.conv1_2, n.relu1_2 = conv_relu(n.relu1_1, 64,65                                     param_names=('conv1_2_w', 'conv1_2_b'),66                                     fix_param=True,67                                     finetune=False)68    n.pool1 = max_pool(n.relu1_2)69    n.conv2_1, n.relu2_1 = conv_relu(n.pool1, 128,70                                     param_names=('conv2_1_w', 'conv2_1_b'),71                                     fix_param=True,72                                     finetune=False)73    n.conv2_2, n.relu2_2 = conv_relu(n.relu2_1, 128,74                                     param_names=('conv2_2_w', 'conv2_2_b'),75                                     fix_param=True,76                                     finetune=False)77    n.pool2 = max_pool(n.relu2_2)78    n.conv3_1, n.relu3_1 = conv_relu(n.pool2, 256,79                                     param_names=('conv3_1_w', 'conv3_1_b'),80                                     fix_param=config.fix_vgg,81                                     finetune=config.finetune)82    n.conv3_2, n.relu3_2 = conv_relu(n.relu3_1, 256,83                                     param_names=('conv3_2_w', 'conv3_2_b'),84                                     fix_param=config.fix_vgg,85                                     finetune=config.finetune)86    n.conv3_3, n.relu3_3 = conv_relu(n.relu3_2, 256,87                                     param_names=('conv3_3_w', 'conv3_3_b'),88                                     fix_param=config.fix_vgg,89                                     finetune=config.finetune)90    n.pool3 = max_pool(n.relu3_3)91    # spatial L2 norm92    n.pool3_lrn = L.LRN(n.pool3, local_size=513, alpha=513, beta=0.5, k=1e-16)93    n.conv4_1, n.relu4_1 = conv_relu(n.pool3, 512,94                                     param_names=('conv4_1_w', 'conv4_1_b'),95                                     fix_param=config.fix_vgg,96                                     finetune=config.finetune)97    n.conv4_2, n.relu4_2 = conv_relu(n.relu4_1, 512,98                                     param_names=('conv4_2_w', 'conv4_2_b'),99                                     fix_param=config.fix_vgg,100                                     finetune=config.finetune)101    n.conv4_3, n.relu4_3 = conv_relu(n.relu4_2, 512,102                                     param_names=('conv4_3_w', 'conv4_3_b'),103                                     fix_param=config.fix_vgg,104                                     finetune=config.finetune)105    # spatial L2 norm106    n.relu4_3_lrn = L.LRN(n.relu4_3, local_size=1025, alpha=1025, beta=0.5, k=1e-16)107    #n.pool4 = max_pool(n.relu4_3)108    #n.conv5_1, n.relu5_1 = conv_relu(n.pool4, 512,109    #                                 param_names=('conv5_1_w', 'conv5_1_b'),110    #                                 fix_param=config.fix_vgg,111    #                                 finetune=config.finetune)112    #n.conv5_2, n.relu5_2 = conv_relu(n.relu5_1, 512,113    #                                 param_names=('conv5_2_w', 'conv5_2_b'),114    #                                 fix_param=config.fix_vgg,115    #                                 finetune=config.finetune)116    #n.conv5_3, n.relu5_3 = conv_relu(n.relu5_2, 512,117    #                                 param_names=('conv5_3_w', 'conv5_3_b'),118    #                                 fix_param=config.fix_vgg,119    #                                 finetune=config.finetune)120    # upsampling feature map121    #n.relu5_3_upsampling = L.Deconvolution(n.relu5_3,122    #                                       convolution_param=dict(num_output=512,123    #                                                              group=512,124    #                                                              kernel_size=4,125    #                                                              stride=2,126    #                                                              pad=1,127    #                                                              bias_term=False,128    #                                                              weight_filler=dict(type='bilinear')),129    #                                       param=[dict(lr_mult=0, decay_mult=0)])130    # spatial L2 norm131    #n.relu5_3_lrn = L.LRN(n.relu5_3_upsampling, local_size=1025, alpha=1025, beta=0.5, k=1e-16)132    # concat all skip features133    #n.feat_all1 = n.relu4_3_lrn134    n.feat_all1 = L.Concat(n.pool3_lrn, n.relu4_3_lrn, concat_param=dict(axis=1))135    #n.feat_all1 = L.Concat(n.pool3_lrn, n.relu4_3_lrn, n.relu5_3_lrn, concat_param=dict(axis=1))136    n.feat_all1_crop = L.Crop(n.feat_all1, n.feat_crop, crop_param=dict(axis=2, offset=[config.query_featmap_H//3, config.query_featmap_W//3]))137    138    ################################139    # the base net (VGG-16) branch 2140    n.conv1_1_p, n.relu1_1_p = conv_relu(n.image2, 64,141                                         param_names=('conv1_1_w', 'conv1_1_b'),142                                         fix_param=True,143                                         finetune=False)144    n.conv1_2_p, n.relu1_2_p = conv_relu(n.relu1_1_p, 64,145                                         param_names=('conv1_2_w', 'conv1_2_b'),146                                         fix_param=True,147                                         finetune=False)148    n.pool1_p = max_pool(n.relu1_2_p)149    n.conv2_1_p, n.relu2_1_p = conv_relu(n.pool1_p, 128,150                                         param_names=('conv2_1_w', 'conv2_1_b'),151                                         fix_param=True,152                                         finetune=False)153    n.conv2_2_p, n.relu2_2_p = conv_relu(n.relu2_1_p, 128,154                                         param_names=('conv2_2_w', 'conv2_2_b'),155                                         fix_param=True,156                                         finetune=False)157    n.pool2_p = max_pool(n.relu2_2_p)158    n.conv3_1_p, n.relu3_1_p = conv_relu(n.pool2_p, 256,159                                         param_names=('conv3_1_w', 'conv3_1_b'),160                                         fix_param=config.fix_vgg,161                                         finetune=config.finetune)162    n.conv3_2_p, n.relu3_2_p = conv_relu(n.relu3_1_p, 256,163                                         param_names=('conv3_2_w', 'conv3_2_b'),164                                         fix_param=config.fix_vgg,165                                         finetune=config.finetune)166    n.conv3_3_p, n.relu3_3_p = conv_relu(n.relu3_2_p, 256,167                                         param_names=('conv3_3_w', 'conv3_3_b'),168                                         fix_param=config.fix_vgg,169                                         finetune=config.finetune)170    n.pool3_p = max_pool(n.relu3_3_p)171    # spatial L2 norm172    n.pool3_lrn_p = L.LRN(n.pool3_p, local_size=513, alpha=513, beta=0.5, k=1e-16)173    n.conv4_1_p, n.relu4_1_p = conv_relu(n.pool3_p, 512,174                                         param_names=('conv4_1_w', 'conv4_1_b'),175                                         fix_param=config.fix_vgg,176                                         finetune=config.finetune)177    n.conv4_2_p, n.relu4_2_p = conv_relu(n.relu4_1_p, 512,178                                         param_names=('conv4_2_w', 'conv4_2_b'),179                                         fix_param=config.fix_vgg,180                                         finetune=config.finetune)181    n.conv4_3_p, n.relu4_3_p = conv_relu(n.relu4_2_p, 512,182                                         param_names=('conv4_3_w', 'conv4_3_b'),183                                         fix_param=config.fix_vgg,184                                         finetune=config.finetune)185    # spatial L2 norm186    n.relu4_3_lrn_p = L.LRN(n.relu4_3_p, local_size=1025, alpha=1025, beta=0.5, k=1e-16)187    #n.pool4_p = max_pool(n.relu4_3_p)188    #n.conv5_1_p, n.relu5_1_p = conv_relu(n.pool4_p, 512,189    #                                     param_names=('conv5_1_w', 'conv5_1_b'),190    #                                     fix_param=config.fix_vgg,191    #                                     finetune=config.finetune)192    #n.conv5_2_p, n.relu5_2_p = conv_relu(n.relu5_1_p, 512,193    #                                     param_names=('conv5_2_w', 'conv5_2_b'),194    #                                     fix_param=config.fix_vgg,195    #                                     finetune=config.finetune)196    #n.conv5_3_p, n.relu5_3_p = conv_relu(n.relu5_2_p, 512,197    #                                     param_names=('conv5_3_w', 'conv5_3_b'),198    #                                     fix_param=config.fix_vgg,199    #                                     finetune=config.finetune)200    # upsampling feature map201    #n.relu5_3_upsampling_p = L.Deconvolution(n.relu5_3_p,202    #                                         convolution_param=dict(num_output=512,203    #                                                                group=512,204    #                                                                kernel_size=4,205    #                                                                stride=2,206    #                                                                pad=1,207    #                                                                bias_term=False,208    #                                                                weight_filler=dict(type='bilinear')),209    #                                         param=[dict(lr_mult=0, decay_mult=0)])210    # spatial L2 norm211    #n.relu5_3_lrn_p = L.LRN(n.relu5_3_upsampling_p, local_size=1025, alpha=1025, beta=0.5, k=1e-16)212    # concat all skip features213    #n.feat_all2 = n.relu4_3_lrn_p214    n.feat_all2 = L.Concat(n.pool3_lrn_p, n.relu4_3_lrn_p, concat_param=dict(axis=1))215    #n.feat_all2 = L.Concat(n.pool3_lrn_p, n.relu4_3_lrn_p, n.relu5_3_lrn_p, concat_param=dict(axis=1))216    # Dyn conv layer217    n.fcn_scores = L.DynamicConvolution(n.feat_all2, n.feat_all1_crop,218                                        convolution_param=dict(num_output=1,219                                                               kernel_size=11,220                                                               stride=1,221                                                               pad=5,222                                                               bias_term=False))223    return n.to_proto()224def generate_model(split, config):225    n = caffe.NetSpec()226    dataset = config.dataset227    batch_size = config.N228    mode_str = str(dict(dataset=dataset, split=split, batch_size=batch_size))229    n.image1, n.image2, n.label, n.sample_weights, n.feat_crop = L.Python(module=config.data_provider,230                                                                          layer=config.data_provider_layer,231                                                                          param_str=mode_str,232                                                                          ntop=5)233    ################################234    # the base net (VGG-16) branch 1235    n.conv1_1, n.relu1_1 = conv_relu(n.image1, 64,236                                     param_names=('conv1_1_w', 'conv1_1_b'),237                                     fix_param=True,238                                     finetune=False)239    n.conv1_2, n.relu1_2 = conv_relu(n.relu1_1, 64,240                                     param_names=('conv1_2_w', 'conv1_2_b'),241                                     fix_param=True,242                                     finetune=False)243    n.pool1 = max_pool(n.relu1_2)244    n.conv2_1, n.relu2_1 = conv_relu(n.pool1, 128,245                                     param_names=('conv2_1_w', 'conv2_1_b'),246                                     fix_param=True,247                                     finetune=False)248    n.conv2_2, n.relu2_2 = conv_relu(n.relu2_1, 128,249                                     param_names=('conv2_2_w', 'conv2_2_b'),250                                     fix_param=True,251                                     finetune=False)252    n.pool2 = max_pool(n.relu2_2)253    n.conv3_1, n.relu3_1 = conv_relu(n.pool2, 256,254                                     param_names=('conv3_1_w', 'conv3_1_b'),255                                     fix_param=config.fix_vgg,256                                     finetune=config.finetune)257    n.conv3_2, n.relu3_2 = conv_relu(n.relu3_1, 256,258                                     param_names=('conv3_2_w', 'conv3_2_b'),259                                     fix_param=config.fix_vgg,260                                     finetune=config.finetune)261    n.conv3_3, n.relu3_3 = conv_relu(n.relu3_2, 256,262                                     param_names=('conv3_3_w', 'conv3_3_b'),263                                     fix_param=config.fix_vgg,264                                     finetune=config.finetune)265    n.pool3 = max_pool(n.relu3_3)266    # spatial L2 norm267    n.pool3_lrn = L.LRN(n.pool3, local_size=513, alpha=513, beta=0.5, k=1e-16)268    n.conv4_1, n.relu4_1 = conv_relu(n.pool3, 512,269                                     param_names=('conv4_1_w', 'conv4_1_b'),270                                     fix_param=config.fix_vgg,271                                     finetune=config.finetune)272    n.conv4_2, n.relu4_2 = conv_relu(n.relu4_1, 512,273                                     param_names=('conv4_2_w', 'conv4_2_b'),274                                     fix_param=config.fix_vgg,275                                     finetune=config.finetune)276    n.conv4_3, n.relu4_3 = conv_relu(n.relu4_2, 512,277                                     param_names=('conv4_3_w', 'conv4_3_b'),278                                     fix_param=config.fix_vgg,279                                     finetune=config.finetune)280    # spatial L2 norm281    n.relu4_3_lrn = L.LRN(n.relu4_3, local_size=1025, alpha=1025, beta=0.5, k=1e-16)282    #n.pool4 = max_pool(n.relu4_3)283    #n.conv5_1, n.relu5_1 = conv_relu(n.pool4, 512,284    #                                 param_names=('conv5_1_w', 'conv5_1_b'),285    #                                 fix_param=config.fix_vgg,286    #                                 finetune=config.finetune)287    #n.conv5_2, n.relu5_2 = conv_relu(n.relu5_1, 512,288    #                                 param_names=('conv5_2_w', 'conv5_2_b'),289    #                                 fix_param=config.fix_vgg,290    #                                 finetune=config.finetune)291    #n.conv5_3, n.relu5_3 = conv_relu(n.relu5_2, 512,292    #                                 param_names=('conv5_3_w', 'conv5_3_b'),293    #                                 fix_param=config.fix_vgg,294    #                                 finetune=config.finetune)295    # upsampling feature map296    #n.relu5_3_upsampling = L.Deconvolution(n.relu5_3,297    #                                       convolution_param=dict(num_output=512,298    #                                                              group=512,299    #                                                              kernel_size=4,300    #                                                              stride=2,301    #                                                              pad=1,302    #                                                              bias_term=False,303    #                                                              weight_filler=dict(type='bilinear')),304    #                                       param=[dict(lr_mult=0, decay_mult=0)])305    # spatial L2 norm306    #n.relu5_3_lrn = L.LRN(n.relu5_3_upsampling, local_size=1025, alpha=1025, beta=0.5, k=1e-16)307    # concat all skip features308    #n.feat_all1 = n.relu4_3_lrn309    n.feat_all1 = L.Concat(n.pool3_lrn, n.relu4_3_lrn, concat_param=dict(axis=1))310    #n.feat_all1 = L.Concat(n.pool3_lrn, n.relu4_3_lrn, n.relu5_3_lrn, concat_param=dict(axis=1))311    n.feat_all1_crop = L.Crop(n.feat_all1, n.feat_crop, crop_param=dict(axis=2, offset=[config.query_featmap_H//3, config.query_featmap_W//3]))312    ################################313    # the base net (VGG-16) branch 2314    n.conv1_1_p, n.relu1_1_p = conv_relu(n.image2, 64,315                                         param_names=('conv1_1_w', 'conv1_1_b'),316                                         fix_param=True,317                                         finetune=False)318    n.conv1_2_p, n.relu1_2_p = conv_relu(n.relu1_1_p, 64,319                                         param_names=('conv1_2_w', 'conv1_2_b'),320                                         fix_param=True,321                                         finetune=False)322    n.pool1_p = max_pool(n.relu1_2_p)323    n.conv2_1_p, n.relu2_1_p = conv_relu(n.pool1_p, 128,324                                         param_names=('conv2_1_w', 'conv2_1_b'),325                                         fix_param=True,326                                         finetune=False)327    n.conv2_2_p, n.relu2_2_p = conv_relu(n.relu2_1_p, 128,328                                         param_names=('conv2_2_w', 'conv2_2_b'),329                                         fix_param=True,330                                         finetune=False)331    n.pool2_p = max_pool(n.relu2_2_p)332    n.conv3_1_p, n.relu3_1_p = conv_relu(n.pool2_p, 256,333                                         param_names=('conv3_1_w', 'conv3_1_b'),334                                         fix_param=config.fix_vgg,335                                         finetune=config.finetune)336    n.conv3_2_p, n.relu3_2_p = conv_relu(n.relu3_1_p, 256,337                                         param_names=('conv3_2_w', 'conv3_2_b'),338                                         fix_param=config.fix_vgg,339                                         finetune=config.finetune)340    n.conv3_3_p, n.relu3_3_p = conv_relu(n.relu3_2_p, 256,341                                         param_names=('conv3_3_w', 'conv3_3_b'),342                                         fix_param=config.fix_vgg,343                                         finetune=config.finetune)344    n.pool3_p = max_pool(n.relu3_3_p)345    # spatial L2 norm346    n.pool3_lrn_p = L.LRN(n.pool3_p, local_size=513, alpha=513, beta=0.5, k=1e-16)347    n.conv4_1_p, n.relu4_1_p = conv_relu(n.pool3_p, 512,348                                         param_names=('conv4_1_w', 'conv4_1_b'),349                                         fix_param=config.fix_vgg,350                                         finetune=config.finetune)351    n.conv4_2_p, n.relu4_2_p = conv_relu(n.relu4_1_p, 512,352                                         param_names=('conv4_2_w', 'conv4_2_b'),353                                         fix_param=config.fix_vgg,354                                         finetune=config.finetune)355    n.conv4_3_p, n.relu4_3_p = conv_relu(n.relu4_2_p, 512,356                                         param_names=('conv4_3_w', 'conv4_3_b'),357                                         fix_param=config.fix_vgg,358                                         finetune=config.finetune)359    # spatial L2 norm360    n.relu4_3_lrn_p = L.LRN(n.relu4_3_p, local_size=1025, alpha=1025, beta=0.5, k=1e-16)361    #n.pool4_p = max_pool(n.relu4_3_p)362    #n.conv5_1_p, n.relu5_1_p = conv_relu(n.pool4_p, 512,363    #                                     param_names=('conv5_1_w', 'conv5_1_b'),364    #                                     fix_param=config.fix_vgg,365    #                                     finetune=config.finetune)366    #n.conv5_2_p, n.relu5_2_p = conv_relu(n.relu5_1_p, 512,367    #                                     param_names=('conv5_2_w', 'conv5_2_b'),368    #                                     fix_param=config.fix_vgg,369    #                                     finetune=config.finetune)370    #n.conv5_3_p, n.relu5_3_p = conv_relu(n.relu5_2_p, 512,371    #                                     param_names=('conv5_3_w', 'conv5_3_b'),372    #                                     fix_param=config.fix_vgg,373    #                                     finetune=config.finetune)374    # upsampling feature map375    #n.relu5_3_upsampling_p = L.Deconvolution(n.relu5_3_p,376    #                                         convolution_param=dict(num_output=512,377    #                                                                group=512,378    #                                                                kernel_size=4,379    #                                                                stride=2,380    #                                                                pad=1,381    #                                                                bias_term=False,382    #                                                                weight_filler=dict(type='bilinear')),383    #                                         param=[dict(lr_mult=0, decay_mult=0)])384    # spatial L2 norm385    #n.relu5_3_lrn_p = L.LRN(n.relu5_3_upsampling_p, local_size=1025, alpha=1025, beta=0.5, k=1e-16)386    # concat all skip features387    #n.feat_all2 = n.relu4_3_lrn_p388    n.feat_all2 = L.Concat(n.pool3_lrn_p, n.relu4_3_lrn_p, concat_param=dict(axis=1))389    #n.feat_all2 = L.Concat(n.pool3_lrn_p, n.relu4_3_lrn_p, n.relu5_3_lrn_p, concat_param=dict(axis=1))390    # Dyn conv layer391    n.fcn_scores = L.DynamicConvolution(n.feat_all2, n.feat_all1_crop,392                                        convolution_param=dict(num_output=1,393                                                               kernel_size=11,394                                                               stride=1,395                                                               pad=5,396                                                               bias_term=False))397    398    # scale scores with zero mean 0.01196 -> 0.02677399    n.fcn_scaled_scores = L.Power(n.fcn_scores, power_param=dict(scale=0.01196,400                                                                 shift=-1.0,401                                                                 power=1))402    # Loss Layer403    n.loss = L.WeightedSigmoidCrossEntropyLoss(n.fcn_scaled_scores, n.label, n.sample_weights)...

translations.py

Source:translations.py

1"""2    Flowblade Movie Editor is a nonlinear video editor.3    Copyright 2012 Janne Liljeblad.4    This file is part of Flowblade Movie Editor <http://code.google.com/p/flowblade>.5    Flowblade Movie Editor is free software: you can redistribute it and/or modify6    it under the terms of the GNU General Public License as published by7    the Free Software Foundation, either version 3 of the License, or8    (at your option) any later version.9    Flowblade Movie Editor is distributed in the hope that it will be useful,10    but WITHOUT ANY WARRANTY; without even the implied warranty of11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12    GNU General Public License for more details.13    You should have received a copy of the GNU General Public License14    along with Flowblade Movie Editor.  If not, see <http://www.gnu.org/licenses/>.15"""16import gettext17import locale18import os19import respaths20APP_NAME = "Flowblade"21lang = None22filter_groups = {}23filter_names = {}24param_names = {}25combo_options = {}26def init_languages():27    langs = []28    lc, encoding = locale.getdefaultlocale()29    if (lc):30        langs = [lc]31    print "Locale:", lc32    language = os.environ.get('LANGUAGE', None)33    if (language):34        langs += language.split(":")35    gettext.bindtextdomain(APP_NAME, respaths.LOCALE_PATH)36    gettext.textdomain(APP_NAME)37    # Get the language to use38    global lang39    #lang = gettext.translation(APP_NAME, respaths.LOCALE_PATH, languages=["fi"], fallback=True) # Testing, comment out for production40    lang = gettext.translation(APP_NAME, respaths.LOCALE_PATH, languages=langs, fallback=True)41    lang.install(APP_NAME) # makes _() a build-in available in all modules without imports42def get_filter_name(f_name):43    try:44        return filter_names[f_name]45    except KeyError:46        return f_name47def get_filter_group_name(group_name):48    try:49        return filter_groups[group_name]50    except:51        return group_name52def get_param_name(name):53    try:54        return param_names[name]55    except KeyError:56        return name57def get_combo_option(c_opt):58    try:59        return combo_options[c_opt]60    except KeyError:61        return c_opt62        63def load_filters_translations():64    # filter group names65    global filter_groups66    filter_groups["Color"] = _("Color")67    filter_groups["Color Effect"] = _("Color Effect")68    filter_groups["Audio"] = _("Audio")69    filter_groups["Audio Filter"] = _("Audio Filter")70    filter_groups["Blur"] = _("Blur")71    filter_groups["Distort"] = _("Distort")72    filter_groups["Alpha"] = _("Alpha")73    filter_groups["Movement"] = _("Movement")74    filter_groups["Transform"] = _("Transform")75    filter_groups["Edge"] = _("Edge")76    filter_groups["Fix"] = _("Fix")77    filter_groups["Artistic"] = _("Artistic")78    # filter names79    global filter_names80    filter_names["Alpha Gradient"] = _("Alpha Gradient")81    filter_names["Crop"] = _("Crop")82    filter_names["Alpha Shape"]= _("Alpha Shape")83    84    filter_names["Volume"]= _("Volume")85    filter_names["Pan"]= _("Pan")86    filter_names["Pan Keyframed"]= _("Pan Keyframed")87    filter_names["Mono to Stereo"]= _("Mono to Stereo")88    filter_names["Swap Channels"]= _("Swap Channels")89    filter_names["Pitchshifter"]= _("Pitchshifter")90    filter_names["Distort - Barry's Satan"]= _("Distort - Barry's Satan")91    filter_names["Frequency Shift - Bode/Moog"]= _("Frequency Shift - Bode/Moog")92    filter_names["Equalize - DJ 3-band"]= _("Equalize - DJ 3-band")93    filter_names["Flanger - DJ"]= _("Flanger - DJ")94    filter_names["Declipper"]= _("Declipper")95    filter_names["Delayorama"]= _("Delayorama")96    filter_names["Distort - Diode Processor"]= _("Distort - Diode Processor")97    filter_names["Distort - Foldover"]= _("Distort - Foldover")98    filter_names["Highpass - Butterworth"]= _("Highpass - Butterworth")99    filter_names["Lowpass - Butterworth"]= _("Lowpass - Butterworth")100    filter_names["GSM Simulator"]= _("GSM Simulator")101    filter_names["Reverb - GVerb"]= _("Reverb - GVerb")102    filter_names["Noise Gate"]= _("Noise Gate")103    filter_names["Bandpass"]= _("Bandpass")104    filter_names["Pitchscaler - High Quality"]= _("Pitchscaler - High Quality")105    filter_names["Equalize - Multiband"]= _("Equalize - Multiband")106    filter_names["Reverb - Plate"]= _("Reverb - Plate")107    filter_names["Distort - Pointer cast"]= _("Distort - Pointer cast")108    filter_names["Rate Shifter"]= _("Rate Shifter")109    filter_names["Signal Shifter"]= _("Signal Shifter")110    filter_names["Distort - Sinus Wavewrap"]= _("Distort - Sinus Wavewrap")111    filter_names["Vinyl Effect"]= _("Vinyl Effect")112    filter_names["Chorus - Multivoice"]= _("Chorus - Multivoice")113    filter_names["Charcoal"]= _("Charcoal")114    filter_names["Glow"]= _("Glow")115    filter_names["Old Film"]= _("Old Film")116    filter_names["Scanlines"]= _("Scanlines")117    filter_names["Cartoon"]= _("Cartoon")118    119    filter_names["Pixelize"]= _("Pixelize")120    filter_names["Blur"]= _("Blur")121    filter_names["Grain"]= _("Grain")122    123    filter_names["Grayscale"]= _("Grayscale")124    filter_names["Contrast"]= _("Contrast")125    filter_names["Saturation"]= _("Saturation")126    filter_names["Invert"]= _("Invert")127    filter_names["Hue"]= _("Hue")128    filter_names["Brightness"]= _("Brightness")129    filter_names["Sepia"]= _("Sepia")130    filter_names["Tint"]= _("Tint")131    filter_names["White Balance"]= _("White Balance")132    filter_names["Levels"]= _("Levels")133    filter_names["Color Clustering"]= _("Color Clustering")134    filter_names["Chroma Hold"]= _("Chroma Hold")135    filter_names["Three Layer"]= _("Three Layer")136    filter_names["Threshold0r"]= _("Threshold0r")137    filter_names["Technicolor"]= _("Technicolor")138    filter_names["Primaries"]= _("Primaries")139    filter_names["Color Distance"]= _("Color Distance")140    filter_names["Threshold"]= _("Threshold")141    filter_names["Waves"]= _("Waves")142    filter_names["Lens Correction"]= _("Lens Correction")143    filter_names["Flip"]= _("Flip")144    filter_names["Mirror"]= _("Mirror")145    filter_names["V Sync"]= _("V Sync")146    filter_names["Edge Glow"]= _("Edge Glow")147    filter_names["Sobel"]= _("Sobel")148    filter_names["Denoise"]= _("Denoise")149    filter_names["Sharpness"]= _("Sharpness")150    filter_names["Letterbox"]= _("Letterbox")151    filter_names["Baltan"]= _("Baltan")152    filter_names["Vertigo"]= _("Vertigo")153    filter_names["Nervous"]= _("Nervous")154    filter_names["Freeze"]= _("Freeze")155    filter_names["Rotate"]= _("Rotate")156    filter_names["Shear"]= _("Shear")157    filter_names["Translate"]= _("Translate")158    # 0.8 added159    filter_names["Color Select"]= _("Color Select")160    filter_names["Alpha Modify"]= _("Alpha Modify")161    filter_names["Spill Supress"]= _("Spill Supress")162    filter_names["RGB Noise"]= _("RGB Noise")163    filter_names["Box Blur"]= _("Box Blur")164    filter_names["IRR Blur"]= _("IRR Blur")165    filter_names["Color Halftone"]= _("Color Halftone")166    filter_names["Dither"]= _("Dither")167    filter_names["Vignette"]= _("Vignette")168    filter_names["Emboss"]= _("Emboss")169    filter_names["3 Point Balance"]= _("3 Point Balance")170    filter_names["Colorize"]= _("Colorize")171    filter_names["Brightness Keyframed"]= _("Brightness Keyframed")172    filter_names["RGB Adjustment"]= _("RGB Adjustment")173    filter_names["Color Tap"]= _("Color Tap")174    filter_names["Posterize"]= _("Posterize")175    filter_names["Soft Glow"]= _("Soft Glow")176    filter_names["Newspaper"]= _("Newspaper")177    # 0.16 added178    filter_names["Luma Key"] = _("Luma Key")179    filter_names["Chroma Key"] = _("Chroma Key")180    filter_names["Affine"] = _("Affine")181    filter_names["Color Adjustment"] = _("Color Adjustment")182    filter_names["Color Grading"] = _("Color Grading")183    filter_names["Curves"] = _("Curves")184    filter_names["Lift Gain Gamma"] = _("Lift Gain Gamma")185    filter_names["Image Grid"] = _("Image Grid")186    187    # 0.18188    filter_names["Color Lift Gain Gamma"] = _("Color Lift Gain Gamma")189    190    # param names191    global param_names192    # param names for filters193    param_names["Position"] = _("Position")194    param_names["Grad width"] = _("Grad width")195    param_names["Tilt"] = _("Tilt")196    param_names["Min"] = _("Min")197    param_names["Max"] = _("Max")198    param_names["Left"] = _("Left")199    param_names["Right"] = _("Right")200    param_names["Top"] = _("Top")201    param_names["Bottom"] = _("Bottom")202    param_names["Shape"] = _("Shape")203    param_names["Pos X"] = _("Pos X")204    param_names["Pos Y"] = _("Pos Y")205    param_names["Size X"] = _("Size X")206    param_names["Size Y"] = _("Size Y")207    param_names["Tilt"] = _("Tilt")208    param_names["Trans. Width"] = _("Trans. Width")209    param_names["Volume"] = _("Volume")210    param_names["Left/Right"] = _("Left/Right")211    param_names["Left/Right"] = _("Left/Right")212    param_names["Dry/Wet"] = _("Dry/Wet")213    param_names["Pitch Shift"] = _("Pitch Shift")214    param_names["Buffer Size"] = _("Buffer Size")215    param_names["Dry/Wet"] = _("Dry/Wet")216    param_names["Decay Time(samples)"] = _("Decay Time(samples)")217    param_names["Knee Point(dB)"] = _("Knee Point(dB)")218    param_names["Dry/Wet"] = _("Dry/Wet")219    param_names["Frequency shift"] = _("Frequency shift")220    param_names["Dry/Wet"] = _("Dry/Wet")221    param_names["Low Gain(dB)"] = _("Low Gain(dB)")222    param_names["Mid Gain(dB)"] = _("Mid Gain(dB)")223    param_names["High Gain(dB)"] = _("High Gain(dB)")224    param_names["Dry/Wet"] = _("Dry/Wet")225    param_names["Oscillation period(s)"] = _("Oscillation period(s)")226    param_names["Oscillation depth(ms)"] = _("Oscillation depth(ms)")227    param_names["Feedback%"] = _("Feedback%")228    param_names["Dry/Wet"] = _("Dry/Wet")229    param_names["Dry/Wet"] = _("Dry/Wet")230    param_names["Random seed"] = _("Random seed")231    param_names["Input Gain(dB)"] = _("Input Gain(dB)")232    param_names["Feedback(%)"] = _("Feedback(%)")233    param_names["Number of taps"] = _("Number of taps")234    param_names["First Delay(s)"] = _("First Delay(s)")235    param_names["Delay Range(s)"] = _("Delay Range(s)")236    param_names["Delay Change"] = _("Delay Change")237    param_names["Delay Random(%)"] = _("Delay Random(%)")238    param_names["Amplitude Change"] = _("Amplitude Change")239    param_names["Amplitude Random(%)"] = _("Amplitude Random(%)")240    param_names["Dry/Wet"] = _("Dry/Wet")241    param_names["Amount"] = _("Amount")242    param_names["Dry/Wet"] = _("Dry/Wet")243    param_names["Drive"] = _("Drive")244    param_names["Skew"] = _("Skew")245    param_names["Dry/Wet"] = _("Dry/Wet")246    param_names["Cutoff Frequency(Hz)"] = _("Cutoff Frequency(Hz)")247    param_names["Resonance"] = _("Resonance")248    param_names["Dry/Wet"] = _("Dry/Wet")249    param_names["Cutoff Frequency(Hz)"] = _("Cutoff Frequency(Hz)")250    param_names["Resonance"] = _("Resonance")251    param_names["Dry/Wet"] = _("Dry/Wet")252    param_names["Passes"] = _("Passes")253    param_names["Error Rate"] = _("Error Rate")254    param_names["Dry/Wet"] = _("Dry/Wet")255    param_names["Roomsize"] = _("Roomsize")256    param_names["Reverb time(s)"] = _("Reverb time(s)")257    param_names["Damping"] = _("Damping")258    param_names["Input bandwith"] = _("Input bandwith")259    param_names["Dry signal level(dB)"] = _("Dry signal level(dB)")260    param_names["Early reflection level(dB)"] = _("Early reflection level(dB)")261    param_names["Tail level(dB)"] = _("Tail level(dB)")262    param_names["Dry/Wet"] = _("Dry/Wet")263    param_names["LF keyfilter(Hz)"] = _("LF keyfilter(Hz)")264    param_names["HF keyfilter(Hz)"] = _("HF keyfilter(Hz)")265    param_names["Threshold(dB)"] = _("Threshold(dB)")266    param_names["Attack(ms)"] = _("Attack(ms)")267    param_names["Hold(ms)"] = _("Hold(ms)")268    param_names["Decay(ms)"] = _("Decay(ms)")269    param_names["Range(dB)"] = _("Range(dB)")270    param_names["Dry/Wet"] = _("Dry/Wet")271    param_names["Center Frequency(Hz)"] = _("Center Frequency(Hz)")272    param_names["Bandwidth(Hz)"] = _("Bandwidth(Hz)")273    param_names["Stages"] = _("Stages")274    param_names["Dry/Wet"] = _("Dry/Wet")275    param_names["Pitch-coefficient"] = _("Pitch-coefficient")276    param_names["Dry/Wet"] = _("Dry/Wet")277    param_names["50Hz gain"] = _("50Hz gain")278    param_names["100Hz gain"] = _("100Hz gain")279    param_names["156Hz gain"] = _("156Hz gain")280    param_names["220Hz gain"] = _("220Hz gain")281    param_names["311Hz gain"] = _("311Hz gain")282    param_names["440Hz gain"] = _("440Hz gain")283    param_names["622Hz gain"] = _("622Hz gain")284    param_names["880Hz gain"] = _("880Hz gain")285    param_names["1250Hz gain"] = _("1250Hz gain")286    param_names["1750Hz gain"] = _("1750Hz gain")287    param_names["2500Hz gain"] = _("2500Hz gain")288    param_names["3500Hz gain"] = _("3500Hz gain")289    param_names["5000Hz gain"] = _("5000Hz gain")290    param_names["100000Hz gain"] = _("100000Hz gain")291    param_names["200000Hz gain"] = _("200000Hz gain")292    param_names["Dry/Wet"] = _("Dry/Wet")293    param_names["Reverb time"] = _("Reverb time")294    param_names["Damping"] = _("Damping")295    param_names["Dry/Wet mix"] = _("Dry/Wet mix")296    param_names["Dry/Wet"] = _("Dry/Wet")297    param_names["Effect cutoff(Hz)"] = _("Effect cutoff(Hz)")298    param_names["Dry/Wet mix"] = _("Dry/Wet mix")299    param_names["Dry/Wet"] = _("Dry/Wet")300    param_names["Rate"] = _("Rate")301    param_names["Dry/Wet"] = _("Dry/Wet")302    param_names["Sift"] = _("Sift")303    param_names["Dry/Wet"] = _("Dry/Wet")304    param_names["Amount"] = _("Amount")305    param_names["Dry/Wet"] = _("Dry/Wet")306    param_names["Year"] = _("Year")307    param_names["RPM"] = _("RPM")308    param_names["Surface warping"] = _("Surface warping")309    param_names["Cracle"] = _("Cracle")310    param_names["Wear"] = _("Wear")311    param_names["Dry/Wet"] = _("Dry/Wet")312    param_names["Number of voices"] = _("Number of voices")313    param_names["Delay base(ms)"] = _("Delay base(ms)")314    param_names["Voice separation(ms)"] = _("Voice separation(ms)")315    param_names["Detune(%)"] = _("Detune(%)")316    param_names["Oscillation frequency(Hz)"] = _("Oscillation frequency(Hz)")317    param_names["Output attenuation(dB)"] = _("Output attenuation(dB)")318    param_names["Dry/Wet"] = _("Dry/Wet")319    param_names["X Scatter"] = _("X Scatter")320    param_names["Y Scatter"] = _("Y Scatter")321    param_names["Scale"] = _("Scale")322    param_names["Mix"] = _("Mix")323    param_names["Invert"] = _("Invert")324    param_names["Blur"] = _("Blur")325    param_names["Delta"] = _("Delta")326    param_names["Duration"] = _("Duration")327    param_names["Bright. up"] = _("Bright. up")328    param_names["Bright. down"] = _("Bright. down")329    param_names["Bright. dur."] = _("Bright. dur.")330    param_names["Develop up"] = _("Develop up")331    param_names["Develop down"] = _("Develop down")332    param_names["Develop dur."] = _("Develop dur.")333    param_names["Triplevel"] = _("Triplevel")334    param_names["Difference Space"] = _("Difference Space")335    param_names["Block width"] = _("Block width")336    param_names["Block height"] = _("Block height")337    param_names["Size"] = _("Size")338    param_names["Noise"] = _("Noise")339    param_names["Contrast"] = _("Contrast")340    param_names["Brightness"] = _("Brightness")341    param_names["Contrast"] = _("Contrast")342    param_names["Saturation"] = _("Saturation")343    param_names["Hue"] = _("Hue")344    param_names["Brightness"] = _("Brightness")345    param_names["Brightness"] = _("Brightness")346    param_names["U"] = _("U")347    param_names["V"] = _("V")348    param_names["Black"] = _("Black")349    param_names["White"] = _("White")350    param_names["Amount"] = _("Amount")351    param_names["Neutral Color"] = _("Neutral Color")352    param_names["Input"] = _("Input")353    param_names["Input"] = _("Input")354    param_names["Gamma"] = _("Gamma")355    param_names["Black"] = _("Black")356    param_names["White"] = _("White")357    param_names["Num"] = _("Num")358    param_names["Dist. weight"] = _("Dist. weight")359    param_names["Color"] = _("Color")360    param_names["Variance"] = _("Variance")361    param_names["Threshold"] = _("Threshold")362    param_names["Red Saturation"] = _("Red Saturation")363    param_names["Yellow Saturation"] = _("Yellow Saturation")364    param_names["Factor"] = _("Factor")365    param_names["Source color"] = _("Source color")366    param_names["Threshold"] = _("Threshold")367    param_names["Amplitude"] = _("Amplitude")368    param_names["Frequency"] = _("Frequency")369    param_names["Rotate"] = _("Rotate")370    param_names["Tilt"] = _("Tilt")371    param_names["Center Correct"] = _("Center Correct")372    param_names["Edges Correct"] = _("Edges Correct")373    param_names["Flip"] = _("Flip")374    param_names["Axis"] = _("Axis")375    param_names["Invert"] = _("Invert")376    param_names["Position"] = _("Position")377    param_names["Edge Lightning"] = _("Edge Lightning")378    param_names["Edge Brightness"] = _("Edge Brightness")379    param_names["Non-Edge Brightness"] = _("Non-Edge Brightness")380    param_names["Spatial"] = _("Spatial")381    param_names["Temporal"] = _("Temporal")382    param_names["Amount"] = _("Amount")383    param_names["Size"] = _("Size")384    param_names["Border width"] = _("Border width")385    param_names["Phase Incr."] = _("Phase Incr.")386    param_names["Zoom"] = _("Zoom")387    param_names["Freeze Frame"] = _("Freeze Frame")388    param_names["Freeze After"] = _("Freeze After")389    param_names["Freeze Before"] = _("Freeze Before")390    param_names["Angle"] = _("Angle")391    param_names["transition.geometry"] = _("transition.geometry")392    param_names["Shear X"] = _("Shear X")393    param_names["Shear Y"] = _("Shear Y")394    param_names["transition.geometry"] = _("transition.geometry")395    param_names["transition.geometry"] = _("transition.geometry")396    param_names["Left"] = _("Left")397    param_names["Right"] = _("Right")398    param_names["Top"] = _("Top")399    param_names["Bottom"] = _("Bottom")400    param_names["Invert"] = _("Invert")401    param_names["Blur"] = _("Blur")402    param_names["Opacity"] = _("Opacity")403    param_names["Opacity"] = _("Opacity")404    param_names["Rotate X"] = _("Rotate X")405    param_names["Rotate Y"] = _("Rotate Y")406    param_names["Rotate Z"] = _("Rotate Z")407    # added 0.8408    param_names["Edge Mode"] = _("Edge Mode")409    param_names["Sel. Space"] = _("Sel. Space")410    param_names["Operation"] = _("Operation")411    param_names["Hard"] = _("Hard")412    param_names["R/A/Hue"] = _("R/A/Hue")413    param_names["G/B/Chromae"] = _("G/B/Chroma")414    param_names["B/I/I"] = _("B/I/I")415    param_names["Supress"] = _("Supress")416    param_names["Horizontal"] = _("Horizontal")417    param_names["Vertical"] = _("Vertical")418    param_names["Type"] = _("Type")419    param_names["Edge"] = _("Edge")420    param_names["Dot Radius"] = _("Dot Radius")421    param_names["Cyan Angle"] = _("Cyan Angle")422    param_names["Magenta Angle"] = _("Magenta Angle")423    param_names["Yellow Angle"] = _("Yellow Angle")424    param_names["Levels"] = _("Levels")425    param_names["Matrix Type"] = _("Matrix Type")426    param_names["Aspect"] = _("Aspect")427    param_names["Center Size"] = _("Center Size")428    param_names["Azimuth"] = _("Azimuth")429    param_names["Lightness"] = _("Lightness")430    param_names["Bump Height"] = _("Bump Height")431    param_names["Gray"] = _("Gray")432    param_names["Split Preview"] = _("Split Preview")433    param_names["Source on Left"] = _("Source on Left")434    param_names["Lightness"] = _("Lightness")435    param_names["Input black level"] = _("Input black level")436    param_names["Input white level"] = _("Input white level")437    param_names["Black output"] = _("Black output")438    param_names["White output"] = _("White output")439    param_names["Red"] = _("Red")440    param_names["Green"] = _("Green")441    param_names["Blue"] = _("Blue")442    param_names["Action"] = _("Action")443    param_names["Keep Luma"] = _("Keep Luma")444    param_names["Luma Formula"] = _("Luma Formula")445    param_names["Effect"] = _("Effect")446    param_names["Sharpness"] = _("Sharpness")447    param_names["Blend Type"] = _("Blend Type")448    # added 0.16449    param_names["Key Color"] = _("Key Color")450    param_names["Pre-Level"] = _("Pre-Level")451    param_names["Post-Level"] = _("Post-Level")452    param_names["Slope"] = _("Slope")453    param_names["Luma Band"] = _("Luma Band")454    param_names["Lift"] = _("Lift")455    param_names["Gain"] = _("Gain")456    param_names["Input White Level"] = _("Input White Level")457    param_names["Input Black Level"] = _("Input Black Level")458    param_names["Black Output"] = _("Black Output")459    param_names["White Output"] = _("White Output")460    param_names["Rows"] = _("Rows")461    param_names["Columns"] = _("Columns")462    param_names["Color Temperature"] = _("Color Temperature")463    # param names for compositors464    param_names["Opacity"] = _("Opacity")465    param_names["Shear X"] = _("Shear X")466    param_names["Shear Y"] = _("Shear Y")467    param_names["Distort"] = _("Distort")468    param_names["Opacity"] = _("Opacity")469    param_names["Wipe Type"] = _("Wipe Type")470    param_names["Invert"] = _("Invert")471    param_names["Softness"] = _("Softness")472    param_names["Wipe Amount"] = _("Wipe Amount")473    param_names["Wipe Type"] = _("Wipe Type")474    param_names["Invert"] = _("Invert")475    param_names["Softness"] = _("Softness")476    # Combo options477    global combo_options478    combo_options["Shave"] = _("Shave")479    combo_options["Rectangle"] = _("Rectangle")480    combo_options["Ellipse"] = _("Ellipse")481    combo_options["Triangle"] = _("Triangle")482    combo_options["Diamond"] = _("Diamond")483    combo_options["Shave"] = _("Shave")484    combo_options["Shrink Hard"] = _("Shrink Hard")485    combo_options["Shrink Soft"] = _("Shrink Soft")486    combo_options["Grow Hard"] = _("Grow Hard")487    combo_options["Grow Soft"] = _("Grow Soft")488    combo_options["RGB"] = _("RGB")489    combo_options["ABI"] = _("ABI")490    combo_options["HCI"] = _("HCI")491    combo_options["Hard"] = _("Hard")492    combo_options["Fat"] = _("Fat")493    combo_options["Normal"] = _("Normal")494    combo_options["Skinny"] = _("Skinny")495    combo_options["Ellipsoid"] = _("Ellipsoid")496    combo_options["Diamond"] = _("Diamond")497    combo_options["Overwrite"] = _("Overwrite")498    combo_options["Max"] = _("Max")499    combo_options["Min"] = _("Min")500    combo_options["Add"] = _("Add")501    combo_options["Subtract"] = _("Subtract")502    combo_options["Green"] = _("Green")503    combo_options["Blue"] = _("Blue")504    combo_options["Sharper"] = _("Sharper")505    combo_options["Fuzzier"] = _("Fuzzier")506    combo_options["Luma"] = _("Luma")507    combo_options["Red"] = _("Red")508    combo_options["Green"] = _("Green")509    combo_options["Blue"] = _("Blue")510    combo_options["Add Constant"] = _("Add Constant")511    combo_options["Change Gamma"] = _("Change Gamma")512    combo_options["Multiply"] = _("Multiply")513    combo_options["XPro"] = _("XPro")514    combo_options["OldPhoto"] = _("OldPhoto")515    combo_options["Sepia"] = _("Sepia")516    combo_options["Heat"] = _("Heat")517    combo_options["XRay"] = _("XRay")518    combo_options["RedGreen"] = _("RedGreen")519    combo_options["YellowBlue"] = _("YellowBlue")520    combo_options["Esses"] = _("Esses")521    combo_options["Horizontal"] = _("Horizontal")522    combo_options["Vertical"] = _("Vertical")523    combo_options["Shadows"] = _("Shadows")524    combo_options["Midtones"] = _("Midtones")525    combo_options["Highlights"] = _("Highlights")...

interpolate_core_collapse_timescale.py

Source:interpolate_core_collapse_timescale.py

1import numpy as np2from sidmpy.core_collapse_timescale import fraction_collapsed_halos, fraction_collapsed_halos_pool3from scipy.interpolate import RegularGridInterpolator4from scipy.interpolate import interp1d5import pickle6from multiprocess.pool import Pool7class InterpolatedCollapseTimescale(object):8    def __init__(self, points, values, param_names, param_arrays):9        self.param_names = param_names10        self.param_ranges = []11        self.param_ranges_dict = {}12        for i, param in enumerate(param_arrays):13            ran = [param[0], param[-1]]14            self.param_ranges.append(ran)15            self.param_ranges_dict[param_names[i]] = ran16        self._interp_function = RegularGridInterpolator(points, values,17                                                        bounds_error=False, fill_value=None)18    @classmethod19    def fromParamArray(self, m1, m2, cross_section_model, param_names, param_arrays, params_fixed={},20                 kwargs_fraction={}, nproc=8):21        param_names = param_names22        param_ranges = []23        param_ranges_dict = {}24        for i, param in enumerate(param_arrays):25            ran = [param[0], param[-1]]26            param_ranges.append(ran)27            param_ranges_dict[param_names[i]] = ran28        print('param_names: ', param_names)29        print('n params: ', len(param_names))30        print('n sample arrays: ', len(param_arrays))31        # redshift is always last32        if len(param_arrays) == 2:33            args_list = []34            points = (param_arrays[0], param_arrays[1])35            n_total = len(param_arrays[0]) * len(param_arrays[1])36            print('n total: ', n_total)37            for p1 in param_arrays[0]:38                for redshift in param_arrays[1]:39                    kw = {param_names[0]: p1}40                    kw.update(params_fixed)41                    kwargs_fraction['redshift'] = redshift42                    cross_model = cross_section_model(**kw)43                    new = (m1, m2, cross_model, kwargs_fraction['redshift'], kwargs_fraction['timescale_factor'])44                    args_list.append(new)45            shape = (len(param_arrays[0]), len(param_arrays[1]))46        elif len(param_arrays) == 3:47            args_list = []48            points = (param_arrays[0], param_arrays[1], param_arrays[2])49            n_total = len(param_arrays[0]) * len(param_arrays[1]) * len(param_arrays[2])50            print('n total: ', n_total)51            for p1 in param_arrays[0]:52                for p2 in param_arrays[1]:53                    for redshift in param_arrays[2]:54                        # if counter % step == 0:55                        #     print(str(np.round(100 * counter / n_total, 1)) + '% ')56                        kw = {param_names[0]: p1, param_names[1]: p2}57                        kw.update(params_fixed)58                        kwargs_fraction['redshift'] = redshift59                        cross_model = cross_section_model(**kw)60                        new = (m1, m2, cross_model, kwargs_fraction['redshift'], kwargs_fraction['timescale_factor'])61                        args_list.append(new)62            shape = (len(param_arrays[0]), len(param_arrays[1]), len(param_arrays[2]))63        elif len(param_arrays) == 4:64            points = (param_arrays[0], param_arrays[1], param_arrays[2], param_arrays[3])65            n_total = len(param_arrays[0]) * len(param_arrays[1]) * len(param_arrays[2]) * len(param_arrays[3])66            print('n total: ', n_total)67            args_list = []68            for p1 in param_arrays[0]:69                for p2 in param_arrays[1]:70                    for p3 in param_arrays[2]:71                        for redshift in param_arrays[3]:72                            kw = {param_names[0]: p1, param_names[1]: p2, param_names[2]: p3}73                            kw.update(params_fixed)74                            kwargs_fraction['redshift'] = redshift75                            cross_model = cross_section_model(**kw)76                            new = (m1, m2, cross_model, kwargs_fraction['redshift'], kwargs_fraction['timescale_factor'])77                            args_list.append(new)78            pool = Pool(nproc)79            values = pool.map(fraction_collapsed_halos_pool, args_list)80            pool.close()81            shape = (len(param_arrays[0]), len(param_arrays[1]), len(param_arrays[2]), len(param_arrays[3]))82        elif len(param_arrays) == 5:83            points = (param_arrays[0], param_arrays[1], param_arrays[2], param_arrays[3], param_arrays[4])84            n_total = len(param_arrays[0]) * len(param_arrays[1]) * len(param_arrays[2]) * len(param_arrays[3]) * len(param_arrays[4])85            print('n total: ', n_total)86            args_list = []87            for p1 in param_arrays[0]:88                for p2 in param_arrays[1]:89                    for p3 in param_arrays[2]:90                        for p4 in param_arrays[3]:91                            for redshift in param_arrays[4]:92                                # if counter % step == 0:93                                #     print(str(np.round(100 * counter / n_total, 1)) + '% ')94                                kw = {param_names[0]: p1, param_names[1]: p2, param_names[2]: p3, param_names[3]: p4}95                                kw.update(params_fixed)96                                kwargs_fraction['redshift'] = redshift97                                cross_model = cross_section_model(**kw)98                                new = (99                                m1, m2, cross_model, kwargs_fraction['redshift'], kwargs_fraction['timescale_factor'])100                                args_list.append(new)101            shape = (len(param_arrays[0]), len(param_arrays[1]), len(param_arrays[2]), len(param_arrays[3]),102                     len(param_arrays[4]))103        elif len(param_arrays) == 6:104            points = (param_arrays[0], param_arrays[1], param_arrays[2], param_arrays[3], param_arrays[4], param_arrays[5])105            n_total = len(param_arrays[0]) * len(param_arrays[1]) * len(param_arrays[2]) * len(param_arrays[3]) * len(106                param_arrays[4]) * len(param_arrays[5])107            print('n total: ', n_total)108            args_list = []109            for p1 in param_arrays[0]:110                for p2 in param_arrays[1]:111                    for p3 in param_arrays[2]:112                        for p4 in param_arrays[3]:113                            for p5 in param_arrays[4]:114                                for redshift in param_arrays[5]:115                                    # if counter % step == 0:116                                    #     print(str(np.round(100 * counter / n_total, 1)) + '% ')117                                    kw = {param_names[0]: p1, param_names[1]: p2, param_names[2]: p3, param_names[3]: p4,118                                          param_names[4]: p5}119                                    kw.update(params_fixed)120                                    kwargs_fraction['redshift'] = redshift121                                    cross_model = cross_section_model(**kw)122                                    new = (123                                        m1, m2, cross_model, kwargs_fraction['redshift'],124                                        kwargs_fraction['timescale_factor'])125                                    args_list.append(new)126            pool = Pool(nproc)127            values = pool.map(fraction_collapsed_halos_pool, args_list)128            pool.close()129            shape = (len(param_arrays[0]), len(param_arrays[1]), len(param_arrays[2]), len(param_arrays[3]),130                     len(param_arrays[4]), len(param_arrays[5]))131        elif len(param_arrays) == 7:132            points = (param_arrays[0], param_arrays[1], param_arrays[2], param_arrays[3], param_arrays[4],133                      param_arrays[5], param_arrays[6])134            n_total = len(param_arrays[0]) * len(param_arrays[1]) * len(param_arrays[2]) * len(param_arrays[3]) * len(135                param_arrays[4]) * len(param_arrays[5] * len(param_arrays[6]))136            print('n total: ', n_total)137            args_list = []138            for p1 in param_arrays[0]:139                for p2 in param_arrays[1]:140                    for p3 in param_arrays[2]:141                        for p4 in param_arrays[3]:142                            for p5 in param_arrays[4]:143                                for timescale_factor in param_arrays[5]:144                                    for redshift in param_arrays[6]:145                                        kw = {param_names[0]: p1, param_names[1]: p2, param_names[2]: p3, param_names[3]: p4,146                                              param_names[4]: p5}147                                        kw.update(params_fixed)148                                        kwargs_fraction['redshift'] = redshift149                                        kwargs_fraction['timescale_factor'] = timescale_factor150                                        cross_model = cross_section_model(**kw)151                                        new = (152                                            m1, m2, cross_model, kwargs_fraction['redshift'],153                                            kwargs_fraction['timescale_factor'])154                                        args_list.append(new)155            pool = Pool(nproc)156            values = pool.map(fraction_collapsed_halos_pool, args_list)157            pool.close()158            shape = (len(param_arrays[0]), len(param_arrays[1]), len(param_arrays[2]), len(param_arrays[3]),159                     len(param_arrays[4]), len(param_arrays[5]), len(param_arrays[6]))160        else:161            raise Exception('only 2, 3, 4 and 5D interpolations implemented')162        return InterpolatedCollapseTimescale(points, values, param_names, param_arrays, shape)163    def __call__(self, *args):164        return np.squeeze(self._interp_function(tuple(args)))165def interpolate_collapse_fraction(fname, cross_section_class, param_names, param_arrays, params_fixed, m1,166                                  kwargs_collapse_fraction, nproc):167    interp_timescale = InterpolatedCollapseTimescale(m1, m1 * 1.05, cross_section_class,168                                                     param_names, param_arrays, params_fixed, kwargs_collapse_fraction, nproc=nproc)169    f = open('interpolated_collapse_fraction_'+fname, 'wb')170    pickle.dump(interp_timescale, f)171    f.close()172# from sidmpy.CrossSections.resonant_tchannel import ExpResonantTChannel173# # norm, v_ref, v_res, w_res, res_amplitude174# param_names = ['norm', 'v_ref', 'v_res', 'w_res', 'res_amplitude', 'timescale_factor', 'redshift']175# cross_model = ExpResonantTChannel176#177# output_folder = ''178# nproc = 50179# params_fixed = {}180# kwargs_collapse_fraction = {}181# z_array = [0.2, 0.45, 0.7, 0.95]182# tarray = [10/3, 15/3, 20/3]183# param_arrays = [np.linspace(1, 10.0, 9), np.linspace(1, 50.0, 20), np.linspace(1, 40, 20),184#                 np.linspace(1, 5.0, 5), np.linspace(1.0, 100, 40), tarray, z_array]185# n_total = 1186# for parr in param_arrays:187#     n_total *= len(parr)188# print('n_total: ', n_total); a=input('continue')189# fname = output_folder + 'logM68_expresonanttchannel'190# m1 = 10 ** 7191# interpolate_collapse_fraction(fname, cross_model, param_names, param_arrays, params_fixed, m1, kwargs_collapse_fraction, nproc=nproc)192# fname = output_folder + 'logM89_expresonanttchannel'193# m1 = 10 ** 8.5194# interpolate_collapse_fraction(fname, cross_model, param_names, param_arrays, params_fixed, m1, kwargs_collapse_fraction, nproc=nproc)195#196# fname = output_folder + 'logM910_expresonanttchannel'197# m1 = 10 ** 9.5198# interpolate_collapse_fraction(fname, cross_model, param_names, param_arrays, params_fixed, m1, kwargs_collapse_fraction, nproc=nproc)199# from sidmpy.CrossSections.tchannel import TChannel200# param_names = ['norm', 'v_ref']201# n = 50202# params_fixed = {}203# kwargs_collapse_fraction = {'redshift': 0.5, 'timescale_factor': 20.0}204# param_arrays = [np.linspace(0.5, 60.0, n), np.linspace(1.0, 40, n)]205# fname = 'logM68_tchannel'206# m1 = 10 ** 7207# interpolate_collapse_fraction(fname, TChannel, param_names, param_arrays, params_fixed, m1, kwargs_collapse_fraction)208#209# fname = 'logM89_tchannel'210# m1 = 5 * 10 ** 8211# interpolate_collapse_fraction(fname, TChannel, param_names, param_arrays, params_fixed, m1, kwargs_collapse_fraction)212#213# fname = 'logM910_tchannel'214# m1 = 5 * 10 ** 9215# interpolate_collapse_fraction(fname, TChannel, param_names, param_arrays, params_fixed, m1, kwargs_collapse_fraction)...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.