Isoniazid is one of the two main first-line tuberculosis drugs, along with rifampicin. Its plasma concentrations vary a lot between patients, and low concentrations of anti-TB drugs have been linked to treatment failure and to multidrug-resistant TB. Several population PK models of isoniazid had been published, but nobody had put them side by side. We wanted to compare the models and see which covariates kept coming up as explaining the variability.

How we did it

We followed PRISMA and searched PubMed and Scopus for population PK analyses of isoniazid in volunteers or TB patients from 2011 to 2021. Reviews, methodology papers, non-compartmental analyses, in vitro and animal work, and studies that reused a previously published model were excluded. From 107 records, 14 went to full evaluation and 12 studies (published 2013 to 2021) were included.

Together they covered 1,444 people, from 33 to 466 per study, aged 0 to 72. Four studies included children, eight were adults only, and one of those was in healthy volunteers. All gave isoniazid orally.

What we found

Ten of the twelve models were two-compartment and two were one-compartment. One of the one-compartment models was built from a single sample taken 3 hours after the dose, which probably isn’t enough data to support a second compartment. Absorption was handled in different ways: first-order, transit compartments (mean transit time 0.66 h, range 0.179 to 0.924 h across studies) or a lag time. Transit compartments describe the physiology of absorption better than a lag time does.

Mean reported clearance was 20.55 L/h (SD 16.60). Children cleared the drug more slowly: median 6.5 L/h (range 4.44 to 11.3) against 22.8 L/h (11.4 to 40.5) in adults. This fits with how NAT2, the enzyme that acetylates isoniazid, matures. At birth the slow-acetylator phenotype predominates, and the fast phenotype develops over roughly the first four years of life in children with the relevant genotypes. Central volume was also smaller in children.

Across the twelve studies, 29 covariates were tested. NAT2 genotype was the main one, affecting clearance in 11 studies. Creatinine clearance and body mass index each came up once on clearance, and body weight (two studies), body mass index and mid-upper arm circumference (one each) on central volume. Most studies used a mixture model to split patients into acetylator groups.

The NAT2 effect also tracks ethnicity. In a South African study more than 80% of patients were slow or intermediate acetylators, and in a Tanzanian study 48% were slow and 48% intermediate. Studies from Singapore and China found mostly fast and intermediate acetylators, and those two studies reported some of the highest clearances in the review.

A few gaps showed up. Only one study modelled the main metabolite, acetylisoniazid, even though acetylation status matters for hepatotoxicity (slow acetylators are at higher risk). Only one study checked adherence, by pill count and medication diaries. Every study did basic internal evaluation such as goodness-of-fit plots and VPCs, five added bootstrap or NPDE, and only two tested their model on an external dataset.

What it means

To dose isoniazid well, a patient’s NAT2 genotype and age should be taken into account, and body weight and BMI matter for dose adjustment. Genotyping isn’t routine everywhere, so mixture models are a practical way to estimate acetylator status when genetic data aren’t available. They still need external validation: one study that did genotype some patients found no significant difference in Cmax or AUC between slow-intermediate and rapid acetylators. Larger studies with better sampling would help, and both existing and new models should be evaluated on external data.

The paper: Tan WR, Sheikh Ghadzi SM, Hyder Ali IA, Harun SN. Systematic review of population pharmacokinetic models of isoniazid in children and adults with tuberculosis. Malaysian Journal of Pharmacy. 2022;8(2):1-15. doi:10.52494/DJIQ7058. It’s free to read on the journal’s site.

Piperacillin-tazobactam (PTZ) is often given to critically ill children as prophylaxis around surgery, especially abdominal and ear, nose and throat (ENT) procedures. International guidance for intraoperative dosing in children is 80-100 mg/kg of piperacillin (90-112.5 mg/kg as PTZ) every 2 hours.

That regimen has two problems. One is exposure: an earlier study from our group found that children who developed piperacillin-associated acute kidney injury had an average highest trough of 50 mg/L in the first 24 hours, against 10.7 mg/L in those who didn’t. The other is practical. Clinicians who give antibiotics in the operating room told us that redosing every 2 hours is hard to keep up with.

About 68% of a piperacillin dose is excreted unchanged by the kidneys, and surgery can change renal function, blood volume and fluid balance. There were population PK models for critically ill children in general, but none for children during and after surgery. So we set out to build one and use it to find doses that reach a sensible target without the very high concentrations the current regimen gives.

What we did

The data came from a larger prospective PK study of beta-lactams in the pediatric intensive care unit at Cincinnati Children’s Hospital Medical Center. We included 34 children who had surgery and were getting PTZ every 2-3 hours: 15 liver transplants, 2 total pancreatectomies with islet autotransplantation, 9 other abdominal surgeries and 8 ENT surgeries. Median age was 7.07 years, median weight 20 kg and median baseline creatinine clearance (bedside Schwartz) 143 mL/min/1.73 m².

Sampling was opportunistic, so no extra blood was drawn. After a PTZ dose we requested leftover blood from routine clinical samples and measured total and free piperacillin by HPLC. That gave intraoperative and postoperative samples for everyone and preoperative samples for children already in the PICU: 286 total and 285 free concentrations, 1 to 19 per child.

We built separate NONMEM models for total and free piperacillin. The total model was the primary analysis, and the dosing simulations used the free model, since the efficacy target is defined on free drug.

The model

A two-compartment model fit better than one compartment. Weight entered through allometric scaling, and creatinine clearance was the only other covariate kept on clearance:

Central volume was 17.2 L/70 kg, intercompartmental clearance 3.25 L/h/70 kg and peripheral volume 4.79 L/70 kg. Between-patient variability was 28.7% on clearance and 41% on central volume, with a 37.1% proportional residual error. Age and surgery type were tested and didn’t stay in.

Treating the preoperative and postoperative periods as separate occasions improved the fit, but once clearance was normalized for weight and renal function there were no significant differences between the three periods or between surgery types. Postoperative clearance did vary a lot between children (2.26 to 14.96 L/h/70 kg).

Clearance in our patients, 7.1 L/h/70 kg, was lower than the 13.4 and 12.6 L/h/70 kg reported in two earlier studies of critically ill children outside surgery. Kidney injury after surgical stress could explain some of that, and so could saturation of clearance at high doses: our patients got around 89 mg/kg every 2-3 hours, while those studies used 75 mg/kg every 6 hours.

Simulating doses

We simulated 1,000 virtual patients per regimen in mrgsolve, grouped by creatinine clearance (five groups, 20-29 up to 130 and above) and weight (four groups, 10-29 kg up to 70 kg and above). We compared a 30-minute infusion every 2 hours with a 30-minute loading dose followed by a continuous infusion.

Both targets were on free piperacillin and had to hold for the whole surgery: above 8 mg/L (the CLSI susceptible breakpoint for Enterococcus and Enterobacterales) and above 32 mg/L (four times that MIC). A regimen passed if more than 90% of virtual patients met the target.

The current 100 mg/kg regimen gave peaks and troughs far above either target. The doses that were enough came out much lower:

Where a child falls in each range depends on their weight and renal function group, with smaller children and higher creatinine clearance needing more per kilogram. The figure plots the every-2-hour recommendations from the paper’s tables next to the guideline range. Even the largest, 55 mg/kg, is well below 80-100 mg/kg.

What it means for dosing

Both approaches reach the targets with much less drug, but I’d lean toward continuous infusion. For the higher target, every-2-hour dosing still left most simulated patients with steady-state troughs above 50 mg/L, the level we had seen in children who developed kidney injury. A continuous infusion keeps concentrations nearer the target and removes the 2-hour redosing problem.

For the lower target we picked a 10 mg/kg loading dose even though it overshoots slightly, because it reaches the target in about 12 minutes compared with 24 for 5 mg/kg. The higher target gives some margin for tissue penetration, which we didn’t measure, though the tissues involved in these surgeries are well vascularized.

Limitations

Only seven children (21%) were under 2, so we couldn’t model renal maturation and the recommendations are for children older than 2. Timing of leftover samples can be imprecise, and we didn’t account for that, which may affect the intercompartmental clearance and peripheral volume. Intercompartmental clearance was poorly estimated anyway (74% RSE), as you’d expect from sparse data. With 34 patients the study is small, even if we believe it’s the largest population PK study of prophylactic PTZ in this group, so the regimens need prospective testing. The model could also support Bayesian dose adjustment after surgery, which needs its own study.

The paper is open access: Tan WR, Irie K, McIntire C, Torres JL, Jones R, Gibson A, Mizuno T, Tang Girdwood S. Model-informed dose optimization for prophylactic piperacillin-tazobactam in perioperative pediatric critically ill patients. Antimicrob Agents Chemother. 2025;69(3):e0122724. doi:10.1128/aac.01227-24. The general simulation workflow is in the earlier post on Monte Carlo simulation for dose optimization.

A wrist-worn device gives you a nearly continuous record of physiology over months, far denser than any biospecimen schedule. The biology (a metabolomics panel, a biomarker, a drug concentration) is measured a handful of times. A lot of the work in linking the two is deciding what the continuous stream means as a variable before any model sees it.

