davaug / chi Goto Github PK

See #26 for infos on MarginalPosteriorPlot

By default

• take mechanistic model name
• enumerate noise parameters

Add an exemplary PK dataset to the data library

• Document in a notebook where the data comes from
• Add cleaned data to the data library
• Implement a PKTimeSeriesPlot which shows one biomarker and the dosing point (amount on y axis)
• Implement a PKPDTimeSeriesPlot which combines the PKTimeSeriesPlot and the PDTimeSeriesPlot

Refactor the sampling controller similar to #44 .

• Compute sensitivies for parameters
• Compute sensitivies for initial conditions

A HierarchicalLogLikelihood

• Takes a list of pints.LogPDFs
• Takes a list of PopulationLogPDFs.
• Implement a PopulationLogPDF base class
  • n_pop_params - population level parameters
  • sample for fixed pop parameters
  • call takes individual and pop parameters and returns score
  • pools_parameters return False or True
• Implement a PoolParameters class that simply takes all parameters and sets them equal.
  • Evaluation returns 0
  • sampling return the input parameter
• HierarchicalLogLikelihood checks whether pop pools, if so, adds just n_pop_params to input parameters, if not adds individual params and n_pop_params.
• Then distributes the right parameters to the right log_likelihoods and PopulationLogPDFs. Possibly index entries for each individual loglikelihood and also index(mask) parameters for the population parameters.

Implement support in the ProblemModellingController

• Extend the set_population_model class.

Building on the PosteriorConvergencePlot build an app that

• allows to dynamically set warm up phase
• computes R hat, ESS etc live for everything but warm up phase
• visualises left out samples from trace
• updates marginal posterior for the non-warm up samples.

Create a log-likelihood that

• takes a pints.log-likelihood
• takes the data as DataFrame
• dynamically allows to perform individualised, (partially) pooled, and (later) hierarchical inference, possibly with a method for each
• it should be possible to use them with a pints posterior
• Create tickets for the inference controllers to return the estimates / samples with ID

Similar to PDTimeSeriesPlot

• Displays dose events
• Displays time series
• Should expect pandas.DataFrame with a columns of applied dose
• Also for model (look at PDTimeSeriesModel)

Probably just because y axis update has to be done for yaxis1, yaxis2 etc.

Similar to Pharmacodynamic model, but

• Needs set dosing regimen class
• set and get PD output variable method typically drug.conc in central compartment
• Set get dose input

Infer PK model parameters indiviudally.

If necessary fix model parameters similar to the reference

• reparametrise in terms of critical volume and growth rate
• run individual optimisation again
• Check whether results improve
• Add reparametrisation to model library

Create a notebook in that

• Displays control growth data
• Optimises PD model for each individual separately 10 times
• Display spread of inferred model parameters in box plot (each parameter separately, such that different scales do not hide variability)
• Run MCMC chains for each individual
• Display trace plots, and diagnostic metrics.

The controller takes a

• pandas.DataFrame with keys for ID, time, and at least one biomarker. Optionally a dose key can be provided, by default None
• Set model method accepts PharmacodynamicModels and PharmacokineticModels.
• If dose_key None PharmacokineticModel is provided, show a Warning that doses are not set from the data.
• If dose_key is provided and PharmacodynamicModel is provided, show a Warning that for PharmacodynamicModels dosing regimens cannot be set
• If dose_key is not None and PharmacokineticModel is provided, set doses according to dataframe when error models are create. I.e. set flag self._dose_applied to True.

When this is done, complete #56 by 'hacking', i.e. set ID in dataset to pooled for all individuals and run optimisation.

Create a problem class that

• inherits from pints' problem base class
• takes an instance of the erlotinib base class model, and times and values.
• additionally to the standard pints.problem methods, create a method that allows to fix parameter values for the inference
• set the output states.

In this issue I am creating a notebook that takes the lung cancer medium dose data from [1], imports it, cleans it, and exports the cleaned data file

• Put data in raw_data repository
• Import data
• Interpret columns
• Clean data
• Visualise data
• Export data to data directory

[1] Eigenmann et. al., Combining Nonclinical Experiments with Translational PKPD Modeling to Differentiate Erlotinib and Gefitinib, Mol Cancer Ther (2016)

Create a log-posterior class similar to pints.LogPosterior

Additional features:

• parameter_names method
• id method

Create a SimulationController dash app with the following features

• Initialises as an empty figure.
• Has an add model method that sets the model to be simulated (for now overwrite any previous model)
• Generates sliders for all parameters of the model
• Solves the model live for slider values (for now only allow SingleOutput models)
• Has an add data method that shows the creates a scatter representation of the data
• Has a method to set the simulation time range
• Has a method that starts the app.
• Potentially: Has a method that returns a static plotly.Figure of some slider configuration, such that simulation may be presented with nbviewer.

Possible extensions:

1. Allow multiple outputs
2. Allow simulation of multiple models
3. Allow marking of current simulation, i.e. create a permanent trace of the current simulation, so outputs of multiple simulations may be more easily compared.

• Allows setting the initial values of the chains
• Run individual and fully pooled analysis again, starting in MAPs

Following the ProblemModellingController class in #43, refactor the OptimisationController such that

• instead of taking just one log-posterior, it can also take a list of log-posteriors.
• if log-posterior is a list, run the defined optimisation for all log-posteriors.
• The results have an ID column with the ID from the respective log-posterior.
• Update the individual inference notebook.
• Update the pooled inference nottebook.

