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
          • Samlping 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
          • In short
        • Run optimization
        • 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
      • 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
        • 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 nonlinear-monotone 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
    • 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
      • AnalyticalInnerSolver
        • AnalyticalInnerSolver.solve()
      • HierarchicalAmiciCalculator
        • HierarchicalAmiciCalculator.__call__()
        • HierarchicalAmiciCalculator.__init__()
        • HierarchicalAmiciCalculator.get_inner_parameter_ids()
        • HierarchicalAmiciCalculator.initialize()
      • 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()
      • InnerProblem
        • InnerProblem.xs
        • InnerProblem.data
        • InnerProblem.__init__()
        • InnerProblem.from_petab_amici()
        • InnerProblem.get_dummy_values()
        • InnerProblem.get_for_id()
        • InnerProblem.get_x_ids()
        • InnerProblem.get_xs_for_type()
        • InnerProblem.is_empty()
      • InnerSolver
        • InnerSolver.initialize()
        • InnerSolver.solve()
      • NumericalInnerSolver
        • NumericalInnerSolver.minimize_kwargs
        • NumericalInnerSolver.n_cached
        • NumericalInnerSolver.problem_kwargs
        • NumericalInnerSolver.x_guesses
        • NumericalInnerSolver.__init__()
        • NumericalInnerSolver.initialize()
        • NumericalInnerSolver.solve()
    • pypesto.hierarchical.optimal_scaling
      • Optimal scaling
      • OptimalScalingAmiciCalculator
        • OptimalScalingAmiciCalculator.__call__()
        • OptimalScalingAmiciCalculator.__init__()
        • OptimalScalingAmiciCalculator.get_inner_parameter_ids()
        • OptimalScalingAmiciCalculator.initialize()
      • OptimalScalingInnerSolver
        • OptimalScalingInnerSolver.__init__()
        • OptimalScalingInnerSolver.calculate_gradients()
        • OptimalScalingInnerSolver.calculate_obj_function()
        • OptimalScalingInnerSolver.get_default_options()
        • OptimalScalingInnerSolver.solve()
        • OptimalScalingInnerSolver.validate_options()
      • OptimalScalingParameter
        • OptimalScalingParameter.dummy_value
        • OptimalScalingParameter.inner_parameter_id
        • OptimalScalingParameter.inner_parameter_type
        • OptimalScalingParameter.ixs
        • OptimalScalingParameter.lb
        • OptimalScalingParameter.scale
        • OptimalScalingParameter.ub
        • OptimalScalingParameter.observable_id
        • OptimalScalingParameter.category
        • OptimalScalingParameter.group
        • OptimalScalingParameter.value
        • OptimalScalingParameter.estimate
        • OptimalScalingParameter.censoring_type
        • OptimalScalingParameter.__init__()
        • OptimalScalingParameter.initialize()
      • OptimalScalingProblem
        • OptimalScalingProblem.xs
        • OptimalScalingProblem.data
        • OptimalScalingProblem.groups
        • OptimalScalingProblem.method
        • OptimalScalingProblem.__init__()
        • OptimalScalingProblem.from_petab_amici()
        • OptimalScalingProblem.get_cat_lb_parameters_for_group()
        • OptimalScalingProblem.get_cat_ub_parameters_for_group()
        • OptimalScalingProblem.get_censored_group_quantitative_ixs()
        • OptimalScalingProblem.get_d()
        • OptimalScalingProblem.get_dd_dtheta()
        • OptimalScalingProblem.get_fixed_xs_for_group()
        • OptimalScalingProblem.get_free_xs_for_group()
        • OptimalScalingProblem.get_groups_for_xs()
        • OptimalScalingProblem.get_inner_parameter_dictionary()
        • OptimalScalingProblem.get_w()
        • OptimalScalingProblem.get_wdot()
        • OptimalScalingProblem.get_xs_for_group()
        • OptimalScalingProblem.initialize()
        • OptimalScalingProblem.initialize_c()
        • OptimalScalingProblem.initialize_w()
    • pypesto.hierarchical.spline_approximation
      • Spline approximation
      • SplineAmiciCalculator
        • SplineAmiciCalculator.__call__()
        • SplineAmiciCalculator.__init__()
        • SplineAmiciCalculator.get_inner_parameter_ids()
        • SplineAmiciCalculator.initialize()
      • SplineInnerParameter
        • SplineInnerParameter.observable_id
        • SplineInnerParameter.group
        • SplineInnerParameter.index
        • SplineInnerParameter.value
        • SplineInnerParameter.estimate
        • SplineInnerParameter.__init__()
        • SplineInnerParameter.initialize()
      • SplineInnerProblem
        • SplineInnerProblem.xs
        • SplineInnerProblem.data
        • SplineInnerProblem.groups
        • SplineInnerProblem.spline_ratio
        • SplineInnerProblem.__init__()
        • SplineInnerProblem.from_petab_amici()
        • SplineInnerProblem.get_fixed_xs_for_group()
        • SplineInnerProblem.get_free_xs_for_group()
        • SplineInnerProblem.get_groups_for_xs()
        • SplineInnerProblem.get_inner_noise_parameter_dictionary()
        • SplineInnerProblem.get_inner_parameter_dictionary()
        • SplineInnerProblem.get_measurements_for_group()
        • SplineInnerProblem.get_noise_dummy_values()
        • SplineInnerProblem.get_noise_parameters_for_group()
        • SplineInnerProblem.get_xs_for_group()
        • SplineInnerProblem.initialize()
      • SplineInnerSolver
        • SplineInnerSolver.__init__()
        • SplineInnerSolver.calculate_gradients()
        • SplineInnerSolver.calculate_obj_function()
        • SplineInnerSolver.get_default_options()
        • SplineInnerSolver.solve()
        • SplineInnerSolver.validate_options()
    • 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.n_fval
        • CountHistoryBase.n_grad
        • CountHistoryBase.n_hess
        • CountHistoryBase.n_res
        • CountHistoryBase.n_sres
        • CountHistoryBase.start_time
        • CountHistoryBase.update()
      • 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__()
      • Hdf5History
        • Hdf5History.__init__()
        • Hdf5History.exitflag
        • Hdf5History.finalize()
        • 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.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.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.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.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.__call__()
        • 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.get_config()
        • AmiciObjective.initialize()
        • AmiciObjective.par_arr_to_dct()
        • AmiciObjective.reset_steadystate_guesses()
        • AmiciObjective.set_custom_timepoints()
        • 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.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.julia
      • Julia objective
      • JuliaObjective
        • JuliaObjective.__init__()
        • JuliaObjective.get()
      • display_source_ipython()
    • pypesto.optimize
      • Optimize
      • CESSOptimizer
        • CESSOptimizer.ess_init_args
        • CESSOptimizer.max_iter
        • CESSOptimizer.max_walltime_s
        • CESSOptimizer.fx_best
        • CESSOptimizer.x_best
        • CESSOptimizer.starttime
        • CESSOptimizer.i_iter
        • CESSOptimizer.__init__()
        • CESSOptimizer.minimize()
      • CmaesOptimizer
        • CmaesOptimizer.__init__()
        • CmaesOptimizer.is_least_squares()
        • CmaesOptimizer.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()
      • SacessOptimizer
        • 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()
      • 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
      • 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.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.__init__()
        • ProfileOptions.create_instance()
      • approximate_parameter_profile()
      • calculate_approximate_ci()
      • chi2_quantile_to_ratio()
      • parameter_profile()
      • validation_profile_significance()
    • pypesto.result
      • Result
      • McmcPtResult
        • McmcPtResult.__init__()
      • OptimizeResult
        • OptimizeResult.__init__()
        • OptimizeResult.append()
        • OptimizeResult.as_dataframe()
        • OptimizeResult.as_list()
        • 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.default_options()
      • DynestySampler
        • DynestySampler.__init__()
        • DynestySampler.get_original_samples()
        • DynestySampler.get_samples()
        • DynestySampler.initialize()
        • DynestySampler.loglikelihood()
        • DynestySampler.prior_transform()
        • DynestySampler.restore_internal_sampler()
        • 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.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_postprocessor
        • 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.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.__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_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()
      • 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.3 series
      • 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
  • Logo
pyPESTO
  • Search

© Copyright 2018, The pyPESTO developers. Revision 9a754573.

Built with Sphinx using a theme provided by Read the Docs.
Read the Docs v: latest
Versions
latest
stable
v0.3.1
v0.3.0
v0.2.17
v0.2.16
v0.2.15
v0.2.14
v0.2.13
v0.2.12
v0.2.11
v0.2.10
v0.2.9
v0.2.8
v0.2.7
v0.2.6
v0.2.5
v0.2.4
v0.2.3
v0.2.2
v0.2.1
v0.2.0
v0.1.0
develop
v0.0.13
v0.0.12
v0.0.11
v0.0.10
v0.0.9
v0.0.8
v0.0.7
v0.0.6
v0.0.5
v0.0.4
v0.0.3
v0.0.2
v0.0.1
Downloads
On Read the Docs
Project Home
Builds