These notes cover three decisions: how to aggregate a stream into an exposure, how to line that exposure up with a sparse sample, and what within-day structure does to an association if you ignore it.

What a wearable measures

Very little coming off a consumer or research-grade wearable is a direct measurement of what it’s named after.

• Steps are an accelerometer signal run through a proprietary step-detection algorithm. Two devices disagree with each other, and one device can disagree with itself after a firmware update.
• Sleep stages are inferred from movement and heart rate; this isn’t polysomnography. Total sleep time is estimated reasonably well, but stage-level output is much weaker, and I’d treat REM/deep splits as device-specific constructs rather than physiology.
• Heart rate variability comes from an optical pulse signal, so strictly it’s pulse rate variability, and it’s sensitive to motion and perfusion. The reported metric is often RMSSD over a fixed nocturnal window, which is one choice among several and not a standard.
• Resting heart rate is a daily summary from a vendor algorithm whose definition of “resting” is undocumented and can change.

So a wearable variable is much safer to compare within a device and firmware version than across them. Either put device model in the model as a covariate or restrict the cohort to one device. It also helps to think of these as digital phenotypes: reproducible constructs with some biological meaning, but not gold-standard measurements. That’s enough for association work but not for claims about mechanism.

Missing data

A wearable records nothing when it’s off the wrist, and people take it off for reasons: charging, showering, discomfort, illness, travel, losing interest in the study. That is missing-not-at-random in the most direct way, because non-wear is correlated with the states you’re studying.

At minimum, set a wear-time rule in advance. A day counts only if wear time is above some threshold (10 or 16 hours are common; nocturnal metrics need the night itself covered), and a participant-period counts only if it has enough valid days. These thresholds matter, so report how many participant-days, and which participants, each rule removed. If the cohort goes from 60 participants to 34 by the time you fit the model without anyone saying so, the analysis is no longer about the cohort in the methods section.

Check whether valid-day counts differ by group. If they do, the missingness is informative and the complete-case analysis is biased. State the likely direction of the bias even if you can’t correct it.

From stream to exposure

The model needs one number per sample and the sensor gives thousands. Most of the analytic freedom is in this aggregation step, so fix it before looking at outcomes. There are four choices:

1. Window: how much time before (or around) the biological sample counts. The preceding night, 24 hours, 7 days. Match it to the biology’s timescale; a metabolite with a half-life of hours shouldn’t be regressed on a 7-day activity average.
2. Summary: mean, median, total, time above a threshold, or a variability measure like the standard deviation across days. This is the same idea as exposure metrics in PK, where $AUC$, $C_{max}$ and time above target are three summaries of one curve that answer different questions.
3. Reference: the absolute value, or the deviation from the participant’s own baseline. The deviation is usually better, because between-person differences in resting heart rate are much bigger than the within-person changes you care about. That’s what person-mean centring gives you:

Putting both terms in separates the within-person effect from the between-person one. Using only the raw value estimates a mix of the two and reports it as one effect.

1. Lag: whether the exposure comes before the sample, after it, or around it. Only “before” supports a directional reading, and only weakly.

The risk here is multiplicity that nobody counts. Three windows, four summaries and two references make 24 versions of the same association, and reporting whichever one reached significance is the garden of forking paths again. Pre-specify one primary aggregation. If you run the others, call them a sensitivity analysis and report where they disagree.

Diurnal structure

Both sides of the association vary over the day. Many plasma metabolites (cortisol-associated species, bile acids, amino acids after a meal) have systematic diurnal variation, and so does every wearable metric. If sample collection time differs between groups, time of day is a confounder that looks just like an effect.

The cheap fix is to record the clock time of sampling and adjust for it. Two harmonic terms handle a daily rhythm without using many degrees of freedom:

This is a cosine with amplitude $\sqrt{\beta_c^2 + \beta_s^2}$ and phase $\arctan(\beta_s / \beta_c)$. It’s linear in its parameters, so any mixed model can estimate it. A second harmonic ($2\pi t / 12$) picks up a bimodal shape, such as a second peak after a meal.

Describing diurnal variability is also a result in itself, and often a more reliable one than the cross-sectional association: which analytes have a detectable within-day rhythm, how large it is, and its phase relative to sleep offset. That question actually uses the dense side of the data. A single-timepoint association mostly doesn’t.

The model

With repeated visits per participant, start with a random intercept per participant:

Here $y_{ij}$ is the log-transformed analyte, $x$ is the aggregated wearable exposure split into within- and between-person parts, $f(t_{ij})$ are the diurnal terms, and $\mathbf{z}$ holds covariates (age, sex, BMI, device model, and season if the study runs long enough).

On interpretation: $\beta_1$ is a within-person effect. It describes what happens to the analyte when this participant’s activity or sleep moves away from their own usual level. That’s closer to a causal reading, and stable between-person traits don’t confound it. With a log-transformed analyte, $\beta_1$ is multiplicative (a unit change in exposure multiplies the analyte by $e^{\beta_1}$), so report it that way rather than as a raw coefficient on an arbitrary intensity scale.

Multiple testing

Thousands of analytes crossed with a few wearable metrics is a lot of tests. Run Benjamini–Hochberg within each wearable metric, not pooled across metrics or with unrelated contrasts, so the threshold stays interpretable.

Expect small effects. A within-person association between last night’s sleep duration and a plasma metabolite is a modest multiplicative shift, and a study powered for a large effect will find nothing. The analytes are also correlated, often because they sit in the same pathway or are adducts of one compound, so 50 significant features may be far fewer distinct findings. Collapse to compounds or pathways before counting.

The findings that replicate tend to be the ones that hold across the sensitivity aggregations, which aren’t necessarily the ones with the smallest $q$-value in the primary analysis.

Summary

Linking wearables to molecular data is mostly a problem of defining the measurement. Work out what the device is reporting, set a wear-time rule and report what it removes, fix one aggregation window and summary before looking at outcomes, split within- from between-person variation, adjust for time of day on both sides, and control error within each metric. The sensor stream is where most of the information is, and a single cross-sectional correlation wastes most of it; looking at within-day and within-person structure makes better use of it. The note on untargeted metabolomics covers the other side of the join.

Untargeted metabolomics data usually arrives as a feature table: samples in rows, mass-spectrometry features in columns, intensities in the cells. It looks ready for statistics, but most of the choices that decide whether the final association list means anything are made between that export and the first model fit, and they often get made without anyone writing them down.

These notes go through those choices in the order they come up. The example I have in mind is plasma metabolomics from a cohort with repeated visits per patient, which breaks a few of the usual shortcuts.

What a feature table is

A few things make a feature table different from the tidy assay data most statistics courses assume.

A feature is not a metabolite. It is a mass-to-charge ratio at a retention time, and it could be a metabolite, an adduct of one, an in-source fragment, an isotopologue or contamination. Annotation maps some features to compounds with varying confidence, and the confidence level matters: a level-1 identification matched to an authentic standard and a level-3 putative class assignment don’t support the same claims. Several correlated features are often one compound showing up more than once.

Intensity is relative. Ionization efficiency differs by orders of magnitude between compounds, so intensities can be compared across samples within a feature but not across features. An untargeted run can’t tell you that metabolite A is more abundant than metabolite B. Fold changes within a feature are fine, and that’s what the analysis is for anyway.

Blank cells mean the feature wasn’t detected in that sample. It might be absent, below the limit of detection, or missed by the peak picker. These are different mechanisms, and how you handle them shapes the result more than which test you pick.

Filtering

Two filters come before normalization. For both, report what the choice cost.

Prevalence: drop features detected in fewer than some fraction of samples. A common default is 50%, or 50% within at least one group. The within-group version matters when a compound is present in one arm and absent in the other, because a global prevalence filter throws away exactly that case.

Annotation: keeping only annotated features makes interpretation possible but discards real signal. Whether that’s acceptable depends on whether you want a mechanism or a classifier.

Every filter should log what it dropped and why, and the counts should go in the write-up. If a pipeline silently removes 60% of the features, versioning the code doesn’t make it reproducible in any useful sense.

Normalization and transformation

Total ion current (TIC) normalization divides each sample by its own summed intensity, which corrects for injection volume and gross sensitivity drift:

where $x_{ij}$ is the intensity of feature $j$ in sample $i$ and $\bar{s}$ is the mean sample sum. The catch is that it assumes total signal is constant. If one group really has more total metabolite content, TIC normalization removes that effect. Probabilistic quotient normalization is the usual alternative; median or quantile scaling are simpler options.

Then log-transform. Intensities are right-skewed over several orders of magnitude, and the log turns multiplicative effects into additive ones, which is what a linear model can express:

The pseudo-count $c$ is only there to handle zeros, and its value decides how far below the detected range a non-detect ends up. If non-detects are treated as missing (next section), you don’t need $c$ at all, which is another point in favour of doing that.

Non-detects: treat as missing, don’t impute

The usual approach is to impute non-detects at half the minimum observed intensity, or by $k$-nearest neighbours, and carry on. Both are fine under missing-at-random. Metabolomics non-detects are rarely missing at random, though. They’re missing because the value was low, which is missing-not-at-random by definition.