See #19 for details.

Use set_population_model method

A PopulationModel that leaves all parameters independent.

Similar to individual inference, but now pool noise.

Both optimisation and sampling will likely fail with the prior settings

Deploy pd simulator with Heroku

• Create a base class model
• Create a PDModel class that inherits from the base class. This class should define methods that specify the PK input / and PD output states.
• Create a PKModel class that inherits from the base class. This class should define methods that specify the PD input / and PK output states.
• Create a PKPDModel class that inherits from the base class. This model takes a PK and PD model and combines them based on their specified PK/PD input/output states.
• Improve docs of set administration (align equal signs)

See #6.

Create a notebook that solves the tumour growth PD model with the error model suggested by Eigenmann et al.

• Solve PD model in absence of treatment
• Create sliders for all mechanistic and error parameters. Because combining parameters arbitrarily when precomputing the model, it makes sense to find the optimal parameters for one individual, and allow the sliders to perturb values around this optimal solution.
• Allow to plot data next to the model.

In this issue I am creating a notebook that takes the lung cancer control growth data from [1], imports it, cleans it, and exports the cleaned data file

• Put data in raw_data repository
• Import data
• Interpret columns
• Clean data
• Visualise data
• Export data to data directory

[1] Eigenmann et. al., Combining Nonclinical Experiments with Translational PKPD Modeling to Differentiate Erlotinib and Gefitinib, Mol Cancer Ther (2016)

Extends #24.

The inference has been performed rather rash and not very controlled. Add the following features:

• Prior predictive analysis to find suitable parameter priors, likely best done in an app that allows adjusting priors dynamically.
• Keep optimisation
• Run AMCMC or HMC for a short time in the vicinity of those points.
• Plot marginal posteriors with their traces to explore convergence
• Plot pair-wise correlations between parameters
• Construct priors that encapsulate the inferred posteriors
• Run simulation-based calibration for HMC
• With the calibrated HMC and new priors run final chains
• Show marginals and traces to convergence check
• Plot marginal posterior distributions
• Plot pair-wise correlations between parameters
• Plot posterior predictive model

This figure is not supposed to assess convergence, but compare marginal posteriors across individuals

• Allow setting a warm up phase that can be excluded from the plot
• Plots marginal posteriors of individuals next to each other (different chain runs are now taken as one chain)
• Computes R hat and ESS in hovertext

The PDDataPlot has been generalised to a PDTimeSeriesPlot.

Setup docs generation with Sphinx and test documentation

• Set up sphinx
• Improve docstrings
• Add docs to README
• Set up doc tests.

This notebook should

• Display the data
• Run an optimisation multiple times for each individual separately
• Display the point estimates in a figure
• Run an MCMC sampling routine for each individual separately
• Display the traces as time series to visually inspect convergence
• Display the traces as marginal histograms for the parameters
• Display multi-dimensional histograms to explore correlations
• Compute R, ESS, possibly rank R or R*

1. PyStan https://pystan.readthedocs.io/en/latest/getting_started.html
2. Stan documentation https://mc-stan.org/docs/2_19/stan-users-guide/solving-a-system-of-linear-odes-using-a-matrix-exponential.html
3. Pints Stan interface, but mostly how to use stan model in pints, not how to use pints models in stan. https://github.com/pints-team/pints/blob/stan-interface/

Set mean dose manually for now and ignore dose in dataset

brew update-reset sometimes takes forever to setup Homebrew for sundials. Check whether there is a more light weight command.

I forgot to transform the parameters.

Create a figure that

• Takes a pandas.DataFrame with keys ['ID', 'Parameter', 'Estimate' , 'Score', 'Run']
• Displays the estimates across runs in a bar plot. Each parameter in a separate figure.
• Score and run in hovertext
• Each individual gets a different colour

Create a figure that takes samples from one individual and plots marginal posterior with trace.

This class is mainly to assess convergence of the traces.

• Chains are assigned with different colours

The class should be initialised with a

1. mechanistic model
2. an error model
3. optionally a population model

Has method

• takes data, parameters (or prior/posterior dist) num of individuals and returns dataframe with simulated individuals.

• Use HierarchicalLogLikelihood
• Run sampling
• Display posterior estimates.

• implement method
• check other places in ProblemModellingController that need to be adapted for this method.

In this issue I am creating a notebook that takes the lung cancer control growth data from [1], imports it, cleans it, and exports the cleaned data file

• Put data in raw_data repository
• Import data
• Interpret columns
• Clean data
• Visualise data
• Export data to data directory

[1] Eigenmann et. al., Combining Nonclinical Experiments with Translational PKPD Modeling to Differentiate Erlotinib and Gefitinib, Mol Cancer Ther (2016)

Along the lines of #24 but now pool all parameters across individuals.

In this issue I am creating a notebook that takes the lung cancer low dose data from [1], imports it, cleans it, and exports the cleaned data file

• Put data in raw_data repository
• Import data
• Interpret columns
• Clean data
• Visualise data
• Export data to data directory

[1] Eigenmann et. al., Combining Nonclinical Experiments with Translational PKPD Modeling to Differentiate Erlotinib and Gefitinib, Mol Cancer Ther (2016)

Create a SamplingControler similar to the OptimisationController and building on pints.MCMCController

Similar to PDSimulationController

For informative priors it is worth checking how much information was gained from the data.

• Add a switch to the marginal posterior histograms that plots the priors as line plots.