pyPESTO
latest

User's guide

  • Install and upgrade
    • Requirements
      • I cannot use my system’s Python distribution, what now?
    • Install from PIP
    • Install from GIT
    • Upgrade
    • Install optional packages and external dependencies
    • Python support
  • Examples
    • Getting started
      • pyPESTO: Getting started
        • 1. Objective Definition
          • Custom Objective Definition
          • Problem Definition via PEtab
            • Background on PEtab
            • Basic Model Import and Optimization
        • 2. Optimizer Choice
          • Optimizer Convergence
          • Optimizer run time
        • 3. Fitting of large scale models
          • Efficient gradient computation
          • Parallelization
        • 4. Uncertainty quantification
          • Profile Likelihoods
          • Sampling
          • Sampling Diagnostics
          • Visualization of Sampling Results
            • Sampler Choice:
        • 5. Storage
          • Store result
          • Load result file
        • Software Development Standards:
        • Further topics
      • Custom Objective Function
        • 1. Objective + Problem Definition
          • Illustration
        • 2. Optimization
          • Visualization
        • 3. Profiling
          • Profile approximation
    • PEtab and AMICI
      • AMICI in pyPESTO
        • 1. Create a pyPESTO problem
          • Create a pyPESTO objective from AMICI
            • Constant parameters
            • Observables
            • \(\sigma\) parameters
            • Generating the module
            • Importing the module and loading the model
            • Running simulations and analyzing results
            • Creating pyPESTO objective
          • Create a pyPESTO problem + objective from Petab
            • Background on PEtab
        • 2. Optimization
          • Optimizer
          • Startpoint method
          • History options
          • Optimization options
          • Running the optimization
        • 3. Optimization visualization
          • Model fit
          • Waterfall plot
          • Parameter plots
            • Parameter overview
            • Parameter correlation plot
            • Parameter histogram + scatter
        • 4. Uncertainty quantification
          • Profile likelihood
          • Sampling
        • 5. Saving results
          • Save result object in HDF5 File
          • Reload results
          • Plot (reloaded) results
      • Model import using the PEtab format
        • Import
          • Manage PEtab model
          • Import model to AMICI
          • Create objective function
        • Run optimization
          • Dealing with function evaluations at the initial point
        • Visualize
    • Algorithms and features
      • Fixed parameters
        • Define the two problems
        • Optimize
        • Visualize
      • Prior definition
        • Example: Rosenbrock Banana
          • Define the negative log-likelihood
          • Define the log-prior
          • Define the negative log-posterior and the problem
          • Optimize
          • Some basic visualizations
      • A sampler study
        • The pipeline
        • 1-dim test problem
          • Metropolis sampler
          • Parallel tempering sampler
          • Adaptive Metropolis sampler
          • Adaptive parallel tempering sampler
          • Pymc sampler
          • Emcee sampler
          • dynesty sampler
        • 2-dim test problem: Rosenbrock banana
      • MCMC sampling diagnostics
        • The pipeline
          • Finding parameter point estimates
      • Result Storage
        • Imports
          • 0. Objective function and problem definition
          • 1. Filling in the result file
        • Optimization
        • Profiling
        • Sampling
          • 2. Storing the result file
          • 3. Visualization Comparison
        • Optimization
        • Profiling
        • Sampling
          • 4. Optimization History
        • Memory History
        • CSV History
        • HDF5 History
      • Optimizer Convergence and Comparison
        • Imports and constants
        • Creating optimization results
        • Optimizer convergence
        • Reloading from History
          • Loading Results from History
          • Verifying the Loaded Results
          • Continuing Optimization
          • Notes on Hdf5History with MultiProcessEngine
      • Model Selection
        • Example Model
        • Model Space Specifications File
        • Forward Selection, Multiple Searches
        • Backward Selection, Custom Initial Model
        • Additional Options
          • Select First Improvement
          • Use Previous Maximum Likelihood Estimate as Startpoint
          • Minimize Options
          • Criterion Options
            • Criterion Threshold
        • Multistart
      • Julia objectives
        • Comments
        • Inference problem
        • Optimization
        • Sampling
      • Hierarchical optimization with relative data
        • Note on inclusion of additional data types:
          • Problem specification
          • Hierarchical optimization using analytical or numerical inner solver
          • Comparison of hierarchical and non-hierarchical optimization
          • Comparison of hierarchical and non-hierarchical optimization with adjoint and forward sensitivities
      • Parameter estimation using ordinal data
        • Import model from the petab_problem
          • Note on inclusion of additional data types:
        • Construct the objective and pypesto problem
        • Run optimization using optimal scaling approach
          • Run optimization using the reduced and reparameterized approach
          • Run optimization using the reduced non-reparameterized approach
          • Run optimization using the standard approach
        • Compare results
      • Parameter estimation using censored data
        • Import model from the petab_problem
          • Note on inclusion of additional data types:
        • Construct the objective and pypesto problem
        • Run optimization using optimal scaling approach
        • Visualizing the result
      • Parameter estimation using non-linear semi-quantitative data
        • Problem specification & importing model from the petab_problem
          • Note on inclusion of additional data types:
        • Constructing the objective and pypesto problem
        • Running optimization using spline approximation
        • Caution when using minimal difference
      • RoadRunner in pyPESTO
        • Creating pyPESTO problem from PEtab
        • Optimization
          • Visualization Methods
          • Sensitivities via finite differences
    • Application examples
      • Conversion reaction
        • Compile AMICI model
        • Load AMICI model
        • Optimize
        • Visualize
        • Profiles
        • Sampling
        • Predict
        • Analyze parameter ensembles
      • Optimization with Synthetic Data
        • Requirements
        • Standard Optimization
        • Synthetic Optimization
          • Noise
  • Storage
    • pyPESTO Problem
    • Parameter estimation
      • Parameter estimation settings
      • Parameter estimation results
        • Results per local optimization
        • Trace per local optimization
    • Sampling
      • Sampling results
    • Profiling
      • Profiling results
  • API reference
    • pypesto.engine
      • Engines
      • Engine
        • Engine.__init__()
        • Engine.execute()
      • MultiProcessEngine
        • MultiProcessEngine.__init__()
        • MultiProcessEngine.execute()
      • MultiThreadEngine
        • MultiThreadEngine.__init__()
        • MultiThreadEngine.execute()
      • SingleCoreEngine
        • SingleCoreEngine.__init__()
        • SingleCoreEngine.execute()
      • Task
        • Task.__init__()
        • Task.execute()
    • pypesto.ensemble
      • Ensemble
      • Ensemble
        • Ensemble.__init__()
        • Ensemble.check_identifiability()
        • Ensemble.compute_summary()
        • Ensemble.from_optimization_endpoints()
        • Ensemble.from_optimization_history()
        • Ensemble.from_sample()
        • Ensemble.predict()
      • EnsemblePrediction
        • EnsemblePrediction.__init__()
        • EnsemblePrediction.compute_chi2()
        • EnsemblePrediction.compute_summary()
        • EnsemblePrediction.condense_to_arrays()
      • get_covariance_matrix_parameters()
      • get_covariance_matrix_predictions()
      • get_pca_representation_parameters()
      • get_pca_representation_predictions()
      • get_percentile_label()
      • get_spectral_decomposition_lowlevel()
      • get_spectral_decomposition_parameters()
      • get_spectral_decomposition_predictions()
      • get_umap_representation_parameters()
      • get_umap_representation_predictions()
      • read_ensemble_prediction_from_h5()
      • read_from_csv()
      • read_from_df()
      • write_ensemble_prediction_to_h5()
    • pypesto.hierarchical
      • Hierarchical
      • InnerCalculatorCollector
        • InnerCalculatorCollector.__call__()
        • InnerCalculatorCollector.__init__()
        • InnerCalculatorCollector.construct_inner_calculators()
        • InnerCalculatorCollector.get_inner_par_ids()
        • InnerCalculatorCollector.get_interpretable_inner_par_bounds()
        • InnerCalculatorCollector.get_interpretable_inner_par_ids()
        • InnerCalculatorCollector.initialize()
        • InnerCalculatorCollector.validate_options()
      • InnerParameter
        • InnerParameter.coupled
        • InnerParameter.dummy_value
        • InnerParameter.inner_parameter_id
        • InnerParameter.inner_parameter_type
        • InnerParameter.ixs
        • InnerParameter.lb
        • InnerParameter.scale
        • InnerParameter.ub
        • InnerParameter.__init__()
        • InnerParameter.check_bounds()
        • InnerParameter.get_bounds()
        • InnerParameter.get_unsatisfied_bound()
        • InnerParameter.is_within_bounds()
      • InnerProblem
        • InnerProblem.xs
        • InnerProblem.data
        • InnerProblem.__init__()
        • InnerProblem.from_petab_amici()
        • InnerProblem.get_bounds()
        • InnerProblem.get_dummy_values()
        • InnerProblem.get_for_id()
        • InnerProblem.get_interpretable_x_bounds()
        • InnerProblem.get_interpretable_x_ids()
        • InnerProblem.get_x_ids()
        • InnerProblem.get_xs_for_type()
        • InnerProblem.is_empty()
      • InnerSolver
        • InnerSolver.initialize()
        • InnerSolver.solve()
    • pypesto.hierarchical.ordinal
      • Ordinal and censored data integration
      • OrdinalCalculator
        • OrdinalCalculator.__call__()
        • OrdinalCalculator.__init__()
        • OrdinalCalculator.initialize()
      • OrdinalInnerSolver
        • OrdinalInnerSolver.__init__()
        • OrdinalInnerSolver.calculate_gradients()
        • OrdinalInnerSolver.calculate_obj_function()
        • OrdinalInnerSolver.get_default_options()
        • OrdinalInnerSolver.solve()
        • OrdinalInnerSolver.validate_options()
      • OrdinalParameter
        • OrdinalParameter.dummy_value
        • OrdinalParameter.inner_parameter_id
        • OrdinalParameter.inner_parameter_type
        • OrdinalParameter.ixs
        • OrdinalParameter.lb
        • OrdinalParameter.scale
        • OrdinalParameter.ub
        • OrdinalParameter.observable_id
        • OrdinalParameter.category
        • OrdinalParameter.group
        • OrdinalParameter.value
        • OrdinalParameter.estimate
        • OrdinalParameter.censoring_type
        • OrdinalParameter.__init__()
        • OrdinalParameter.initialize()
      • OrdinalProblem
        • OrdinalProblem.xs
        • OrdinalProblem.data
        • OrdinalProblem.edatas
        • OrdinalProblem.groups
        • OrdinalProblem.method
        • OrdinalProblem.__init__()
        • OrdinalProblem.from_petab_amici()
        • OrdinalProblem.get_cat_lb_parameters_for_group()
        • OrdinalProblem.get_cat_ub_parameters_for_group()
        • OrdinalProblem.get_censored_group_quantitative_ixs()
        • OrdinalProblem.get_d()
        • OrdinalProblem.get_dd_dtheta()
        • OrdinalProblem.get_fixed_xs_for_group()
        • OrdinalProblem.get_free_xs_for_group()
        • OrdinalProblem.get_groups_for_xs()
        • OrdinalProblem.get_inner_parameter_dictionary()
        • OrdinalProblem.get_interpretable_x_ids()
        • OrdinalProblem.get_w()
        • OrdinalProblem.get_wdot()
        • OrdinalProblem.get_xs_for_group()
        • OrdinalProblem.initialize()
        • OrdinalProblem.initialize_c()
        • OrdinalProblem.initialize_w()
    • pypesto.hierarchical.relative
      • Relative data integration
      • AnalyticalInnerSolver
        • AnalyticalInnerSolver.solve()
      • NumericalInnerSolver
        • NumericalInnerSolver.minimize_kwargs
        • NumericalInnerSolver.n_cached
        • NumericalInnerSolver.problem_kwargs
        • NumericalInnerSolver.x_guesses
        • NumericalInnerSolver.__init__()
        • NumericalInnerSolver.initialize()
        • NumericalInnerSolver.sample_startpoints()
        • NumericalInnerSolver.solve()
      • RelativeAmiciCalculator
        • RelativeAmiciCalculator.__call__()
        • RelativeAmiciCalculator.__init__()
        • RelativeAmiciCalculator.calculate_directly()
        • RelativeAmiciCalculator.call_amici_twice()
        • RelativeAmiciCalculator.initialize()
      • RelativeInnerProblem
        • RelativeInnerProblem.xs
        • RelativeInnerProblem.data
        • RelativeInnerProblem.edatas
        • RelativeInnerProblem.__init__()
        • RelativeInnerProblem.from_petab_amici()
        • RelativeInnerProblem.get_observable_indices_for_xs()
        • RelativeInnerProblem.get_relative_observable_ids()
        • RelativeInnerProblem.get_xs_for_obs_idx()
    • pypesto.hierarchical.semiquantitative
      • Semi-quantitative data integration
      • SemiquantCalculator
        • SemiquantCalculator.__call__()
        • SemiquantCalculator.__init__()
        • SemiquantCalculator.initialize()
      • SemiquantInnerSolver
        • SemiquantInnerSolver.__init__()
        • SemiquantInnerSolver.calculate_gradients()
        • SemiquantInnerSolver.calculate_obj_function()
        • SemiquantInnerSolver.get_default_options()
        • SemiquantInnerSolver.solve()
        • SemiquantInnerSolver.validate_options()
      • SemiquantProblem
        • SemiquantProblem.xs
        • SemiquantProblem.data
        • SemiquantProblem.edatas
        • SemiquantProblem.groups
        • SemiquantProblem.spline_ratio
        • SemiquantProblem.__init__()
        • SemiquantProblem.from_petab_amici()
        • SemiquantProblem.get_fixed_xs_for_group()
        • SemiquantProblem.get_free_xs_for_group()
        • SemiquantProblem.get_groups_for_xs()
        • SemiquantProblem.get_inner_noise_parameters()
        • SemiquantProblem.get_inner_parameter_dictionary()
        • SemiquantProblem.get_interpretable_x_ids()
        • SemiquantProblem.get_measurements_for_group()
        • SemiquantProblem.get_noise_dummy_values()
        • SemiquantProblem.get_noise_parameters_for_group()
        • SemiquantProblem.get_semiquant_observable_ids()
        • SemiquantProblem.get_spline_knots()
        • SemiquantProblem.get_xs_for_group()
        • SemiquantProblem.initialize()
      • SplineInnerParameter
        • SplineInnerParameter.observable_id
        • SplineInnerParameter.group
        • SplineInnerParameter.index
        • SplineInnerParameter.value
        • SplineInnerParameter.estimate
        • SplineInnerParameter.__init__()
        • SplineInnerParameter.initialize()
    • pypesto.history
      • History
      • CountHistory
        • CountHistory.get_fval_trace()
        • CountHistory.get_grad_trace()
        • CountHistory.get_hess_trace()
        • CountHistory.get_res_trace()
        • CountHistory.get_sres_trace()
        • CountHistory.get_time_trace()
        • CountHistory.get_x_trace()
      • CountHistoryBase
        • CountHistoryBase.__init__()
        • CountHistoryBase.exitflag
        • CountHistoryBase.finalize()
        • CountHistoryBase.message
        • CountHistoryBase.n_fval
        • CountHistoryBase.n_grad
        • CountHistoryBase.n_hess
        • CountHistoryBase.n_res
        • CountHistoryBase.n_sres
        • CountHistoryBase.start_time
        • CountHistoryBase.update()
      • CsvAmiciHistory
        • CsvAmiciHistory.__init__()
        • CsvAmiciHistory.get_cpu_time_total_trace()
        • CsvAmiciHistory.get_posteq_timeB_trace()
        • CsvAmiciHistory.get_posteq_time_trace()
        • CsvAmiciHistory.get_preeq_timeB_trace()
        • CsvAmiciHistory.get_preeq_time_trace()
      • CsvHistory
        • CsvHistory.__init__()
        • CsvHistory.finalize()
        • CsvHistory.get_fval_trace()
        • CsvHistory.get_grad_trace()
        • CsvHistory.get_hess_trace()
        • CsvHistory.get_res_trace()
        • CsvHistory.get_sres_trace()
        • CsvHistory.get_time_trace()
        • CsvHistory.get_x_trace()
        • CsvHistory.update()
      • CsvHistoryTemplateError
        • CsvHistoryTemplateError.__init__()
      • Hdf5AmiciHistory
        • Hdf5AmiciHistory.__init__()
        • Hdf5AmiciHistory.get_cpu_time_total_trace()
        • Hdf5AmiciHistory.get_posteq_timeB_trace()
        • Hdf5AmiciHistory.get_posteq_time_trace()
        • Hdf5AmiciHistory.get_preeq_timeB_trace()
        • Hdf5AmiciHistory.get_preeq_time_trace()
        • Hdf5AmiciHistory.load()
      • Hdf5History
        • Hdf5History.__init__()
        • Hdf5History.exitflag
        • Hdf5History.finalize()
        • Hdf5History.from_history()
        • Hdf5History.get_fval_trace()
        • Hdf5History.get_grad_trace()
        • Hdf5History.get_hess_trace()
        • Hdf5History.get_res_trace()
        • Hdf5History.get_sres_trace()
        • Hdf5History.get_time_trace()
        • Hdf5History.get_x_trace()
        • Hdf5History.load()
        • Hdf5History.message
        • Hdf5History.n_fval
        • Hdf5History.n_grad
        • Hdf5History.n_hess
        • Hdf5History.n_res
        • Hdf5History.n_sres
        • Hdf5History.recover_options()
        • Hdf5History.start_time
        • Hdf5History.trace_save_iter
        • Hdf5History.update()
      • HistoryBase
        • HistoryBase.ALL_KEYS
        • HistoryBase.RESULT_KEYS
        • HistoryBase.__init__()
        • HistoryBase.exitflag
        • HistoryBase.finalize()
        • HistoryBase.get_chi2_trace()
        • HistoryBase.get_fval_trace()
        • HistoryBase.get_grad_trace()
        • HistoryBase.get_hess_trace()
        • HistoryBase.get_res_trace()
        • HistoryBase.get_schi2_trace()
        • HistoryBase.get_sres_trace()
        • HistoryBase.get_time_trace()
        • HistoryBase.get_trimmed_indices()
        • HistoryBase.get_x_trace()
        • HistoryBase.implements_trace()
        • HistoryBase.message
        • HistoryBase.n_fval
        • HistoryBase.n_grad
        • HistoryBase.n_hess
        • HistoryBase.n_res
        • HistoryBase.n_sres
        • HistoryBase.start_time
        • HistoryBase.update()
      • HistoryOptions
        • HistoryOptions.__init__()
        • HistoryOptions.assert_instance()
      • HistoryTypeError
        • HistoryTypeError.__init__()
      • MemoryHistory
        • MemoryHistory.__init__()
        • MemoryHistory.get_fval_trace()
        • MemoryHistory.get_grad_trace()
        • MemoryHistory.get_hess_trace()
        • MemoryHistory.get_res_trace()
        • MemoryHistory.get_sres_trace()
        • MemoryHistory.get_time_trace()
        • MemoryHistory.get_x_trace()
        • MemoryHistory.update()
      • NoHistory
        • NoHistory.exitflag
        • NoHistory.get_fval_trace()
        • NoHistory.get_grad_trace()
        • NoHistory.get_hess_trace()
        • NoHistory.get_res_trace()
        • NoHistory.get_sres_trace()
        • NoHistory.get_time_trace()
        • NoHistory.get_x_trace()
        • NoHistory.message
        • NoHistory.n_fval
        • NoHistory.n_grad
        • NoHistory.n_hess
        • NoHistory.n_res
        • NoHistory.n_sres
        • NoHistory.start_time
        • NoHistory.update()
      • OptimizerHistory
        • OptimizerHistory.grad_min
        • OptimizerHistory.hess_min
        • OptimizerHistory.res_min
        • OptimizerHistory.sres_min
        • OptimizerHistory.MIN_KEYS
        • OptimizerHistory.__init__()
        • OptimizerHistory.finalize()
        • OptimizerHistory.update()
      • create_history()
    • pypesto.logging
      • Logging
      • log()
      • log_level_active()
      • log_to_console()
      • log_to_file()
    • pypesto.objective
      • Objective
      • AggregatedObjective
        • AggregatedObjective.__init__()
        • AggregatedObjective.call_unprocessed()
        • AggregatedObjective.check_mode()
        • AggregatedObjective.check_sensi_orders()
        • AggregatedObjective.get_config()
        • AggregatedObjective.initialize()
      • AmiciObjective
        • AmiciObjective.__init__()
        • AmiciObjective.apply_custom_timepoints()
        • AmiciObjective.apply_steadystate_guess()
        • AmiciObjective.call_unprocessed()
        • AmiciObjective.check_gradients_match_finite_differences()
        • AmiciObjective.check_mode()
        • AmiciObjective.check_sensi_orders()
        • AmiciObjective.create_history()
        • AmiciObjective.get_config()
        • AmiciObjective.initialize()
        • AmiciObjective.par_arr_to_dct()
        • AmiciObjective.reset_steadystate_guesses()
        • AmiciObjective.set_custom_timepoints()
        • AmiciObjective.share_return_dict
        • AmiciObjective.store_steadystate_guess()
      • FD
        • FD.BACKWARD
        • FD.CENTRAL
        • FD.FORWARD
        • FD.METHODS
        • FD.__init__()
        • FD.call_unprocessed()
        • FD.has_fun
        • FD.has_grad
        • FD.has_hess
        • FD.has_res
        • FD.has_sres
      • FDDelta
        • FDDelta.ALWAYS
        • FDDelta.CONSTANT
        • FDDelta.DISTANCE
        • FDDelta.STEPS
        • FDDelta.UPDATE_CONDITIONS
        • FDDelta.__init__()
        • FDDelta.get()
        • FDDelta.update()
      • NegLogParameterPriors
        • NegLogParameterPriors.__init__()
        • NegLogParameterPriors.call_unprocessed()
        • NegLogParameterPriors.check_mode()
        • NegLogParameterPriors.check_sensi_orders()
        • NegLogParameterPriors.gradient_neg_log_density()
        • NegLogParameterPriors.hessian_neg_log_density()
        • NegLogParameterPriors.hessian_vp_neg_log_density()
        • NegLogParameterPriors.neg_log_density()
        • NegLogParameterPriors.residual()
        • NegLogParameterPriors.residual_jacobian()
      • NegLogPriors
      • Objective
        • Objective.__init__()
        • Objective.call_unprocessed()
        • Objective.get_config()
        • Objective.has_fun
        • Objective.has_grad
        • Objective.has_hess
        • Objective.has_hessp
        • Objective.has_res
        • Objective.has_sres
      • ObjectiveBase
        • ObjectiveBase.history
        • ObjectiveBase.pre_post_processor
        • ObjectiveBase.__call__()
        • ObjectiveBase.__init__()
        • ObjectiveBase.call_unprocessed()
        • ObjectiveBase.check_grad()
        • ObjectiveBase.check_grad_multi_eps()
        • ObjectiveBase.check_gradients_match_finite_differences()
        • ObjectiveBase.check_mode()
        • ObjectiveBase.check_sensi_orders()
        • ObjectiveBase.create_history()
        • ObjectiveBase.get_config()
        • ObjectiveBase.get_fval()
        • ObjectiveBase.get_grad()
        • ObjectiveBase.get_hess()
        • ObjectiveBase.get_res()
        • ObjectiveBase.get_sres()
        • ObjectiveBase.has_fun
        • ObjectiveBase.has_grad
        • ObjectiveBase.has_hess
        • ObjectiveBase.has_hessp
        • ObjectiveBase.has_res
        • ObjectiveBase.has_sres
        • ObjectiveBase.initialize()
        • ObjectiveBase.output_to_tuple()
        • ObjectiveBase.update_from_problem()
        • ObjectiveBase.x_names
      • get_parameter_prior_dict()
    • pypesto.objective.aesara
      • Aesara objective
      • AesaraObjective
        • AesaraObjective.__init__()
        • AesaraObjective.call_unprocessed()
        • AesaraObjective.check_mode()
        • AesaraObjective.check_sensi_orders()
    • pypesto.objective.jax
      • Jax objective
      • JaxObjective
        • JaxObjective.__call__()
        • JaxObjective.__init__()
        • JaxObjective.call_unprocessed()
        • JaxObjective.check_mode()
        • JaxObjective.check_sensi_orders()
        • JaxObjective.history
        • JaxObjective.pre_post_processor
        • JaxObjective.x_names
    • pypesto.objective.julia
      • Julia objective
      • JuliaObjective
        • JuliaObjective.__init__()
        • JuliaObjective.get()
      • PEtabJlObjective
        • PEtabJlObjective.__init__()
        • PEtabJlObjective.precompile_model()
      • display_source_ipython()
    • pypesto.objective.roadrunner
      • RoadRunner objective
      • ExpData
        • ExpData.__init__()
        • ExpData.from_petab_problem()
        • ExpData.from_petab_single_condition()
        • ExpData.get_observable_ids()
        • ExpData.sanity_check()
        • ExpData.timepoints
      • PetabImporterRR
        • PetabImporterRR.__init__()
        • PetabImporterRR.create_edatas()
        • PetabImporterRR.create_objective()
        • PetabImporterRR.create_parameter_mapping()
        • PetabImporterRR.create_prior()
        • PetabImporterRR.create_problem()
        • PetabImporterRR.create_startpoint_method()
        • PetabImporterRR.fill_model()
        • PetabImporterRR.from_yaml()
      • RoadRunnerCalculator
        • RoadRunnerCalculator.__call__()
        • RoadRunnerCalculator.fill_in_parameters()
        • RoadRunnerCalculator.simulate_per_condition()
      • RoadRunnerObjective
        • RoadRunnerObjective.__call__()
        • RoadRunnerObjective.__init__()
        • RoadRunnerObjective.call_unprocessed()
        • RoadRunnerObjective.check_mode()
        • RoadRunnerObjective.check_sensi_orders()
        • RoadRunnerObjective.get_config()
      • SolverOptions
        • SolverOptions.__init__()
        • SolverOptions.apply_to_roadrunner()
      • simulation_to_measurement_df()
    • pypesto.optimize
      • Optimize
      • CmaOptimizer
        • CmaOptimizer.__init__()
        • CmaOptimizer.is_least_squares()
        • CmaOptimizer.minimize()
      • DlibOptimizer
        • DlibOptimizer.__init__()
        • DlibOptimizer.check_x0_support()
        • DlibOptimizer.get_default_options()
        • DlibOptimizer.is_least_squares()
        • DlibOptimizer.minimize()
      • ESSOptimizer
        • ESSOptimizer.__init__()
        • ESSOptimizer.minimize()
      • FidesOptimizer
        • FidesOptimizer.__init__()
        • FidesOptimizer.is_least_squares()
        • FidesOptimizer.minimize()
      • IpoptOptimizer
        • IpoptOptimizer.__init__()
        • IpoptOptimizer.is_least_squares()
        • IpoptOptimizer.minimize()
      • NLoptOptimizer
        • NLoptOptimizer.__init__()
        • NLoptOptimizer.check_x0_support()
        • NLoptOptimizer.is_least_squares()
        • NLoptOptimizer.minimize()
      • OptimizeOptions
        • OptimizeOptions.__init__()
        • OptimizeOptions.assert_instance()
      • Optimizer
        • Optimizer.__init__()
        • Optimizer.check_x0_support()
        • Optimizer.get_default_options()
        • Optimizer.is_least_squares()
        • Optimizer.minimize()
      • PyswarmOptimizer
        • PyswarmOptimizer.__init__()
        • PyswarmOptimizer.check_x0_support()
        • PyswarmOptimizer.is_least_squares()
        • PyswarmOptimizer.minimize()
      • PyswarmsOptimizer
        • PyswarmsOptimizer.__init__()
        • PyswarmsOptimizer.check_x0_support()
        • PyswarmsOptimizer.is_least_squares()
        • PyswarmsOptimizer.minimize()
      • SacessFidesFactory
        • SacessFidesFactory.__call__()
        • SacessFidesFactory.__init__()
      • SacessOptimizer
        • SacessOptimizer.histories
        • SacessOptimizer.__init__()
        • SacessOptimizer.minimize()
      • ScipyDifferentialEvolutionOptimizer
        • ScipyDifferentialEvolutionOptimizer.__init__()
        • ScipyDifferentialEvolutionOptimizer.is_least_squares()
        • ScipyDifferentialEvolutionOptimizer.minimize()
      • ScipyOptimizer
        • ScipyOptimizer.__init__()
        • ScipyOptimizer.get_default_options()
        • ScipyOptimizer.is_least_squares()
        • ScipyOptimizer.minimize()
      • fill_result_from_history()
      • get_default_ess_options()
      • minimize()
      • optimization_result_from_history()
      • read_result_from_file()
      • read_results_from_file()
    • pypesto.petab
      • PEtab
      • PetabImporter
        • PetabImporter.MODEL_BASE_DIR
        • PetabImporter.__init__()
        • PetabImporter.check_gradients()
        • PetabImporter.compile_model()
        • PetabImporter.create_edatas()
        • PetabImporter.create_model()
        • PetabImporter.create_objective()
        • PetabImporter.create_predictor()
        • PetabImporter.create_prior()
        • PetabImporter.create_problem()
        • PetabImporter.create_solver()
        • PetabImporter.create_startpoint_method()
        • PetabImporter.from_yaml()
        • PetabImporter.prediction_to_petab_measurement_df()
        • PetabImporter.prediction_to_petab_simulation_df()
        • PetabImporter.rdatas_to_measurement_df()
        • PetabImporter.rdatas_to_simulation_df()
        • PetabImporter.validate_inner_options()
    • pypesto.predict
      • Prediction
      • AmiciPredictor
        • AmiciPredictor.__call__()
        • AmiciPredictor.__init__()
      • PredictorTask
        • PredictorTask.predictor
        • PredictorTask.x
        • PredictorTask.sensi_orders
        • PredictorTask.mode
        • PredictorTask.id
        • PredictorTask.__init__()
        • PredictorTask.execute()
    • pypesto.problem
      • Problem
      • HierarchicalProblem
        • HierarchicalProblem.__init__()
      • Problem
        • Problem.__init__()
        • Problem.dim
        • Problem.fix_parameters()
        • Problem.full_index_to_free_index()
        • Problem.get_full_matrix()
        • Problem.get_full_vector()
        • Problem.get_reduced_matrix()
        • Problem.get_reduced_vector()
        • Problem.get_startpoints()
        • Problem.lb
        • Problem.lb_init
        • Problem.normalize()
        • Problem.print_parameter_summary()
        • Problem.set_x_guesses()
        • Problem.ub
        • Problem.ub_init
        • Problem.unfix_parameters()
        • Problem.x_free_indices
        • Problem.x_guesses
    • pypesto.profile
      • Profile
      • ProfileOptions
        • ProfileOptions.default_step_size
        • ProfileOptions.min_step_size
        • ProfileOptions.max_step_size
        • ProfileOptions.step_size_factor
        • ProfileOptions.delta_ratio_max
        • ProfileOptions.ratio_min
        • ProfileOptions.reg_points
        • ProfileOptions.reg_order
        • ProfileOptions.magic_factor_obj_value
        • ProfileOptions.whole_path
        • ProfileOptions.__init__()
        • ProfileOptions.create_instance()
        • ProfileOptions.validate()
      • approximate_parameter_profile()
      • calculate_approximate_ci()
      • chi2_quantile_to_ratio()
      • parameter_profile()
      • validation_profile_significance()
    • pypesto.profile.profile_next_guess
      • adaptive_step()
      • fixed_step()
      • next_guess()
    • pypesto.result
      • Result
      • LazyOptimizerResult
        • LazyOptimizerResult.filename
        • LazyOptimizerResult.group_name
        • LazyOptimizerResult._data
        • LazyOptimizerResult._metadata_loaded
        • LazyOptimizerResult.__init__()
        • LazyOptimizerResult.exitflag
        • LazyOptimizerResult.free_indices
        • LazyOptimizerResult.fval
        • LazyOptimizerResult.fval0
        • LazyOptimizerResult.grad
        • LazyOptimizerResult.hess
        • LazyOptimizerResult.history
        • LazyOptimizerResult.id
        • LazyOptimizerResult.inner_parameters
        • LazyOptimizerResult.message
        • LazyOptimizerResult.n_fval
        • LazyOptimizerResult.n_grad
        • LazyOptimizerResult.n_hess
        • LazyOptimizerResult.n_res
        • LazyOptimizerResult.n_sres
        • LazyOptimizerResult.optimizer
        • LazyOptimizerResult.res
        • LazyOptimizerResult.spline_knots
        • LazyOptimizerResult.sres
        • LazyOptimizerResult.time
        • LazyOptimizerResult.x
        • LazyOptimizerResult.x0
      • McmcPtResult
        • McmcPtResult.__init__()
      • OptimizeResult
        • OptimizeResult.__init__()
        • OptimizeResult.append()
        • OptimizeResult.as_dataframe()
        • OptimizeResult.as_list()
        • OptimizeResult.get_by_id()
        • OptimizeResult.get_for_key()
        • OptimizeResult.sort()
        • OptimizeResult.summary()
      • OptimizerResult
        • OptimizerResult.id
        • OptimizerResult.x
        • OptimizerResult.fval
        • OptimizerResult.grad
        • OptimizerResult.hess
        • OptimizerResult.res
        • OptimizerResult.sres
        • OptimizerResult.n_fval
        • OptimizerResult.n_grad
        • OptimizerResult.n_hess
        • OptimizerResult.n_res
        • OptimizerResult.n_sres
        • OptimizerResult.x0
        • OptimizerResult.fval0
        • OptimizerResult.history
        • OptimizerResult.exitflag
        • OptimizerResult.time
        • OptimizerResult.message
        • OptimizerResult.optimizer
        • OptimizerResult.__init__()
        • OptimizerResult.summary()
        • OptimizerResult.update_to_full()
      • PredictionConditionResult
        • PredictionConditionResult.__init__()
      • PredictionResult
        • PredictionResult.__init__()
        • PredictionResult.write_to_csv()
        • PredictionResult.write_to_h5()
      • ProfileResult
        • ProfileResult.__init__()
        • ProfileResult.append_empty_profile_list()
        • ProfileResult.append_profiler_result()
        • ProfileResult.get_profiler_result()
        • ProfileResult.set_profiler_result()
      • ProfilerResult
        • ProfilerResult.x_path
        • ProfilerResult.fval_path
        • ProfilerResult.ratio_path
        • ProfilerResult.gradnorm_path
        • ProfilerResult.exitflag_path
        • ProfilerResult.time_path
        • ProfilerResult.time_total
        • ProfilerResult.n_fval
        • ProfilerResult.n_grad
        • ProfilerResult.n_hess
        • ProfilerResult.message
        • ProfilerResult.__init__()
        • ProfilerResult.append_profile_point()
        • ProfilerResult.flip_profile()
      • Result
        • Result.problem
        • Result.optimize_result
        • Result.profile_result
        • Result.sample_result
        • Result.__init__()
        • Result.summary()
      • SampleResult
        • SampleResult.__init__()
    • pypesto.sample
      • Sample
      • AdaptiveMetropolisSampler
        • AdaptiveMetropolisSampler.__init__()
        • AdaptiveMetropolisSampler.default_options()
        • AdaptiveMetropolisSampler.initialize()
      • AdaptiveParallelTemperingSampler
        • AdaptiveParallelTemperingSampler.adjust_betas()
        • AdaptiveParallelTemperingSampler.compute_log_evidence()
        • AdaptiveParallelTemperingSampler.default_options()
      • DynestySampler
        • DynestySampler.__init__()
        • DynestySampler.get_original_samples()
        • DynestySampler.get_samples()
        • DynestySampler.initialize()
        • DynestySampler.loglikelihood()
        • DynestySampler.prior_transform()
        • DynestySampler.raw_results
        • DynestySampler.restore_internal_sampler()
        • DynestySampler.results
        • DynestySampler.sample()
        • DynestySampler.save_internal_sampler()
      • EmceeSampler
        • EmceeSampler.__init__()
        • EmceeSampler.get_epsilon_ball_initial_state()
        • EmceeSampler.get_samples()
        • EmceeSampler.initialize()
        • EmceeSampler.sample()
      • InternalSampler
        • InternalSampler.get_last_sample()
        • InternalSampler.make_internal()
        • InternalSampler.set_last_sample()
      • MetropolisSampler
        • MetropolisSampler.__init__()
        • MetropolisSampler.default_options()
        • MetropolisSampler.get_last_sample()
        • MetropolisSampler.get_samples()
        • MetropolisSampler.initialize()
        • MetropolisSampler.make_internal()
        • MetropolisSampler.sample()
        • MetropolisSampler.set_last_sample()
      • ParallelTemperingSampler
        • ParallelTemperingSampler.__init__()
        • ParallelTemperingSampler.adjust_betas()
        • ParallelTemperingSampler.compute_log_evidence()
        • ParallelTemperingSampler.default_options()
        • ParallelTemperingSampler.get_samples()
        • ParallelTemperingSampler.initialize()
        • ParallelTemperingSampler.sample()
        • ParallelTemperingSampler.swap_samples()
      • Sampler
        • Sampler.__init__()
        • Sampler.default_options()
        • Sampler.get_samples()
        • Sampler.initialize()
        • Sampler.sample()
        • Sampler.translate_options()
      • auto_correlation()
      • calculate_ci_mcmc_sample()
      • calculate_ci_mcmc_sample_prediction()
      • effective_sample_size()
      • geweke_test()
      • sample()
    • pypesto.select
      • Model Selection
      • Problem
        • Problem.calibrated_models
        • Problem.newly_calibrated_models
        • Problem.method_caller
        • Problem.model_problem_options
        • Problem.petab_select_problem
        • Problem.__init__()
        • Problem.create_method_caller()
        • Problem.handle_select_kwargs()
        • Problem.multistart_select()
        • Problem.select()
        • Problem.select_to_completion()
        • Problem.set_state()
        • Problem.update_with_newly_calibrated_models()
      • model_to_pypesto_problem()
    • pypesto.select.postprocessors
      • model_id_binary_postprocessor()
      • multi_postprocessor()
      • report_postprocessor()
      • save_postprocessor()
      • waterfall_plot_postprocessor()
    • pypesto.startpoint
      • Startpoint
      • CheckedStartpoints
        • CheckedStartpoints.__call__()
        • CheckedStartpoints.__init__()
        • CheckedStartpoints.check_and_resample()
        • CheckedStartpoints.sample()
      • FunctionStartpoints
        • FunctionStartpoints.__init__()
        • FunctionStartpoints.sample()
      • LatinHypercubeStartpoints
        • LatinHypercubeStartpoints.__init__()
        • LatinHypercubeStartpoints.sample()
      • NoStartpoints
        • NoStartpoints.__call__()
      • StartpointMethod
        • StartpointMethod.__call__()
      • UniformStartpoints
        • UniformStartpoints.__init__()
      • latin_hypercube()
      • to_startpoint_method()
      • uniform()
    • pypesto.store
      • Storage
      • OptimizationResultHDF5Reader
        • OptimizationResultHDF5Reader.storage_filename
        • OptimizationResultHDF5Reader.lazy
        • OptimizationResultHDF5Reader.__init__()
        • OptimizationResultHDF5Reader.read()
      • OptimizationResultHDF5Writer
        • OptimizationResultHDF5Writer.storage_filename
        • OptimizationResultHDF5Writer.__init__()
        • OptimizationResultHDF5Writer.write()
      • ProblemHDF5Reader
        • ProblemHDF5Reader.storage_filename
        • ProblemHDF5Reader.__init__()
        • ProblemHDF5Reader.read()
      • ProblemHDF5Writer
        • ProblemHDF5Writer.storage_filename
        • ProblemHDF5Writer.__init__()
        • ProblemHDF5Writer.write()
      • ProfileResultHDF5Reader
        • ProfileResultHDF5Reader.storage_filename
        • ProfileResultHDF5Reader.__init__()
        • ProfileResultHDF5Reader.read()
      • ProfileResultHDF5Writer
        • ProfileResultHDF5Writer.storage_filename
        • ProfileResultHDF5Writer.__init__()
        • ProfileResultHDF5Writer.write()
      • SamplingResultHDF5Reader
        • SamplingResultHDF5Reader.storage_filename
        • SamplingResultHDF5Reader.__init__()
        • SamplingResultHDF5Reader.read()
      • SamplingResultHDF5Writer
        • SamplingResultHDF5Writer.storage_filename
        • SamplingResultHDF5Writer.__init__()
        • SamplingResultHDF5Writer.write()
      • autosave()
      • load_objective_config()
      • read_result()
      • write_array()
      • write_result()
    • pypesto.visualize
      • Visualize
      • ReferencePoint
        • ReferencePoint.x
        • ReferencePoint.fval
        • ReferencePoint.color
        • ReferencePoint.auto_color
        • ReferencePoint.legend
        • ReferencePoint.__init__()
      • assign_clustered_colors()
      • assign_clusters()
      • assign_colors()
      • create_references()
      • delete_nan_inf()
      • ensemble_crosstab_scatter_lowlevel()
      • ensemble_identifiability()
      • ensemble_scatter_lowlevel()
      • optimization_run_properties_one_plot()
      • optimization_run_properties_per_multistart()
      • optimization_run_property_per_multistart()
      • optimization_scatter()
      • optimizer_convergence()
      • optimizer_history()
      • optimizer_history_lowlevel()
      • parameter_hist()
      • parameters()
      • parameters_correlation_matrix()
      • parameters_lowlevel()
      • plot_categories_from_inner_result()
      • plot_categories_from_pypesto_result()
      • plot_linear_observable_mappings_from_pypesto_result()
      • plot_splines_from_inner_result()
      • plot_splines_from_pypesto_result()
      • process_offset_y()
      • process_result_list()
      • process_y_limits()
      • profile_cis()
      • profile_lowlevel()
      • profiles()
      • profiles_lowlevel()
      • projection_scatter_pca()
      • projection_scatter_umap()
      • projection_scatter_umap_original()
      • sampling_1d_marginals()
      • sampling_fval_traces()
      • sampling_parameter_cis()
      • sampling_parameter_traces()
      • sampling_prediction_trajectories()
      • sampling_scatter()
      • visualize_estimated_observable_mapping()
      • waterfall()
      • waterfall_lowlevel()
    • pypesto.visualize.model_fit
      • time_trajectory_model()
      • visualize_optimized_model_fit()