Imputing at a fixed low value puts a spike in the left tail of the distribution. If one group has more non-detects (which is what happens when a compound differs between groups), the spike lands unevenly and creates a difference in the mean for the test to find.

What I’d default to instead is two analyses that answer different questions:

1. Model detected intensity only, with non-detects as missing. Among samples where the feature is present, does its abundance differ?
2. Test presence/absence separately, as a binomial contrast on detection status. Is the feature detected at different rates between groups?

The intensity model can’t see a feature that’s simply absent in one group, and the detection-rate test can’t see a graded difference, so reporting both keeps one from being mistaken for the other. If only a handful of samples in a group have the feature detected, skip the intensity model for that feature instead of fitting it to four points.

Repeated visits and batch structure

With several samples per patient the observations aren’t independent. A patient random intercept is the minimum:

where $u_{p(i)}$ is the random intercept for the patient contributing sample $i$ and $\mathbf{z}_i$ holds covariates. Ordinary least squares treats repeat visits as independent patients and understates the standard error on $\beta_1$, and the problem is worst when patients contribute unequal numbers of visits.

Run order and batch need the same attention. LC-MS sensitivity drifts within a run and shifts between batches. If group correlates with run order, which happens whenever samples are run as they come in, the drift becomes the group effect. Two things help: a run-order-adjusted model as a sensitivity check, and a cross-batch check on whether pooled QC samples behave consistently that halts the analysis when they don’t.

Fitting OLS and the run-order-adjusted model next to the primary mixed model is cheap and shows whether a finding depends on the model specification. If the three disagree, report that.

Multiple testing

A few thousand features at $\alpha = 0.05$ gives a few hundred false positives before any biology. The standard fix is Benjamini–Hochberg control of the false discovery rate: order the $p$-values $p_{(1)} \le \dots \le p_{(m)}$ and reject up to the largest $k$ with

Two practical points. Apply it within each contrast rather than pooling every comparison in the analysis, otherwise the threshold depends on how many unrelated questions happen to be in the same script. And FDR control is about the expected proportion of false rejections in the list. A $q$-value of 0.05 doesn’t mean that particular feature has a 5% chance of being wrong.

Adducts and fragments of the same compound make the tests correlated. Benjamini–Hochberg is valid under positive regression dependence, which is the usual justification, but correlated features still make the list look longer than the number of distinct findings. Collapse to compounds before counting discoveries, so you’re not reporting 40 features that are really 11 molecules.

What to report

Along with the ranked table, I’d want:

• counts at every filter, with what was dropped
• the primary model and its sensitivity comparisons, side by side
• presence/absence tested separately from intensity
• $q$-values within contrast, with discoveries collapsed to compounds
• a statement of what the design can’t answer

The last point matters more than it looks. A cohort can have plenty of power to ask whether the metabolome separates one disease from another and still be unable to say whether it predicts treatment response before the first dose. For example, if medication is recorded without start dates, only a handful of patients may have a plasma sample that provably comes before treatment, and no modelling fixes that. In that situation the useful output is a feasibility assessment giving the design and sample size a proper study would need. That still counts as a result, even without any $p$-values.

Summary

With untargeted metabolomics, care in the steps before the statistics matters more than a clever test. Choose filters against their alternatives, treat non-detects as missing instead of imputing them, put patient structure in the model, check run order, and control error within each contrast. The earlier notes on transcriptomics and chromatin accessibility cover similar pre-processing for other assays.

These are notes on using variational autoencoders (VAEs) for two things in pharmacometrics: model-informed precision dosing (MIPD) based on patient-specific profiles, and describing PK profiles that conventional ODE-based compartmental models struggle with.

A conventional PK model makes you pick a structure up front. That structure is what gives the parameters physiological meaning and what lets the model extrapolate. A VAE relaxes it and gives up interpretability and extrapolation in exchange for flexibility. Whether that’s worth it depends on the problem, and I’ve tried to say below where I think it isn’t.

What ODE models do and do not constrain

Compartmental models assume specific functional relationships:

or more complex structures:

The case for flexible models often gets overstated, so a few things this does not imply:

• Multi-exponential decay isn’t a limitation. A linear compartmental system produces sums of exponentials by construction; that’s what the compartments are.
• Enterohepatic recirculation and target-mediated disposition aren’t “non-compartmental”. Both have well-established ODE formulations, and the TMDD system is written out in an earlier post on this site.
• Irregular sampling isn’t a problem for ODE models. Nonlinear mixed-effects estimation was built for sparse, unbalanced clinical data. If anything it’s the other way round: a network that outputs a fixed grid of time points is what has trouble with irregular sampling.

The actual motivation is narrower. ODE models make you commit to a structure before fitting, and that commitment is what lets the model extrapolate to doses and populations it hasn’t seen. A flexible model is worth considering when the structure really is unknown, when the profile shape itself carries useful information (clustering patients by profile shape, say), or when there’s enough data to learn the structure instead of assuming it. Those situations exist but they’re the exception, and the baseline to beat is a properly specified population PK model.

VAE architecture for PK

Encoder

The encoder maps observed concentration-time data to a latent representation of patient physiology:

where:

• $x = {C_{obs}(t_1), C_{obs}(t_2), …, C_{obs}(t_n), \text{covariates}}$ represents observed data
• $z$ is the latent vector encoding patient-specific PK characteristics
• $\mu_\phi(x)$ and $\sigma_\phi(x)$ are neural network outputs parameterizing the latent distribution

The idea is that the latent vector picks up patient-specific clearance, volume of distribution and absorption characteristics, and inter-individual variability in PK behavior generally.

Decoder

The decoder reconstructs concentration-time profiles from the latent representation:

and $\mu_\theta(z, \text{Dose})$ can represent profiles that don’t come from an ODE:

There’s a gap between this expression and the code below, though. Writing $\text{Decoder}(z, \text{Dose}, t)$ suggests a function of continuous time, but the network in the code outputs a fixed vector of time_points values. It only knows about the grid it was trained on, and it has no idea that concentration at $t + \Delta t$ is related to concentration at $t$. Neural ODEs are meant to close that gap (see below).

Within that grid, the decoder isn’t limited to exponential or polynomial forms. It can learn arbitrary concentration-time curves, multi-modal shapes, non-standard absorption and complicated elimination phases.

Variational inference

The latent vector is sampled with the reparameterization trick:

which allows gradient-based optimization while keeping the probabilistic interpretation.

Application 1: precision dosing

For MIPD the VAE learns individual PK characteristics from sparse observational data.

Training:

1. Encoder processes observed concentrations: $z_i = \text{Encoder}(C_{obs,i}, \text{covariates}_i)$
2. Each patient’s latent vector $z_i$ captures the shape of their PK profile
3. Decoder learns to predict full profiles: $C_{pred,i} = \text{Decoder}(z_i, \text{Dose}_i)$

Dose optimization: given a target exposure (e.g. an AUC target or trough concentration), the dose for patient $i$ is

What this offers for MIPD: full profiles inferred from a few observations, individual variability held in the latent space, dose individualization done directly in that patient-specific space, and prediction intervals from the probabilistic framework.

Implementation example

import torch
import torch.nn as nn

class PKVAE(nn.Module):
    def __init__(self, latent_dim=8, time_points=24):
        super().__init__()
        self.latent_dim = latent_dim      # encode() needs this at call time
        self.time_points = time_points
        # Encoder: concentration-time data -> latent distribution
        self.encoder = nn.Sequential(
            nn.Linear(time_points + 3, 64),  # +3 for covariates
            nn.ReLU(),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, latent_dim * 2)  # mean and log-variance
        )
        
        # Decoder: latent + dose -> concentration profile
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim + 1, 32),  # +1 for dose
            nn.ReLU(),
            nn.Linear(32, 64),
            nn.ReLU(),
            nn.Linear(64, time_points)
        )
    
    def encode(self, x):
        h = self.encoder(x)
        mu, logvar = h[:, :self.latent_dim], h[:, self.latent_dim:]
        return mu, logvar
    
    def reparameterize(self, mu, logvar):
        std = torch.exp(0.5 * logvar)
        eps = torch.randn_like(std)
        return mu + eps * std
    
    def decode(self, z, dose):
        return self.decoder(torch.cat([z, dose.unsqueeze(1)], dim=1))
    
    def forward(self, x, dose):
        mu, logvar = self.encode(x)
        z = self.reparameterize(mu, logvar)
        recon = self.decode(z, dose)
        return recon, mu, logvar

def precision_dosing_loss(recon, target, mu, logvar, beta=0.1):
    # Both terms sum over the feature axis and average over the batch. Mixing a
    # mean reconstruction with a summed KL, as is often written, makes beta
    # depend on batch size and on how many time points you happen to have.
    recon_loss = nn.functional.mse_loss(
        recon, target, reduction="none").sum(dim=1).mean()
    kl_loss = (-0.5 * (1 + logvar - mu.pow(2) - logvar.exp()).sum(dim=1)).mean()
    return recon_loss + beta * kl_loss

Application 2: profiles that are hard to write as ODEs

Some PK profiles are awkward for standard ODE models.

Multi-phase elimination with non-standard exponents. The traditional form is $C(t) = A_1 e^{-\lambda_1 t} + A_2 e^{-\lambda_2 t}$; the VAE version is $C(t) = \text{Decoder}(z, \text{Dose}, t)$, where the decoder learns the functional form.

Irregular absorption. Complicated lag times, multiple absorption sites or food effects give profiles that don’t follow a standard $k_a$ model. A decoder can learn these directly:

where $z_{abs}$ encodes patient-specific absorption characteristics.

Target-mediated or saturable processes. When TMDD or another saturable process causes non-exponential decay, the VAE can capture the profile shape without explicit Michaelis-Menten equations:

Objective

The VAE objective trades off reconstruction accuracy against regularization of the latent space:

The first term is the reconstruction term (fit to the observed data), the second is the KL divergence pulling toward the prior $p(z) = \mathcal{N}(0, I)$, and $\beta$ weights the two.

Comparing fits

This says nothing about how complex a profile is. A model with enough capacity pushes it toward zero on the training set however simple the underlying profile. It’s only informative on held-out patients, and even then a lower value has to be weighed against how many parameters it took to get there.

Neural ODEs

A decoder that outputs a fixed grid throws away the one thing we know for sure about a concentration-time profile: it’s the solution of a differential equation in time. A neural ODE keeps that structure and only learns the right-hand side,

where $f_\theta$ is a neural network and the profile comes from integrating it with an ordinary solver. That gets back what the plain decoder loses:

• Continuous time. The profile can be evaluated at any $t$, so irregular and patient-specific sampling works the same way as in a conventional PK model.
• Dosing events. Integration restarts at each dose, so multiple doses and infusions are handled the way they actually happen instead of being baked into a fixed output grid.
• Partial mechanism. You can write down the known part of the system and learn only the unknown part. This hybrid is where I’d start: a one-compartment model with a learned clearance term is much easier to justify, and much more identifiable, than a black box over the whole profile.

The downsides: neural ODEs train slowly, suffer from whatever stiffness the solver has trouble with, and overfit easily on sparse clinical data, so they shouldn’t be the default. But if the reason for dropping ODEs is that the profile shape is unusual, a neural ODE makes more sense than throwing away the time structure entirely.

Combining with conventional pharmacometrics

VAEs can also sit alongside ODE models: to classify which patients need a complex model and which a simple one, to model the residual deviations from ODE predictions, or to look for nonlinear covariate relationships in the latent space.

Possible uses

On the precision dosing side: inferring full profiles from sparse therapeutic drug monitoring samples, pediatric dosing with complicated age-dependent PK changes, and organ impairment without assuming the standard clearance relationships.

On the profile side: biologics with TMDD (saturable elimination without explicit Michaelis-Menten terms), enterohepatic recirculation (secondary peaks without adding compartments), and patient-specific absorption patterns learned from data.

Validation

For dosing: cross-validate dose prediction accuracy on held-out patients, compare VAE-predicted doses with clinical outcomes prospectively, and check that the prediction intervals are calibrated against observed variability.

For profile modeling: visual predictive checks of observed vs VAE-generated profiles, reconstruction error on independent datasets, and a check that the learned profiles are consistent with known PK principles.

Pros and cons

In favor: it can fit profiles that are hard to describe with ODEs, it holds individual variability in the latent space, it handles limited observations through the learned population structure, and it can pick up nonlinear covariate relationships.

Against: it needs a lot of training data, the latent space is harder to interpret than PK parameters, it extrapolates poorly beyond the training distribution, and it costs more compute than an ODE model.

Summary

VAEs give a flexible, patient-specific latent representation that can be used for dose individualization and for profile shapes that standard compartmental models handle badly. For most problems a well-specified population PK model is still the thing to beat, and when the time structure matters a neural ODE or a hybrid model is usually a better fit than a grid-output decoder.

Indirect response (IDR) models are pharmacodynamic models for drugs that don’t act directly on the thing being measured. The drug changes the turnover (synthesis or degradation) of some endogenous substance, and the level of that substance is what we measure as the effect.

Direct vs indirect response

In a direct response model, concentration maps straight to effect, $E = f(C(t))$. Anesthetics are the usual example: higher concentration, deeper anesthesia.

In an indirect response model the chain is longer: concentration changes turnover, turnover changes the level of a mediator, and the mediator level is the measured effect. Warfarin doesn’t affect clotting time directly. It inhibits synthesis of clotting factors, and the factor levels determine clotting time. Mathematically, the drug acts on $k_{in}$ or $k_{out}$, which then changes the response $R(t)$.

Bathtub analogy

Think of the response (a biomarker level, a clotting factor concentration) as the water level in a bathtub:

• $k_{in}$ (or $R_{syn}$) is the faucet, a constant rate of production or synthesis.
• $k_{out}$ is the drain, a constant rate of elimination or degradation.
• At baseline ($R_0$) the faucet and drain balance and the level is stable.

The drug doesn’t change the water level directly. It either turns the faucet up or down (acts on $k_{in}$) or partly blocks or opens the drain (acts on $k_{out}$). The level then changes slowly, which is where the delay between concentration and effect comes from.

The basic equation

The rate of change of the response $R(t)$ is

where:

• $R(t)$ is the response variable (e.g., biomarker level, physiological measure)
• $k_{in}(t)$ is the zero-order synthesis rate (may be drug-modulated)
• $k_{out}(t)$ is the first-order elimination rate constant (may be drug-modulated)

At baseline (steady state, no drug), $dR/dt = 0$, so

where $R_0$ is the baseline response level.

The four basic IDR models

Model I: inhibition of synthesis ($k_{in}$)

The drug inhibits production of the endogenous substance:

where $I(C) = \frac{I_{max} \cdot C(t)}{IC_{50} + C(t)}$ is the inhibitory drug effect function, $I_{max}$ is the maximum inhibition (typically 1), $IC_{50}$ is the concentration giving 50% inhibition, and $C(t)$ is the drug concentration.

Steady state:

Example: warfarin inhibits synthesis of the vitamin K-dependent clotting factors (II, VII, IX, X) in the liver, so the anticoagulant effect, measured as increased INR, is delayed.

Model II: stimulation of synthesis ($k_{in}$)

The drug increases production:

where $S(C) = \frac{S_{max} \cdot C(t)}{SC_{50} + C(t)}$ is the stimulatory effect function, $S_{max}$ is the maximum stimulation factor, and $SC_{50}$ is the concentration giving 50% of maximum stimulation.

Steady state:

Example: erythropoietin stimulates red blood cell production, and the effect shows up over days to weeks.

Model III: inhibition of loss ($k_{out}$)

The drug reduces the elimination rate:

Steady state:

Example: inhibiting loss raises the mediator above baseline, as when a drug blocks the clearance of an endogenous substance it’s meant to sustain. Corticosteroids don’t belong here; their classical description is Model I, suppression of cortisol synthesis.

Model IV: stimulation of loss ($k_{out}$)

The drug increases the elimination rate:

Steady state:

Example: diuretics increase elimination of fluid and electrolytes, with rapid onset but sustained effects.

Time course

After a step change in drug concentration, the time to reach the new steady state is set by the effective elimination rate constant. For Model I (inhibition of $k_{in}$):

where $t_{ss}$ is the time to reach 99% of steady state. The response half-life is $t_{1/2} = 0.693/k_{out}$, so that’s about 6.6 response half-lives. Five half-lives only gets you to 96.9%. What sets this is the turnover of the mediator, not the half-life of the drug.

Recovery after stopping the drug is also governed by $k_{out}$:

Because recovery depends on endogenous turnover and not on the drug’s PK, the model can predict washout periods and how the dosing interval affects the response.

Hysteresis

All four IDR models produce hysteresis, because peak concentration comes before peak effect. The direction of the loop depends on whether the response rises or falls, not on which parameter the drug acts on. The lag happens because drug concentration changes quickly (set by PK) while the response changes slowly (set by $k_{out}$).

The width of the loop reflects the delay. The enclosed area is the line integral around the closed curve in the concentration-response plane,

but in practice people read the loop qualitatively instead of integrating it. Its direction tells you whether effect lags concentration. An IDR model models the turnover that causes the loop, so you don’t need to quantify the loop itself, and in many cases you don’t need an effect compartment or transit compartments either.

NONMEM implementation

$PK
CL   = THETA(1) * EXP(ETA(1))
V    = THETA(2) * EXP(ETA(2))
KOUT = THETA(3) * EXP(ETA(3))
R0   = THETA(4) * EXP(ETA(4))
IMAX = THETA(5)
IC50 = THETA(6)
KIN  = R0 * KOUT        ; baseline constraint, so R0 is estimated directly
S1   = V
A_0(2) = R0         ; start the response at baseline

$DES
; Concentration must be formed here, not in $PK, because it changes at
; every integration step.
CONC = A(1)/V
DADT(1) = -(CL/V)*A(1)
DADT(2) = KIN*(1 - (IMAX*CONC)/(IC50 + CONC)) - KOUT*A(2)