Developer's guide

  • Contribute
    • Workflow
    • Environment
      • Pre-commit hooks
      • Tox
    • GitHub Actions
    • Documentation
    • Unit tests
    • PEP8
  • Deploy
    • Versions
    • Create a new release
      • Merge into main
      • Create a release on GitHub
    • Upload to PyPI

About

  • Release notes
    • 0.5 series
      • 0.5.3 (2024-08-01)
      • 0.5.2 (2024-05-27)
      • 0.5.0 (2024-04-10)
    • 0.4 series
      • 0.4.2 (2024-01-30)
      • 0.4.1 (2023-12-05)
      • 0.4.0 (2023-11-22)
    • 0.3 series
      • 0.3.3 (2023-10-19)
      • 0.3.2 (2023-10-02)
      • 0.3.1 (2023-06-22)
      • 0.3.0 (2023-05-02)
    • 0.2 series
      • 0.2.17 (2023-05-02)
      • 0.2.16 (2023-02-23)
      • 0.2.15 (2022-12-21)
      • 0.2.14 (2022-10-25)
      • 0.2.13 (2022-05-24)
      • 0.2.12 (2022-04-11)
      • 0.2.11 (2022-01-11)
      • 0.2.10 (2022-01-06)
      • 0.2.9 (2021-11-03)
      • 0.2.8 (2021-10-28)
      • 0.2.7 (2021-07-30)
      • 0.2.6 (2021-05-17)
      • 0.2.5 (2021-05-04)
      • 0.2.4 (2021-03-12)
      • 0.2.3 (2021-01-18)
      • 0.2.2 (2020-10-05)
      • 0.2.1 (2020-09-07)
      • 0.2.0 (2020-06-17)
    • 0.1 series
      • 0.1.0 (2020-06-17)
    • 0.0 series
      • 0.0.13 (2020-05-03)
      • 0.0.12 (2020-04-06)
      • 0.0.11 (2020-03-17)
      • 0.0.10 (2019-12-04)
      • 0.0.9 (2019-10-11)
      • 0.0.8 (2019-09-01)
      • 0.0.7 (2019-03-21)
      • 0.0.6 (2019-03-13)
      • 0.0.5 (2019-03-11)
      • 0.0.4 (2019-02-25)
      • 0.0.3 (2019-01-30)
      • 0.0.2 (2018-10-18)
      • 0.0.1 (2018-07-25)
  • Authors
  • Publications using pyPESTO
  • Contact
  • License
  • How to cite pyPESTO
  • Logo
pyPESTO
  • Search

© Copyright 2018, The pyPESTO developers. Revision ead29b36.

Built with Sphinx using a theme provided by Read the Docs.