$ERROR
IPRED = A(2)
Y = IPRED*(1 + ERR(1)) + ERR(2)

A(1) is the drug amount, A(2) is the response, KIN and KOUT are the turnover parameters, and IMAX and IC50 describe the drug’s inhibition.

Two details matter. The response compartment has to be initialized at baseline (A_0(2) = R0 in $PK); otherwise the model starts from zero and spends the first part of the profile climbing up to baseline. And writing $k_{in}$ as $R_0 \cdot k_{out}$ means the baseline is estimated directly, which is better identified and easier to interpret than estimating $k_{in}$ by itself.

Why use them over direct response models

The model describes an actual biological process (turnover) instead of just fitting a curve. $k_{in}$ and $k_{out}$ have physiological meaning, which helps when extrapolating to other dosing regimens and patient populations. The delay is accounted for without extra compartments. And onset delays, recovery times and steady-state relationships can be read straight from the parameters.

Choosing between the four

Picking one of the four models comes down to knowledge of the drug’s mechanism, looking at concentration-effect plots, statistical comparison by objective function value (OFV) or information criteria (AIC, BIC), and goodness of fit, including visual predictive checks (VPC) and prediction-corrected VPC.

Useful diagnostic plots:

• Concentration-time profiles
• Response-time profiles
• Concentration-response plots (hysteresis loops)
• Individual fits and residuals

Where they’ve been used

• Anticoagulants (warfarin, direct thrombin inhibitors)
• Hormone therapies (erythropoietin, growth hormone)
• Immunosuppressants (corticosteroids, calcineurin inhibitors)
• Cardiovascular drugs (ACE inhibitors, beta-blockers)
• Oncology (biomarker responses to targeted therapies)

Summary

IDR models describe delayed PD effects through the turnover of an endogenous mediator. Because the structure follows the biology, they tend to predict better than empirical direct response models, and they’re the standard choice when there’s a lag between exposure and response, especially where biomarker dynamics drive clinical decisions.

In paediatrics the limit is usually blood volume rather than the model. A neonate can’t give twelve samples, and parents won’t consent to a study that asks for them. So the question becomes: if we can take four samples, which four?

That’s an optimisation problem with a clear objective. The Fisher information matrix describes how much the data will tell you about the parameters. A D-optimal design maximises its determinant, which is the same as minimising the volume of the joint confidence region around the parameter estimates. PopED evaluates that criterion for a population model and searches over sampling times, doses and group sizes.

One caveat first: the optimal design depends on the model and the parameter values you assume. If the prior estimates are badly off, the design is optimal for the wrong model, so how well a design holds up under parameter misspecification matters as much as its nominal efficiency.

Model

One-compartment oral model with first-order absorption, dosed to steady state. Clearance and volume have between-subject variability and absorption doesn’t, which is a common simplification when absorption is poorly identified from sparse data.

library(PopED)
library(ggplot2)
library(dplyr)
library(viridis)

sfg <- function(x, a, bpop, b, bocc) {
  parameters <- c(
    CL = bpop[1] * exp(b[1]),
    V = bpop[2] * exp(b[2]),
    KA = bpop[3],
    DOSE = a[1],
    TAU = a[2]
  )
  return(parameters)
}

# One-compartment oral, multiple dose. The two bracketed ratios are the
# accumulation terms. Without them this is the single-dose solution, and
# using TAU and N without them quietly models every dose in isolation.
ff <- function(model_switch, xt, parameters, poped.db) {
  with(as.list(parameters), {
    N  <- floor(xt/TAU) + 1
    KE <- CL/V
    y  <- (DOSE/V) * (KA/(KA - KE)) *
      (exp(-KE * (xt - (N - 1) * TAU)) * (1 - exp(-N * TAU * KE)) / (1 - exp(-TAU * KE)) -
       exp(-KA * (xt - (N - 1) * TAU)) * (1 - exp(-N * TAU * KA)) / (1 - exp(-TAU * KA)))
    return(list(y = y, poped.db = poped.db))
  })
}

feps <- function(model_switch, xt, parameters, epsi, poped.db) {
  returnArgs <- ff(model_switch, xt, parameters, poped.db)
  y <- returnArgs[[1]]
  poped.db <- returnArgs[[2]]

  y <- y * (1 + epsi[, 1]) + epsi[, 2]
  return(list(y = y, poped.db = poped.db))
}

The residual error is combined proportional and additive. This matters: with a purely proportional error the optimiser will put samples in the terminal tail where concentrations are near zero, because the relative error there is the same. The additive part stops that.

Design space

poped.db <- create.poped.database(
  ff_fun = ff,
  fg_fun = sfg,
  fError_fun = feps,
  bpop = c(CL = 2.5, V = 15, KA = 1.5),
  d = c(CL = 0.3, V = 0.25),
  sigma = c(prop = 0.2, add = 0.1),
  notfixed_sigma = c(1, 1),
  m = 2,
  groupsize = c(20, 20),
  xt = c(0.5, 2, 6, 12, 24, 48),
  a = c(DOSE = 100, TAU = 6),
  minxt = 0,
  maxxt = 72,
  discrete_xt = list(seq(0, 72, by = 0.5)),
  discrete_a = list(c(50, 75, 100, 125, 150)),
  maxa = c(DOSE = 150, TAU = 12),
  mina = c(DOSE = 50, TAU = 4),
  bUseGrouped_xt = 1,
  # Both groups share one sampling schedule: the six indices repeat across
  # groups. Numbering them 1,1,1,1,1,1,2,2,2,2,2,2 instead would constrain all
  # six times *within* a group to be equal, collapsing the design to a single
  # timepoint per group.
  G_xt = matrix(rep(1:6, 2), nrow = 2, byrow = TRUE),
  ourzero = 0
)

discrete_xt restricts sampling to the half hour. On a continuous scale the optimiser returns times like 3.47 h, which no ward is going to hit, and a design that only works if it’s executed perfectly isn’t much use in practice.

Running the optimisation

output <- poped_optim(poped.db, opt_xt = TRUE, opt_a = FALSE,
                      method = c("ARS", "BFGS"),
                      control = list(iter_max = 50))

plot_model_prediction(poped.db, model_num_points = 500)

ARS (adaptive random search) explores globally and BFGS refines locally. Running them in sequence is the usual pattern because the D-criterion surface has local optima, and a gradient method on its own stays in whichever one it started closest to. Doses are fixed here (opt_a = FALSE) because the clinical protocol set the dose.

Comparing candidate designs

The D-criterion itself is on a scale nobody can interpret. For a protocol team the useful number is efficiency relative to a reference design, i.e. how much information a cheaper design keeps.

compare_designs <- function(poped.db, n_samples = c(3, 4, 5, 6)) {
  results <- data.frame()

  candidate_times <- list(
    "Sparse"   = c(0.5, 6, 24),
    "Moderate" = c(0.5, 2, 6, 12, 24),
    "Dense"    = c(0.5, 1, 2, 4, 6, 12, 18, 24),
    "Optimal"  = as.numeric(output$xt[1, ])
  )

  reference_ofv <- PopED::evaluate_design(poped.db)$ofv

  for (design_name in names(candidate_times)) {
    times <- candidate_times[[design_name]]
    if (!length(times) %in% n_samples) next

    poped.db.tmp <- poped.db
    poped.db.tmp$xt <- matrix(rep(times, 2), nrow = 2, byrow = TRUE)

    # PopED::evaluate_design, not this function -- naming the wrapper
    # evaluate_design() shadows it and makes the call infinitely recursive.
    ofv <- PopED::evaluate_design(poped.db.tmp)$ofv

    results <- rbind(results, data.frame(
      N_Samples = length(times),
      Design    = design_name,
      OFV       = ofv,
      # D-efficiency relative to the reference, normalised by the number of
      # parameters. Comparing raw determinants across designs is meaningless.
      Efficiency = 100 * (ofv / reference_ofv)^(1 / length(poped.db$parameters$bpop))
    ))
  }

  results
}

design_comparison <- compare_designs(poped.db)

p1 <- design_comparison %>%
  ggplot(aes(x = factor(N_Samples), y = Efficiency, fill = Design)) +
  geom_bar(stat = "identity", position = "dodge", alpha = 0.8) +
  geom_hline(yintercept = 100, linetype = "dashed", color = "red") +
  annotate("text", x = 2, y = 105, label = "Reference design",
           color = "red", size = 3) +
  scale_fill_viridis_d(begin = 0.2, end = 0.8) +
  labs(x = "Number of Samples", y = "D-efficiency (%)",
       title = "Design efficiency by number of samples") +
  theme_minimal()

print(p1)

cat("\n=== Optimised sampling schedule ===\n")
cat(sprintf("Times (h): %s\n", paste(round(as.numeric(output$xt[1, ]), 1), collapse = ", ")))
cat(sprintf("Samples per patient: %d\n", length(output$xt[1, ])))
cat("\nEfficiency of candidate designs, relative to the reference:\n")
print(design_comparison[, c("Design", "N_Samples", "Efficiency")], row.names = FALSE)

Reading the result

I look at the shape of the efficiency curve more than any single number. It’s usually steep at the low end and flat at the top: going from three samples to five gains a lot, and going from six to eight gains very little. The flat part is what to show a protocol team, since those extra draws cost the patient something and add almost no precision.

Two caveats to mention whenever these results are presented:

• The design is conditional on the assumed parameters. Before committing, re-evaluate the chosen design across a plausible range of CL and V. If its efficiency drops off sharply, the design is fragile, and ED-optimality (which averages over a prior on the parameters) is a better criterion.
• D-optimality optimises parameter precision. If the decision depends on a predicted exposure or a probability of target attainment, the criterion should be the precision of that quantity, which gives a different design.

Not covered here: cost functions over sampling windows, ED-optimal designs under parameter uncertainty, and designs optimised for model discrimination instead of parameter precision. PopED supports all three.

A population PK model gives you a typical patient and a description of how much individuals vary around them. But doses are chosen for a population, so what you want to know is what fraction of that population reaches the target on a given regimen.

Monte Carlo simulation answers that. The steps are always roughly:

1. Draw a virtual population with covariates covering the range you actually treat.
2. Draw individual PK parameters for each subject from the model’s between-subject variability.
3. Simulate every subject through each candidate regimen.
4. Summarise across the population as probability of target attainment (PTA), rather than looking at the profile of the average patient.

Step 4 is the one people skip. Checking that the typical patient’s trough clears the target is a much easier question, and it will recommend a dose that fails in about half the population.

Setting up

library(tidyverse)
library(mrgsolve)
library(viridis)
library(patchwork)
library(pracma)   # trapz(), used for AUC below

# mrgsolve's built-in library has no piperacillin model. Point mread() at a
# model file of your own, or start from one of the shipped structural models
# (modlib() provides pk1, pk2, irm1-irm4, emax and others).
mod <- mread("pk2", modlib())

generate_virtual_population <- function(n = 1000, age_range = c(0.5, 18)) {
  age <- runif(n, age_range[1], age_range[2])
  weight <- exp(rnorm(n, log(3.5 * age^0.75), 0.3))
  bsa <- 0.024265 * (weight^0.5378) * ((age * 12)^0.3964)
  crcl <- 0.48 * weight * (140 - age) / (0.7 * 1.0)
  crcl <- pmax(10, pmin(200, crcl))
  
  data.frame(
    ID = 1:n,
    AGE = age,
    WT = weight,
    BSA = bsa,
    CRCL = crcl,
    SEX = sample(c("M", "F"), n, replace = TRUE)
  )
}

run_mc_simulation <- function(model, population, dose_mgkg, interval_hours, n_doses = 4) {
  results <- list()
  
  for (i in 1:nrow(population)) {
    patient <- population[i, ]
    
    CL <- 2.5 * (patient$CRCL/80)^0.75 * (patient$WT/20)^0.75 * 
          exp(rnorm(1, 0, 0.3))
    V <- 15 * (patient$WT/20) * exp(rnorm(1, 0, 0.25))
    
    ev <- ev(amt = dose_mgkg * patient$WT, 
             ii = interval_hours, 
             addl = n_doses - 1)
    
    out <- model %>%
      param(CL = CL, V = V) %>%
      ev(ev) %>%
      mrgsim(end = interval_hours * n_doses, delta = 0.5) %>%
      as.data.frame()
    
    out$ID <- patient$ID
    out$WT <- patient$WT
    out$CRCL <- patient$CRCL
    out$AGE <- patient$AGE
    
    results[[i]] <- out
  }
  
  bind_rows(results)
}

calculate_pta <- function(sim_data, target_threshold, time_window = NULL) {
  if (!is.null(time_window)) {
    sim_data <- sim_data %>%
      filter(time >= time_window[1] & time <= time_window[2])
  }
  
  sim_data %>%
    group_by(ID) %>%
    summarise(
      Cmin = min(CP, na.rm = TRUE),
      Cmax = max(CP, na.rm = TRUE),
      AUC = pracma::trapz(time, CP),
      T_above_target = sum(CP >= target_threshold, na.rm = TRUE) * 0.5,
      PTA = ifelse(Cmin >= target_threshold, 1, 0),
      WT = first(WT),
      CRCL = first(CRCL),
      AGE = first(AGE)
    )
}

evaluate_dosing_regimens <- function(model, population, regimens) {
  results_list <- list()
  
  for (regimen_name in names(regimens)) {
    regimen <- regimens[[regimen_name]]
    
    sim_data <- run_mc_simulation(
      model = model,
      population = population,
      dose_mgkg = regimen$dose,
      interval_hours = regimen$interval,
      n_doses = regimen$n_doses
    )
    
    pta_64 <- calculate_pta(sim_data, target_threshold = 64)
    pta_32 <- calculate_pta(sim_data, target_threshold = 32)
    
    results_list[[regimen_name]] <- list(
      sim_data = sim_data,
      pta_64 = pta_64,
      pta_32 = pta_32,
      regimen = regimen
    )
  }
  
  results_list
}

Choosing the regimens to compare

I keep the candidate regimens close to the current standard of care. The result has to be a recommendation someone can act on, which usually means a small change from what’s already done. The highest regimen here is only there to show where the curve levels off. Check any candidate against the licensed maximum daily dose before quoting it.

population <- generate_virtual_population(n = 2000, age_range = c(1, 12))

regimens <- list(
  "Standard_100mg_6h" = list(dose = 100, interval = 6, n_doses = 4),
  "High_125mg_6h" = list(dose = 125, interval = 6, n_doses = 4),
  "Extended_100mg_8h" = list(dose = 100, interval = 8, n_doses = 3),
  "Intensive_150mg_6h" = list(dose = 150, interval = 6, n_doses = 4)
)

simulation_results <- evaluate_dosing_regimens(mod, population, regimens)

pta_summary <- map_dfr(names(simulation_results), function(regimen_name) {
  result <- simulation_results[[regimen_name]]
  data.frame(
    Regimen = regimen_name,
    Dose_mgkg = result$regimen$dose,
    Interval_h = result$regimen$interval,
    PTA_64 = mean(result$pta_64$PTA),
    PTA_32 = mean(result$pta_32$PTA),
    Mean_Cmin = mean(result$pta_64$Cmin),
    Median_Cmin = median(result$pta_64$Cmin),
    P5_Cmin = quantile(result$pta_64$Cmin, 0.05),
    P95_Cmin = quantile(result$pta_64$Cmin, 0.95)
  )
})

Reading the output

I look at three things, though usually only the first gets reported:

• PTA against the target. The usual acceptance threshold is 90% of the population, but that’s a convention. The threshold should depend on what missing the target costs, which is different for a prophylactic indication and a life-threatening infection.
• The shape of the dose-PTA curve. If attainment is still rising steeply at the chosen dose, the regimen is fragile, and small errors in the assumed PK cause large swings in attainment.
• Who fails. The overall percentage hides which subgroup misses. Plotting trough against weight and renal function (p2 below) can turn “88% attainment” into “attainment is fine except in the augmented-clearance subgroup”, and that leads to a different recommendation.

p1 <- pta_summary %>%
  pivot_longer(cols = c(PTA_64, PTA_32), names_to = "Target", values_to = "PTA") %>%
  mutate(Target = ifelse(Target == "PTA_64", "≥64 mg/L", "≥32 mg/L")) %>%
  ggplot(aes(x = reorder(Regimen, PTA), y = PTA, fill = Target)) +
  geom_bar(stat = "identity", position = "dodge", alpha = 0.8) +
  geom_hline(yintercept = 0.9, linetype = "dashed", color = "red", size = 1) +
  annotate("text", x = 2.5, y = 0.92, label = "Target: 90%", color = "red", fontface = "bold") +
  scale_fill_viridis_d(begin = 0.2, end = 0.8) +
  labs(x = "Dosing Regimen", y = "Probability of Target Attainment",
       title = "PTA Comparison Across Dosing Regimens") +
  coord_flip() +
  theme_minimal() +
  theme(legend.position = "bottom")

p2 <- simulation_results$High_125mg_6h$pta_64 %>%
  ggplot(aes(x = WT, y = Cmin, color = CRCL)) +
  geom_point(alpha = 0.5) +
  geom_hline(yintercept = 64, linetype = "dashed", color = "red") +
  geom_smooth(method = "loess", se = TRUE, color = "blue") +
  scale_color_viridis_c(name = "CrCL\n(mL/min)") +
  labs(x = "Weight (kg)", y = "Trough Concentration (mg/L)",
       title = "Cmin Distribution: 125 mg/kg q6h") +
  theme_minimal()

p3 <- map_dfr(names(simulation_results), function(regimen_name) {
  result <- simulation_results[[regimen_name]]
  result$pta_64 %>%
    mutate(Regimen = regimen_name)
}) %>%
  ggplot(aes(x = Regimen, y = Cmin, fill = Regimen)) +
  geom_violin(alpha = 0.7) +
  geom_boxplot(width = 0.2, outlier.alpha = 0.3) +
  geom_hline(yintercept = 64, linetype = "dashed", color = "red") +
  scale_fill_viridis_d(begin = 0.2, end = 0.8) +
  labs(x = "Dosing Regimen", y = "Trough Concentration (mg/L)",
       title = "Cmin Distribution Across Regimens") +
  theme_minimal() +
  theme(legend.position = "none",
        axis.text.x = element_text(angle = 45, hjust = 1))

p4 <- pta_summary %>%
  ggplot(aes(x = Dose_mgkg, y = PTA_64, color = factor(Interval_h))) +
  geom_point(size = 4, alpha = 0.8) +
  geom_line(aes(group = Interval_h), alpha = 0.5) +
  geom_hline(yintercept = 0.9, linetype = "dashed", color = "red") +
  scale_color_viridis_d(name = "Interval\n(hours)", begin = 0.2, end = 0.8) +
  labs(x = "Dose (mg/kg)", y = "PTA (≥64 mg/L)",
       title = "Dose-Response Relationship") +
  theme_minimal()

combined_plot <- (p1 | p2) / (p3 | p4) +
  plot_annotation(
    title = "Monte Carlo Simulation for Piperacillin Dose Optimization",
    subtitle = "Evaluation of multiple dosing regimens in pediatric population (n=2000)",
    theme = theme(plot.title = element_text(size = 16, face = "bold", hjust = 0.5),
                  plot.subtitle = element_text(size = 12, hjust = 0.5, color = "grey40"))
  )

print(combined_plot)

optimal_regimen <- pta_summary %>%
  filter(PTA_64 >= 0.9) %>%
  arrange(Dose_mgkg) %>%
  slice_head(n = 1)

cat("\n=== Optimal Dosing Regimen ===\n")
cat(sprintf("Regimen: %s\n", optimal_regimen$Regimen))
cat(sprintf("Dose: %d mg/kg\n", optimal_regimen$Dose_mgkg))
cat(sprintf("Interval: %d hours\n", optimal_regimen$Interval_h))
cat(sprintf("PTA (≥64 mg/L): %.1f%%\n", optimal_regimen$PTA_64 * 100))
cat(sprintf("Mean Cmin: %.1f mg/L\n", optimal_regimen$Mean_Cmin))
cat(sprintf("5th-95th Percentile Cmin: %.1f - %.1f mg/L\n", 
            optimal_regimen$P5_Cmin, optimal_regimen$P95_Cmin))

If only the modeller can run a population model, it doesn’t do much for patients. The people making dosing decisions can’t install NONMEM and shouldn’t have to. A small interactive app lets them change the inputs they already think in (weight, renal function, dose, interval) and see the result straight away.

Two things decide whether an app like this gets used:

• Use the inputs clinicians think in, not the model’s parameters. Nobody on a ward wants to set a clearance. They want to enter a weight and a creatinine clearance and see what happens to the trough.
• Show the spread. A single median profile makes the prediction look exact. Showing variability across simulated patients is a fairer picture of what a population model says, and usually more useful for a dosing decision.

The app follows the usual Shiny layout: a ui object for the layout, a server function with the simulation logic, and a reactive expression so the model only re-runs when an input changes.

The code

library(shiny)
library(shinydashboard)
library(plotly)
library(DT)
library(dplyr)
library(ggplot2)
library(mrgsolve)

# mrgsolve ships no piperacillin model; modlib() provides generic
# structures (pk1, pk2, irm1-irm4, emax). Swap in your own model file
# with mread("mymodel", project = "models").
mod <- mread("pk2", modlib())

ui <- dashboardPage(
  dashboardHeader(title = "Piperacillin PK Simulation Dashboard"),
  dashboardSidebar(
    sidebarMenu(
      menuItem("Simulation", tabName = "simulation", icon = icon("flask")),
      menuItem("Dose Optimization", tabName = "dosing", icon = icon("pills")),
      menuItem("Target Attainment", tabName = "pta", icon = icon("bullseye")),
      menuItem("Patient Profiles", tabName = "profiles", icon = icon("user-md"))
    ),
    hr(),
    h4("Patient Parameters", style = "padding-left: 15px;"),
    numericInput("weight", "Weight (kg)", value = 20, min = 5, max = 100, step = 0.1),
    numericInput("age", "Age (years)", value = 5, min = 0.1, max = 18, step = 0.1),
    numericInput("crcl", "Creatinine Clearance (mL/min)", value = 80, min = 10, max = 200, step = 1),
    selectInput("dose", "Dose (mg/kg)", choices = c(50, 75, 100, 125, 150), selected = 100),
    selectInput("interval", "Dosing Interval (hours)", choices = c(4, 6, 8, 12), selected = 6),
    numericInput("n_sims", "Number of Simulations", value = 1000, min = 100, max = 10000, step = 100),
    actionButton("run_sim", "Run Simulation", class = "btn-primary", style = "width: 100%;")
  ),
  dashboardBody(
    tags$head(
      tags$style(HTML("
        .content-wrapper { background-color: #f4f4f4; }
        .box { border-radius: 5px; }
        .info-box { border-radius: 5px; }
      "))
    ),
    tabItems(
      tabItem(tabName = "simulation",
        fluidRow(
          infoBox("AUC0-24", textOutput("auc"), icon = icon("chart-area"), color = "blue", width = 4),
          infoBox("Cmax", textOutput("cmax"), icon = icon("arrow-up"), color = "green", width = 4),
          infoBox("Cmin", textOutput("cmin"), icon = icon("arrow-down"), color = "red", width = 4)
        ),
        fluidRow(
          box(
            title = "Concentration-Time Profile", status = "primary", solidHeader = TRUE,
            width = 12, height = 500,
            plotlyOutput("conc_plot", height = "450px")
          )
        ),
        fluidRow(
          box(
            title = "Simulation Summary Statistics", status = "info", solidHeader = TRUE,
            width = 12,
            DT::dataTableOutput("summary_table")
          )
        )
      ),
      tabItem(tabName = "dosing",
        fluidRow(
          box(
            title = "Dose-Exposure Relationship", status = "primary", solidHeader = TRUE,
            width = 6,
            plotlyOutput("dose_response", height = "400px")
          ),
          box(
            title = "Optimal Dosing Recommendations", status = "success", solidHeader = TRUE,
            width = 6,
            h4("Recommended Regimen:", style = "color: #3c763d;"),
            verbatimTextOutput("optimal_dose"),
            hr(),
            h5("Rationale:"),
            textOutput("dose_rationale")
          )
        ),
        fluidRow(
          box(
            title = "Dosing Regimen Comparison", status = "warning", solidHeader = TRUE,
            width = 12,
            plotlyOutput("regimen_comparison", height = "400px")
          )
        )
      ),
      tabItem(tabName = "pta",
        fluidRow(
          box(
            title = "Probability of Target Attainment", status = "primary", solidHeader = TRUE,
            width = 12,
            plotlyOutput("pta_plot", height = "500px")
          )
        ),
        fluidRow(
          box(
            title = "PTA Summary by Dosing Regimen", status = "info", solidHeader = TRUE,
            width = 12,
            DT::dataTableOutput("pta_table")
          )
        )
      ),
      tabItem(tabName = "profiles",
        fluidRow(
          box(
            title = "Virtual Patient Population", status = "primary", solidHeader = TRUE,
            width = 12,
            DT::dataTableOutput("patient_table")
          )
        ),
        fluidRow(
          box(
            title = "Covariate Effects on PK Parameters", status = "success", solidHeader = TRUE,
            width = 6,
            plotlyOutput("covariate_cl", height = "350px")
          ),
          box(
            title = "Covariate Effects on Vd", status = "success", solidHeader = TRUE,
            width = 6,
            plotlyOutput("covariate_vd", height = "350px")
          )
        )
      )
    )
  )
)

server <- function(input, output, session) {
  
  sim_results <- eventReactive(input$run_sim, {
    withProgress(message = "Running simulations...", value = 0, {
      setProgress(0.2, detail = "Preparing patient parameters")
      
      patient_params <- data.frame(
        ID = 1:input$n_sims,
        WT = rnorm(input$n_sims, input$weight, input$weight * 0.2),
        AGE = rnorm(input$n_sims, input$age, input$age * 0.15),
        CRCL = rnorm(input$n_sims, input$crcl, input$crcl * 0.25)
      ) %>%
        mutate(
          WT = pmax(5, pmin(100, WT)),
          AGE = pmax(0.1, pmin(18, AGE)),
          CRCL = pmax(10, pmin(200, CRCL))
        )
      
      setProgress(0.4, detail = "Simulating PK profiles")
      
      dose_mg <- input$dose * patient_params$WT
      
      sim_data <- lapply(1:input$n_sims, function(i) {
        ev <- ev(amt = dose_mg[i], ii = as.numeric(input$interval), addl = 3)
        out <- mod %>%
          param(CL = 2.5 * (patient_params$CRCL[i]/80)^0.75 * (patient_params$WT[i]/20)^0.75,
                V = 15 * (patient_params$WT[i]/20)) %>%
          ev(ev) %>%
          mrgsim(end = 24, delta = 0.5) %>%
          as.data.frame()
        out$ID <- i
        out$WT <- patient_params$WT[i]
        out$CRCL <- patient_params$CRCL[i]
        return(out)
      }) %>%
        bind_rows()
      
      setProgress(0.8, detail = "Calculating PK metrics")
      
      pk_metrics <- sim_data %>%
        group_by(ID) %>%
        summarise(
          AUC = pracma::trapz(time, CP),
          Cmax = max(CP, na.rm = TRUE),
          Cmin = min(CP[time >= 18], na.rm = TRUE),
          Tmax = time[which.max(CP)],
          WT = first(WT),
          CRCL = first(CRCL)
        )
      
      setProgress(1.0, detail = "Complete")
      
      list(sim_data = sim_data, pk_metrics = pk_metrics, patient_params = patient_params)
    })
  })
  
  output$conc_plot <- renderPlotly({
    results <- sim_results()
    if (is.null(results)) return(NULL)
    
    p <- results$sim_data %>%
      filter(ID <= 10) %>%
      ggplot(aes(x = time, y = CP, group = ID, color = factor(ID))) +
      geom_line(alpha = 0.7) +
      geom_hline(yintercept = 64, linetype = "dashed", color = "red", alpha = 0.7) +
      annotate("text", x = 20, y = 70, label = "Target: 64 mg/L", color = "red") +
      labs(x = "Time (hours)", y = "Concentration (mg/L)",
           title = "Concentration-Time Profiles (Sample of 10 patients)") +
      theme_minimal() +
      theme(legend.position = "none")
    
    ggplotly(p, tooltip = c("time", "CP", "ID"))
  })
  
  output$auc <- renderText({
    results <- sim_results()
    if (is.null(results)) return("--")
    paste0(round(mean(results$pk_metrics$AUC, na.rm = TRUE), 1), " mg·h/L")
  })
  
  output$cmax <- renderText({
    results <- sim_results()
    if (is.null(results)) return("--")
    paste0(round(mean(results$pk_metrics$Cmax, na.rm = TRUE), 1), " mg/L")
  })
  
  output$cmin <- renderText({
    results <- sim_results()
    if (is.null(results)) return("--")
    paste0(round(mean(results$pk_metrics$Cmin, na.rm = TRUE), 1), " mg/L")
  })
  
  output$summary_table <- DT::renderDataTable({
    results <- sim_results()
    if (is.null(results)) return(NULL)
    
    results$pk_metrics %>%
      summarise(
        Metric = c("AUC (mg·h/L)", "Cmax (mg/L)", "Cmin (mg/L)"),
        Mean = c(mean(AUC), mean(Cmax), mean(Cmin)),
        Median = c(median(AUC), median(Cmax), median(Cmin)),
        `5th Percentile` = c(quantile(AUC, 0.05), quantile(Cmax, 0.05), quantile(Cmin, 0.05)),
        `95th Percentile` = c(quantile(AUC, 0.95), quantile(Cmax, 0.95), quantile(Cmin, 0.95))
      ) %>%
      DT::datatable(options = list(pageLength = 10, dom = 't'), rownames = FALSE) %>%
      DT::formatRound(columns = 2:5, digits = 2)
  })
  
  output$dose_response <- renderPlotly({
    results <- sim_results()
    if (is.null(results)) return(NULL)
    
    dose_range <- seq(50, 150, by = 25)
    dose_effects <- data.frame(
      Dose = rep(dose_range, each = input$n_sims),
      AUC = NA,
      Cmin = NA
    )
    
    p <- results$pk_metrics %>%
      ggplot(aes(x = WT, y = AUC, color = CRCL)) +
      geom_point(alpha = 0.6) +
      geom_smooth(method = "loess", se = TRUE, color = "blue") +
      scale_color_viridis_c(name = "CrCL\n(mL/min)") +
      labs(x = "Weight (kg)", y = "AUC (mg·h/L)",
           title = "AUC vs Body Weight (colored by Creatinine Clearance)") +
      theme_minimal()
    
    ggplotly(p)
  })
  
  output$optimal_dose <- renderText({
    results <- sim_results()
    if (is.null(results)) return("Run simulation first")
    
    target_pta <- results$pk_metrics %>%
      mutate(PTA = ifelse(Cmin >= 64, 1, 0)) %>%
      summarise(PTA = mean(PTA))
    
    if (target_pta$PTA >= 0.9) {
      paste0(input$dose, " mg/kg every ", input$interval, " hours\n",
             "PTA: ", round(target_pta$PTA * 100, 1), "%")
    } else {
      recommended_dose <- input$dose * 1.25
      paste0("Consider: ", round(recommended_dose, 0), " mg/kg every ", input$interval, " hours\n",
             "Current PTA: ", round(target_pta$PTA * 100, 1), "%")
    }
  })
  
  output$pta_plot <- renderPlotly({
    results <- sim_results()
    if (is.null(results)) return(NULL)
    
    pta_data <- results$pk_metrics %>%
      mutate(
        PTA_64 = ifelse(Cmin >= 64, 1, 0),
        PTA_32 = ifelse(Cmin >= 32, 1, 0)
      ) %>%
      group_by(WT = cut(WT, breaks = seq(5, 100, by = 10))) %>%
      summarise(
        PTA_64 = mean(PTA_64),
        PTA_32 = mean(PTA_32),
        .groups = 'drop'
      )
    
    p <- pta_data %>%
      pivot_longer(cols = c(PTA_64, PTA_32), names_to = "Target", values_to = "PTA") %>%
      ggplot(aes(x = WT, y = PTA, fill = Target)) +
      geom_bar(stat = "identity", position = "dodge") +
      geom_hline(yintercept = 0.9, linetype = "dashed", color = "red") +
      scale_fill_manual(values = c("PTA_64" = "#667eea", "PTA_32" = "#764ba2"),
                       labels = c("PTA_64" = "≥64 mg/L", "PTA_32" = "≥32 mg/L")) +
      labs(x = "Weight Category (kg)", y = "Probability of Target Attainment",
           title = "PTA by Weight Category") +
      theme_minimal() +
      theme(axis.text.x = element_text(angle = 45, hjust = 1))
    
    ggplotly(p)
  })
  
  output$patient_table <- DT::renderDataTable({
    results <- sim_results()
    if (is.null(results)) return(NULL)
    
    results$patient_params %>%
      DT::datatable(options = list(pageLength = 15, scrollX = TRUE)) %>%
      DT::formatRound(columns = c("WT", "AGE", "CRCL"), digits = 2)
  })
  
  output$covariate_cl <- renderPlotly({
    results <- sim_results()
    if (is.null(results)) return(NULL)
    
    p <- results$pk_metrics %>%
      ggplot(aes(x = CRCL, y = AUC, color = WT)) +
      geom_point(alpha = 0.6) +
      geom_smooth(method = "lm", se = TRUE, color = "blue") +
      scale_color_viridis_c(name = "Weight\n(kg)") +
      labs(x = "Creatinine Clearance (mL/min)", y = "AUC (mg·h/L)",
           title = "Effect of Renal Function on Exposure") +
      theme_minimal()
    
    ggplotly(p)
  })
  
  output$covariate_vd <- renderPlotly({
    results <- sim_results()
    if (is.null(results)) return(NULL)
    
    p <- results$pk_metrics %>%
      ggplot(aes(x = WT, y = Cmax, color = CRCL)) +
      geom_point(alpha = 0.6) +
      geom_smooth(method = "loess", se = TRUE, color = "green") +
      scale_color_viridis_c(name = "CrCL\n(mL/min)") +
      labs(x = "Weight (kg)", y = "Cmax (mg/L)",
           title = "Effect of Body Size on Peak Concentration") +
      theme_minimal()
    
    ggplotly(p)
  })
}

shinyApp(ui = ui, server = server)

Exposure-response (E-R) analysis puts numbers on the relationship between drug exposure metrics and clinical or biomarker endpoints. It’s used for choosing doses, finding exposure targets, and supporting individualized dosing.

A plain concentration-effect plot can show hysteresis. E-R analysis instead works with summary exposure metrics (area under the concentration-time curve (AUC), trough concentration ($C_{min}$), peak concentration ($C_{max}$)) and relates them to outcomes measured over a suitable time window.

Exposure metrics

AUC is total drug exposure over a dosing interval or treatment period:

or at steady state:

where $\tau$ is the dosing interval and $CL$ is clearance.

The trough ($C_{min}$) is the concentration at the end of a dosing interval:

where $k = CL/V$ is the elimination rate constant.

The peak ($C_{max}$) is the maximum concentration after a dose:

For antimicrobials, time above the minimum inhibitory concentration ($T_{>MIC}$) is often used:

Model structures

Linear

The simplest assumes a straight line:

where:

• $E$ = response endpoint
• $E_0$ = baseline response
• $\alpha$ = slope parameter
• $Exposure$ = AUC, $C_{min}$, or other metric

Log-linear

Often a better fit when exposure spans orders of magnitude:

or equivalently:

where $Exposure_{ref}$ is a reference exposure value.

Emax

A sigmoidal curve with a saturating response:

where:

• $E_{max}$ = maximum drug effect
• $EC_{50}$ = exposure producing 50% of maximum effect
• $\gamma$ = Hill coefficient (steepness of curve)