Everyday Is A School Day

Learning Chromosomal AmpC beta-lactamase Producing Organisms And Its Mechanics

Thu, 02 Apr 2026 00:00:00 +0000

🦠 Made up my own memory tricks — Gatekeeper, Dumpster, Repressor — to understand AmpC mechanics. Discovered Serratia has 2 recyclers (AmpD + AmiD2) making derepression harder, and E. coli lacks AmpR so AmpC stays silent! Probably not textbook, but it helped me learn 🙌

AmpC beta-lactamase of Enterobacter cloacae generated by AlphaFold and ChimeraX

Motivations

We’ve learnt about ESBL and CRE. Let’s explore AmpC mechanics. This is going to be interesting because it’s not a straightforward constitutive gene that produces via plasmid. It contains downstream mechanics that controls (aka repress) the AmpC gene (in chromosome). Let’s take a look ourselves! Here we will also use some associative terms that we understand to solidify our understanding and the actual mechanics. Let’s go!

Disclaimer

I am not a microbiologist. This is purely for educational purpose. Also, please take note that my lingo preference of AmpG (Gatekeeper), AmpD (Dumpster), AmpR (Repressor) is purely for my own memory association and its function, not a true scientific label. If some of them are as such, it’s pure coincidence.

Objectives:

How Is AmpC So Different From Other Beta-lactamase Genes?

This is an interesting bit about class C beta-lactamase AmpC, even though the gene exists, it’s actually repressed and regulated by a few other genes. Let’s take a look.

AmpG : inner membrane permease that transports anhydromuropeptides (cell wall breakdown products) from the periplasm into the cytoplasm. So, let’s say beta lactam antibiotic increases the cell wall breakdown, we get a lot of these products. This protein then transports these prodcuts into cytoplasm. To remember all these code words, let’s think of AmpG as gatekeeper.

AmpD : cytoplasmic amidase that recycles these anhydromuropeptides back into the cell wall synthesis pathway. Wow, it’s a recycler! Let’s think of AmpD as dumpster.

AmpR : transcriptional regulator that controls ampC gene expression, but when it binds anhydromuropeptides, it switches from a repressor to an activator. So, it’s a switch that can turn on ampC production when it senses the signal of cell wall stress (the anhydromuropeptides). Just imagine that if there is an increase in cell wall destruction, our AmpD cannot efficiently recycler all those byproducts, these byproducts then are able to bind to AmpR, hence essentially turning AmpR into an activator and hence AmpC beta-lactamase would be transcribed. Let’s think of AmpR as repressor.

The above natural mechanics is called induction, which is a reversible process. When you remove the antibiotic, the cell wall stress goes away, AmpD can catch up with recycling, the anhydromuropeptides are cleared, AmpR returns to repressor mode, and AmpC production stops. There is another mechanics that involves mutation of AmpD, rendering it useless in recycling, or mutation of AmpR, rendering it permanently in activator mode. This is called derepression, which is an irreversible process. The mutation is in the DNA, and it’s passed to all daughter cells, hence you get constitutive high-level production of AmpC beta-lactamase regardless of whether antibiotic is present or not. 🙌

There is a lot of cartoons out there that help to depict the process above. Let’s view one of them from A Primer on AmpC β-Lactamases: Necessary Knowledge for an Increasingly Multidrug-resistant World

Note that this blog does not touch on plasmid-mediated class C beta-lactamase. We’re only looking at chromosomal genes. It’s important to note this because plasmid-mediated AmpC can be transferred between organisms, whereas chromosomal AmpC is generally not transferable and is regulated by the host’s genetic machinery. In other words, there is usually no proteins that repress the expression of plasmid-mediated AmpC, hence the presence of plasmid-mediated AmpC is usually associated with high level of beta-lactam resistance. Whereas with chromosomal AmpC, the presence of the gene does not necessarily mean high level of beta-lactam resistance, because it may be repressed and regulated by the host’s genetic machinery.

Look at IDSA AMR Guideline 2024 Section 2: AmpC β-Lactamase-Producing Enterobacterales for other references of why these bacteria produce AmpC beta lactamase and the types. Very informative! From clinical standpoint, the derepressed AmpC (mutation of AmpD or AmpR where AmpC gene is always activated) or plasmid-mediated AmpC will usually prefer itself phenotypically, hence we usually would know from susceptibility testing. The tricky part is the inducible portion, because phenotypically it will show that it is ceftriaxone susceptible, but when ceftriaxone is used, it will induce AmpC beta lactamase production rendering ceftriaxone resistance. Though we don’t have to worry too much of this nowadays because most lab would automatically hide these antibiotics regardless of the susceptibility. 🙌 Maybe not in uncomplicated UTI isolates? But, we have to beware that basal production of AmpC beta-lactamase renders these organisms intrinsically resistant to ampicillin, amoxicillin-clavulanate, and 1st and 2nd generation cephalosporins.

Let’s Take A Look At NCBI

Alright, now that we’ve got some basics of the regulatory mechanisms, let’s look at where to find the actual genes in NCBI.

Go to NCBI Genome.
Look for Enterobacter cloacae.
Select the reference gene
Select View Annotated Genes.
On filter, type “amp”. And we’ll see.

Alright! All those AmpG (Gatekeeper), AmpD (Dumppster), AmpR (Repressor) protein genes are there! 🙌 Now let’s take a look at AmpC Beta Lactamase by looking for lactamase.

Notice that it didn’t say ampC but this is the class C beta-lactamase that comes with reference E. cloacae.

Also, note that Usually the AmpC beta-lactamase gene is adjacent to AmpR gene and in opposite direction. Take a look at their position and orientation. 🤔 The end of CMH class C beta lactamase is 405766, the beginning of AmpR is 405899. And their orientations are opposite as well! 🙌 Let’s take a look at another Enterobacter cloacae complex.

Looking at Enterobacter asburiae.

Notice the Ampc-AmpR positions and orientation? Same same? 🙌

What Are The Typical Organisms Of Clinical Significance?

According IDSA AMR Guidelines, Enterobacter cloacae complex, Klebsiella aerogenes, and Citrobacter freundii (we’ll call it the big 3) are the most common Enterobacterales at moderate risk for clinically significant inducible AmpC production. Clinical reports suggest that the emergence of resistance after exposure to an agent like ceftriaxone may occur in approximately 20% of infections caused by these organisms. Other organisms such as Serratia marcescens, Morganella morganii, and Providencia spp., are significantly less likely to overexpress ampC based on both in vitro analysis. Other less common pathogen such as Hafnia alvei, Citrobacter youngae, Yersinia enterocolitica that carry inducible chromosomal ampC genes do not have too robust of data to support or refute the risk of ampC induction.

Interestingly when reading IDSA AMR Guidelines, citrobacter koseri does not have ampC beta-lactamase, let’s verify this on NCBI. Wow, it’s true! It has class A beta-lactamase, not class C! Also, we need to note that, just because certain organisms have class C beta-lactamase gene, it doesn’t mean it will be overexpressed. It is also quite interesting that even with the right machinery like the big 3, it’s ~20% of infections with emergence of resistance, interesting… 🤔 but why? What happened to the other 80%? Also, we’ll see other examples below of other low risk organisms.

Why Is It That Serratia marcescens Not a High Risk for AmpC?

Why Serratia Marcensens has all the genes but yet not a high risk ampC depression? Apparently, S. marcescens has 2 amidohydrolases (ampD and amiD2) and the deletion of both of these 2 is necessary for AmpC de-repression! Two dumpster proteins! Alright, let’s find it if we can! Here, they used Serratia marcescens ATCC 13880.

Umm, OK, we see AmpD, but there are a lot of other amidase and we do not see AmiD2 as stated from the paper. Highlighted in red are AmpD and amidases that were not labeled specifically, maybe it’s one of them?

Thankfully the paper provided forward and reverse primer for deletion of amiD2. This means that the primers are designed to exclude the amiD2 gene. Hence, if we use the 5’ primer as a forward primer, and then the 3’ primer as a reverse primer, we should be able to locate the positions of amiD2 which should be in bettween or around the vicinity. Let’s see which one this is.

library(Biostrings)
library(tidyverse)

genome <- readDNAStringSet(
  "smatcc/ncbi_dataset/data/GCA_017654245.1/GCA_017654245.1_ASM1765424v1_genomic.fna"
)                                                                             
chr <- genome[1]

fwd <- DNAString("CGTAAAGTCCCTCTCTCGCT")                          
rev <- DNAString("ATGCCGAAACCGCCGCCGTT")                          
rev_rev <- reverseComplement(rev)

(fwd_hits <- vmatchPattern(fwd, chr, max.mismatch = 0))           
(rev_hits <- vmatchPattern(rev_rev, chr, max.mismatch = 0))

Awesome! We see that we have EXACT match for forward primer on our sequence, which makes sense because it should bind to the minus strand and move rightward to make copies away from the active gene amiD. Then the reverse gene should bind to plus strand (our sequence) and copy leftward. This also make sense because according to the picture above of al the annotated amidase. Let’s interpret this, our gene should be between the higher and lower positions of these 2 patterns 5035405 and 5036140. Alright! We do have one that is between or around this vicinity! We found it!

Huzzah! So Serratia marcenses do have 2 recylcers! Cool! 😎 Let’s use AlphaFold to visualize them side by side. Left is AmpD, right is AmiD2.

Wow, they look very different! Maybe?

Note: After much poking around, with the help of multiple Claude chats and probes, we finally found out that the primers were actually to exclude the gene as opposed to make copies of the gene. Which makes total sense! Because the forward primer binds to the minus strand (the strand that carries the amiD2 gene) and it seems to copy rightward away from the gene. Took me a while to figure out why that is! Also, conventionally, all fasta are in plus strand. Hence we were able to use this information to identify AmiD2 gene! 🙌

Now, let’s take a look at other organisms that we normally don’t think of AmpC related.

Let’s Look At Ecoli

Now, we’ve looked at Enterobacter Cloaecae complex and verified that they do have all the machinery and AmpC to produce the enzyme. What about Ecoli? It can’t have it, right? Else we should be hearing more about this. Let’s take a look at one of the Ecoli reference gene.

WAHTHTHAT ?! they have these genes too !?!? AmpG, AmpD, AmpC too !?!?! I’m so confused !!! 😵‍💫

Looking at the literature, apparently they lack AmpR which is the switch that turns on the production of AmpC. So, even though they have AmpC gene, they do not have the machinery to turn it on. Hence, they do not produce clinically significant amount of AmpC beta-lactamase. Wow! Very interesting!

Cefepime and AmpC Beta-Lactamase

Cefepime is the preferred antibiotics for AmpC producing organisms. Does that mean that there should be a low or no affinity of AmpC to Cefepime? Let’s perform some molecular dynamic simulation on this! Code not documents, but approach is the same as this and this

Looking at all of the plots above it looks like AmpC beta-lactamase binds to Cefepime !!! 🤔 So I was wrong! Looking at the literature, in fact, AmpC beta-lactamase can bind to Cefepime and form a rather stable acyl enzyme complexes that make it relatively resistant to hydrolysis compared to other cephalosporins! Wow, how about that! This is very interesting! Also a fun learning too! Wait a minute, does that also mean it occupies the AmpC Beta-lactamases rendering them inactivate against other cephalosporins !?! Unfortunately not, these bonds will eventually undergo deacylation making the enzymes free again for binding. Also Cefepime is a weak AmpC inducer. What does that actually mean?

What Does It Mean That Cefepime Is A Weak AmpC Inducer?

This means that Cefepime is less likely to trigger the induction of AmpC beta-lactamase production compared to other cephalosporins. Does that mean whatever mechanism cefepime acts on the cell wall, with whatever downstream effect to have less products that trigger AmpR derepression? Does antibiotics affecting PBP4 has anything to do with this? Cefepime acts on PBP1-4, could that be why it’s a weak inducer? 🤷‍♂️ What do you think?

How Similar Are The Genes for AmpG/D/R Between Species?

You know how when we assess CTX-M-15, KPC-1, they all share the same nucleotide sequence and hence we can perform exact match on any bacteria to see if they possess such genetic element? I wonder if that’s the case for AmpG, AmpD, AmpR? Or do they have different sequences in different organisms? Let’s look at heatmap.

sample code

library(pwalign)

gene <- c("ampG","ampD","ampR")

for (gene_i in gene) {
ampd <- readDNAStringSet(paste0(gene_i".fasta"))
  mat <- matrix(0, nrow = 13, ncol = 13)
  for (i in 1:13) {
    for (j in 1:13) {
      pair <- pairwiseAlignment(ampd[i], ampd[j])
      mat[i,j] <- pair@score
    }
  }
  
  rownames(mat) <- names(ampd)
  colnames(mat) <- names(ampd)
  heatmap(mat, symm = T)
}

AmpG

AmpD

AmpR

Interpretation

Wow, they are in fact very different! Let’s focus on cloacae and ludwigii. They appear to cluster together on AmpG and AmpD, but look at AmpR, they are not! We can genus clusters together, citrobacter freundii and klebsiella aerogenes are closer to each other than enterobacter cloacae complex. Even if they are close, they’re relatively far apart. This is fascinating because even though they are labeled as the same protein (e.g. AmpG), they are different in nucleotides! This means that if we want to do an exact match for AmpG, we may not be able to use the same sequence for different organisms. We may have to use different sequences for different organisms. And of course, this includes AmpC beta lactamases. This is very interesting! This also means that if we’re attempting to locate or annotate such protein producing genes, we need species specific reference and can’t just pull an off the shelf sequence for annotation or detection. Very different from our prior plasmids experiences.

Opportunities For Improvement

learn about AmpE, AmpH, AmpF?
learn about porin mutation next
learn the different type of PBPs and the antibiotics that bind to them and which organisms contain these PBPs.

Lessons learnt

apparently some AmpR genes were not annotated as such, but it seems like majority are adjacent to ampC gene.
learnt how to put image side by side
learnt the direction of forward and reverse primers
AmpC beta-lactamase can bind to Cefepime and form a rather stable acyl enzyme complexes that make it relatively resistant to hydrolysis compared to other cephalosporins
learnt citrobacter koseri doesn’t actually possess class C beta-lactamase!
learnt Serratia marsecens has 2 recyclers (AmpD and AmiD2)!
learnt AmpC mechanics and its genes/proteins are species specific if we want to detect or annotate.

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Navigating Financial Statement And The Story It Tells Us - A Note To Myself

Sun, 29 Mar 2026 00:00:00 +0000

📊 Dipping my toes into financial statements — income, balance sheet & cash flow. Still don’t fully get it, but slowly piecing together the story these numbers tell. Warren Buffett makes it look easy 😅 Baby steps! 🌱

Motivations

I’ve always wanted to learn financial statement, what it means, what it tells us, what Warren Buffett sees in them. Following the book Warren Buffett and the Interpretation of Financial Statements: The Search for the Company with a Durable Competitive Advantage and Datacamp: Analyzing Financial Statement in Python, I’ve made some notes for myself and also create the metrics functions, so that I can use and view them easily in the future. I’ll be honest, I still don’t fully understand it, but at least I can refer back to this as I look at these statements more frequently.

Disclaimer:

This is purely for educational purposes. This is not a financial advice, nor am I a financial advisor. This is a note to myself. If you find any mistakes or error, please let me know. Thanks! Also, there are a lot of information on each section, I won’t be covering all of them, just mostly the metrics from the book and also points I found interesting.

Objectives:

The Skeleton of Financial Statements

A financial statement is a formal record that shows a company’s financial activities and position, typically consisting of three core components: the income statement (which shows revenues earned and expenses incurred to calculate profit or loss over a period), the balance sheet (which presents what the company owns as assets, what it owes as liabilities, and the difference between them as equity at a specific point in time), and the cash flow statement (which tracks the actual movement of cash in and out of the business through operating activities, investing activities, and financing activities). The income statement reveals profitability, and the cash flow statement shows liquidity and how money actually moves through the business.

If we were to think of a kid’s lemonaid shop, the income statement would show how much money the shop made from selling lemon tea and how much it spent on ingredients, paying Johnny hourly to sell (salary) to calculate the profit. The balance sheet would list the shop’s assets (like cash in the register, inventory of lemons, sugar, and any equipment) and liabilities (like loans or unpaid bills - money your parent you borrowed from to buy all of the above) to show the net worth of the business at a given moment. The cash flow statement would track the actual cash coming in from customers and going out for expenses, giving insight into whether the shop has enough liquidity to cover its day-to-day operations.

It sounds simple, in the big picture, but these are just the basic skeleton of financial statements. There are many nuances and details that we need to understand to really grasp the story that these statements are telling us.Each section has its own items and some of these items are good at forming different metrics to tell the story of how the lemonaid business is doing. Below is just a snapshot of Apple’s financial statement.

Income Statement

Balance Sheet

Cash Flow

Let’s Take An Example

Let’s go to Alpha Vantage and create a free api key and then pull Apple’s 10 year financial statement and go through as an exercise.

https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/aapl-20250927.htm#i719388195b384d85a4e238ad88eba90a_181

library(httr)
library(jsonlite)
library(tidyverse)

api_key <- "your_api_key_here" # Use .Renviron to be safer like below combine_all code

## Create a function to pull data
get_data <- function(fx,ticker) {
  raw <- GET(paste0(
    "https://www.alphavantage.co/query?function=",fx,
    "&symbol=",ticker,"&apikey=", api_key
  )) %>%
    content(as = "text", encoding = "UTF-8") %>%
    fromJSON()
  
  df <- raw$annualReports |> 
    as_tibble() |> 
    mutate(across(-c(fiscalDateEnding, reportedCurrency), as.numeric)) |>
    mutate(fiscalDateEnding = as.Date(fiscalDateEnding)) |>
    arrange(fiscalDateEnding)

  return(df)
}

## financial statement
income <- get_data("INCOME_STATEMENT","AAPL")
balance <- get_data("BALANCE_SHEET","AAPL")
cashflow <- get_data("CASH_FLOW","AAPL")

Let’s visualize the income statement

Income Statement

Alright, here we go! Income statement tells the story of how the goods and services are doing in the market, how much it costs to produce and sell them, and how much profit is left after all expenses are accounted for. It is a dynamic statement that shows the flow of money over a period of time, typically a quarter or a year. It is like a movie that tells the story of the company’s operations and profitability. Below are some ratios and heuristics of which companies have a durable competitive advantage, according to Warren Buffett.

Gross Profit Margin

$Gross Profit Margin = Gross Profit / Total Revenue$

In the book, we are looking for consistent, as a general rule, above 40% to consider a company to have a durable competitive advantage. Gross profit here is basically Total Revenue - Cost of Revenue, does not take into account of R&D, admin etc. Gross profit margin is a measure of how much profit a company makes from its core operations, before accounting for other expenses. A higher gross profit margin indicates that the company has a strong competitive position in the market and is able to generate more profit from its sales.

So on Apple, you can see that in the sales section, there is product and service. I assume product is the hardware and service is like the cloud storage etc. The cost of revenue section has the same sections, that depicts how much cost to make these products/services. Again, remember this is all just about the goods, does not take into account of the R&D, office that manages these, administrative etc, I think. 🤔

Depreciation

Apparently this is a non-cash expense that reflects the reduction in value of a company’s assets over time. It is an accounting method used to allocate the cost of tangible assets (like machinery, equipment, buildings) and intangible assets (like patents, copyrights) over their useful lives. Depreciation allows companies to spread out the expense of an asset over several years, rather than recognizing the entire cost in the year it was purchased.

A quick ratio in the book is

$Depreciation / Gross Profit$

which should be low ~5-7% which indicates that the company is not heavily reliant on physical assets that may lose value over time. Warren stated that EBITDA (Earnings Before Depreciation, Taxes, and Amortization) is something Wall Street loves, but in Warren’s eyes, depreciation is a real expanse. Why is it that he said EBITDA is something Wall Street love? Because it shows a higher profit by excluding non-cash expenses like depreciation, which can make a company look more profitable than it actually is… interesting. 🤔

Interest Payment to Operating Income

$Interest Payment / Operating Income$

should be less than 15%. This ratio indicates that the company is not overly burdened by debt and has a healthy balance between its operating income and interest expenses. A lower ratio suggests that the company is generating sufficient operating income to cover its interest payments, which is a positive sign of financial stability.

Operating Income = Total Revenue - Cost of Revenue - Operating Expenses. And Operating Expenses = R&D + Selling, General and Administrative Expenses. Wow, so many terminologies and I still don’t fully understand them, but at least I can refer back to this when I look at these statements.

Income Before Tax

This is a value that Warren uses when he calculates the return that he is getting when he a whole business.

Income After Tax

This is a value is the truth test of a business. What is reported with SEC should reflect the pre-tax income reported on the income statement. Apparently some companies like to report higher values than the the truth? was what the book said 🤔

Net Earnings

$Net Earning / Total Revenue$

The heuristic for this is we should look for more than 20% which indicates that the company is able to generate a significant amount of profit from its total revenue, hence a long term competitive advantage.

Net Earnings = Operating Income - Interest Expense - Taxes. This is the bottom line of the income statement, which represents the company’s total profit after all expenses have been deducted from total revenue. It is a key indicator of a company’s profitability and financial performance. A higher net earnings figure indicates that the company is generating more profit from its operations, which can be a sign of a strong competitive position in the market.Interest Expense - Taxes`.

This is something Warren wants to see consistent increment over time.

This is calculated by: $EPS = Net Income/Outstanding Share$

Does that mean if net income is negative, we’ll have negative share? 🤔

Operating Margin

$Operating Margin = Operating Income / Total Revenue$

This is a measure of a company’s profitability that indicates how much profit it generates from its operations relative to its total revenue. A higher operating margin suggests that the company is more efficient at converting revenue into profit, which can be a sign of a strong competitive position in the market. Though I’m unsure what is a good heuristic for this, we’ll use more than 10%. What do you think?

Metrics

income_metric <- function(df) {
  df_i <- df |>
    mutate(grossProfitMargin = grossProfit / totalRevenue,
           depreciationToGrossProfit = depreciationAndAmortization / grossProfit,
           interestExpenseToOperatingIncome = interestExpense / operatingIncome,
           netEarningMargin = netIncome / totalRevenue,
           operatingMargin = operatingIncome / totalRevenue)
  
  hline <- tribble(
    ~param, ~hline_value, ~color2,
    "grossProfitMargin", 0.4, "red", 
    "depreciationToGrossProfit", 0.07, "blue",
    "interestExpenseToOperatingIncome", 0.15, "blue",
    "netEarningMargin", 0.2, "red",
    "operatingMargin", 0.1, "red"
  ) |>
    mutate(
      param = factor(param),
      ymin = ifelse(color2 == "red", -Inf, hline_value),
      ymax = ifelse(color2 == "red", hline_value, Inf)
    )
  
  columns <- hline$param
  
  plot <- df_i |>
    select(fiscalDateEnding, grossProfitMargin:operatingMargin) |>
    pivot_longer(cols = c(grossProfitMargin:operatingMargin), 
                 names_to = "param", values_to = "values") |>
    mutate(param = factor(param, levels = columns)) |> 
    ggplot(aes(x = fiscalDateEnding, y = values)) +
    geom_rect(
      data = hline,
      aes(ymin = ymin, ymax = ymax, fill = color2),
      xmin = -Inf, xmax = Inf,
      alpha = 0.15,
      inherit.aes = FALSE
    ) +
    geom_line() +
    facet_wrap(. ~ param, scale = "free_y") +
    scale_fill_identity() +
    theme_bw()
  
  return(plot)
}

income_metric(income)

Balance Sheet

$Asset = Liability + Shareholder Equity$

Reminded me of Full Metal Alchemist famous phrase “tōka kōkan”, equivalent exchange.

Current Assets

Current asset is any asset that can be reasonably expected to be converted into cash within one year. This includes cash and cash equivalents, accounts receivable, inventory, and other short-term assets. Current assets are important because they provide insight into a company’s liquidity and ability to meet its short-term obligations.

Net Receivables To Gross Sale Ratio

$Net Receivables / Gross Sale$

If a company consistently has a lower ratio (? 5% or less), it may indicate that the company is efficient in collecting payments from customers and has a lower risk of bad debts. A higher ratio may suggest that the company is having difficulty collecting payments, which could lead to cash flow issues and potential losses from uncollected receivables.

The Current Ratio

$Current Ratio = Total Current Assets / Total Current Liabilities$

The current ratio is a liquidity ratio that measures a company’s ability to pay off its short-term liabilities with its short-term assets. A current ratio of 1 or higher is generally considered good, indicating that the company has enough assets to cover its liabilities. A current ratio below 1 may indicate that the company may have difficulty meeting its short-term obligations. This makes sense.

Property, Plant, and Equipment

This is the value of a company’s physical assets, such as land, buildings, machinery, and equipment. It is important to consider the value of PPE when evaluating a company’s financial health and potential for growth. A company with a significant amount of PPE may have a competitive advantage in its industry, as it may be able to produce goods or services more efficiently than its competitors. However, it is also important to consider the age and condition of the PPE, as well as any potential liabilities associated with it. In the title of this chapter, it says For Warren Not Having Them Is A Good Thing 🤣

Short Term Debt

From Warren’s perspective, when it comes to investing in financial institutions, he’s always shied away from companies who are bigger borrowers in short-term than long-term.

$Short Term Debt/ Long Term Debt$

Not really sure what the heuristic threshold is, but let’s use less than 1 as a good indicator?

Long Term Debt

As a general rule, a company with durable competitve edge, will have no or little long term debt to maintain their business operation. Let’s ensure this is not an uptrend on visualization

Retained Earnings

Retained earnings is the portion of a company’s net income that is retained and not distributed as dividends to shareholders. It represents the accumulated profits that a company has reinvested in its business over time. Retained earnings can be used for various purposes, such as funding research and development, expanding operations, paying off debt, or acquiring other companies. It is an important metric for investors to consider when evaluating a company’s financial health and growth potential, as it indicates how much profit the company has generated and how it has been utilized to support its long-term success.

$Growth Rate = (Ending Retained Earnings/Beginning Retained Earnings)^{1/years}-1$

Treasury Stock

Treasury stock refers to shares that a company has repurchased from its shareholders. These shares are held in the company’s treasury and are not considered outstanding shares. Treasury stock can be used for various purposes, such as to increase shareholder value, to have shares available for employee compensation plans, or to prevent hostile takeovers. When a company repurchases its own shares, it reduces the number of outstanding shares in the market, which can increase the value of the remaining shares and potentially boost earnings per share (EPS). However, it is important for investors to consider the reasons behind a company’s decision to buy back its own stock and how it may impact the company’s financial health and long-term growth prospects.

Return On Shareholders’ Equity

$Return On Shareholders' Equity = Net Income / Shareholders' Equity$

According to the book, high ROSE means come play 🤣 How about stop and smell the rose? 🌹 The book did not tell us exactly what the threshold is, but the companies of choice has about ~30-35%

Metrics

balance_metric <- function(df, income) {
  df_b <- df |>
    mutate(currentRatio = totalCurrentAssets / totalCurrentLiabilities,
           netReceivablesToGrossSale = currentNetReceivables / income$grossProfit,
           shortToLongTermDebt = shortTermDebt / longTermDebt,
           growthRateRetainedEarnings = (retainedEarnings / lag(retainedEarnings))^(1/n()) - 1,
           returnOnShareholdersEquity = income$netIncome / totalShareholderEquity)
  
  hline <- tribble(
    ~param, ~hline_value, ~color2,
    "currentRatio", 1, "red", 
    "netReceivablesToGrossSale", 0.05, "blue",
    "shortToLongTermDebt", 1, "blue",
    "growthRateRetainedEarnings", 0.05, "red",
    "returnOnShareholdersEquity", 0.3, "red"
  ) |>
    mutate(
      param = factor(param),
      ymin = ifelse(color2 == "red", -Inf, hline_value),
      ymax = ifelse(color2 == "red", hline_value, Inf)
    )
  
  columns <- hline$param
  
  plot <- df_b |>
    select(fiscalDateEnding, currentRatio:returnOnShareholdersEquity) |>
    pivot_longer(cols = c(currentRatio:returnOnShareholdersEquity), 
                 names_to = "param", values_to = "values") |>
    mutate(param = factor(param, levels = columns)) |> 
    ggplot(aes(x = fiscalDateEnding, y = values)) +
    geom_rect(
      data = hline,
      aes(ymin = ymin, ymax = ymax, fill = color2),
      xmin = -Inf, xmax = Inf,
      alpha = 0.15,
      inherit.aes = FALSE
    ) +
    geom_line() +
    facet_wrap(. ~ param, scale = "free_y") +
    scale_fill_identity() +
    theme_bw()
  
  return(plot)
}

balance_metric(balance, income)

Cash Flow

Operating Income

Cash flow from operating income starts with net income and then add back depreciation and amortization. This is because depreciation and amortization are non-cash expenses that reduce net income but do not actually involve a cash outflow. By adding them back, we can get a better picture of the actual cash generated by the company’s operations.

Capital Expenditure

Also known as CapEx, refers to the funds that a company uses to acquire, upgrade, and maintain physical assets such as property, buildings, technology, equipment, or machinery. CapEx is an important metric for investors to consider when evaluating a company’s financial health and growth potential, as it indicates how much the company is investing in its long-term success.

If we were to look at Apple’s cash flow statement, CapEx is payments for acquisition of proptery, plant, and equipment.

$Capital Expenditure/Net Earning$

And the heuristic is ~50% or less.

Stock Buyback

Stock buyback, also known as share repurchase, refers to a company’s practice of buying back its own shares from the open market. This can be done for various reasons, such as to increase shareholder value, to have shares available for employee compensation plans, or to prevent hostile takeovers. When a company repurchases its own shares, it reduces the number of outstanding shares in the market, which can increase the value of the remaining shares and potentially boost earnings per share (EPS).

On the Apple cash flow statement, stock buyback is listed as repurchase of common stocks. Others might use issuance of (retirement) stocks.

Metrics

cashflow_metric <- function(df) {
  df_c <- df |>
    mutate(operatingCashFlow = netIncome + depreciationDepletionAndAmortization,
           capitalExpenditureToNetEarning = capitalExpenditures / netIncome,
           stockBuybackToNetEarning = abs(proceedsFromRepurchaseOfEquity / netIncome))
  
  hline <- tribble(
    ~param, ~hline_value, ~color2,
    "operatingCashFlow", 0, "red", 
    "capitalExpenditureToNetEarning", 0.5, "blue",
    "stockBuybackToNetEarning", 0.5, "red"
  ) |>
    mutate(
      param = factor(param),
      ymin = ifelse(color2 == "red", -Inf, hline_value),
      ymax = ifelse(color2 == "red", hline_value, Inf)
    )
  
  columns <- hline$param
  
  plot <- df_c |>
    select(fiscalDateEnding, operatingCashFlow, capitalExpenditureToNetEarning, stockBuybackToNetEarning) |>
    pivot_longer(cols = c(operatingCashFlow, capitalExpenditureToNetEarning, stockBuybackToNetEarning), 
                 names_to = "param", values_to = "values") |>
    mutate(param = factor(param, levels = columns)) |> 
    ggplot(aes(x = fiscalDateEnding, y = values)) +
    geom_rect(
      data = hline,
      aes(ymin = ymin, ymax = ymax, fill = color2),
      xmin = -Inf, xmax = Inf,
      alpha = 0.15,
      inherit.aes = FALSE
    ) +
    geom_line() +
    facet_wrap(. ~ param, scale = "free_y") +
    scale_fill_identity() +
    theme_bw()
  
  return(plot)
}

cashflow_metric(cashflow)

Use key valuation metrics (P/E, EV/EBITDA, P/B, P/S, etc) to determine how cheap or expensive a stock is.

Combine All Metrics

code

library(httr)
library(jsonlite)
library(tidyverse)
library(ggpubr)

api_key <- Sys.getenv("avkey")

## Create a function to pull data
get_data <- function(fx,ticker,share=F) {
  raw <- GET(paste0(
    "https://www.alphavantage.co/query?function=",fx,
    "&symbol=",ticker,"&apikey=", api_key
  )) %>%
    content(as = "text", encoding = "UTF-8") %>%
    fromJSON()
  
  if (share==T) {
    df <- raw$annualEarnings |>
      select(fiscalDateEnding, reportedEPS) |>
      mutate(fiscalDateEnding = ymd(fiscalDateEnding))
  } else {
  df <- raw$annualReports |> 
    as_tibble() |>
    mutate(fiscalDateEnding = as.Date(fiscalDateEnding)) |>   
    mutate(across(where(is.character), as.numeric)) |>        
    arrange(fiscalDateEnding)
  }

  return(df)
}

income_metric <- function(df) {
  df_i <- df |>
    mutate(grossProfitMargin = grossProfit / totalRevenue,
           depreciationToGrossProfit = depreciationAndAmortization / grossProfit,
           interestExpenseToOperatingIncome = interestExpense / operatingIncome,
           netEarningMargin = netIncome / totalRevenue,
           operatingMargin = operatingIncome / totalRevenue)
  
  hline <- tribble(
    ~param, ~hline_value, ~color2,
    "grossProfitMargin", 0.4, "red", 
    "depreciationToGrossProfit", 0.07, "blue",
    "interestExpenseToOperatingIncome", 0.15, "blue",
    "netEarningMargin", 0.2, "red",
    "operatingMargin", 0.1, "red"
  ) |>
    mutate(
      param = factor(param),
      ymin = ifelse(color2 == "red", -Inf, hline_value),
      ymax = ifelse(color2 == "red", hline_value, Inf)
    )
  
  columns <- hline$param
  
  plot <- df_i |>
    select(fiscalDateEnding, grossProfitMargin:operatingMargin) |>
    pivot_longer(cols = c(grossProfitMargin:operatingMargin), 
                 names_to = "param", values_to = "values") |>
    mutate(param = factor(param, levels = columns)) |> 
    ggplot(aes(x = fiscalDateEnding, y = values)) +
    geom_rect(
      data = hline,
      aes(ymin = ymin, ymax = ymax, fill = color2),
      xmin = -Inf, xmax = Inf,
      alpha = 0.15,
      inherit.aes = FALSE
    ) +
    geom_line() +
    facet_wrap(. ~ param, scale = "free_y") +
    scale_fill_identity() +
    theme_bw() +
    ggtitle("Income Statement Metrics")
  
  return(plot)
}

share_metric <- function(df) {
    plot <- df |>
      mutate(reportedEPS = as.numeric(reportedEPS)) |>
      ggplot(aes(x = fiscalDateEnding, y = reportedEPS)) +
      geom_line() +
      geom_smooth() +
      theme_bw() +
      ggtitle("Share Metrics")
    return(plot)
}

balance_metric <- function(df, income) {
  df_b <- df |>
    mutate(currentRatio = totalCurrentAssets / totalCurrentLiabilities,
           netReceivablesToGrossSale = currentNetReceivables / income$grossProfit,
           shortToLongTermDebt = shortTermDebt / longTermDebt,
           growthRateRetainedEarnings = (retainedEarnings / lag(retainedEarnings))^(1/n()) - 1,
           returnOnShareholdersEquity = income$netIncome / totalShareholderEquity)
  
  hline <- tribble(
    ~param, ~hline_value, ~color2,
    "currentRatio", 1, "red", 
    "netReceivablesToGrossSale", 0.3, "blue",
    "shortToLongTermDebt", 1, "blue",
    "growthRateRetainedEarnings", 0.05, "red",
    "returnOnShareholdersEquity", 0.3, "red"
  ) |>
    mutate(
      param = factor(param),
      ymin = ifelse(color2 == "red", -Inf, hline_value),
      ymax = ifelse(color2 == "red", hline_value, Inf)
    )
  
  columns <- hline$param
  
  plot <- df_b |>
    select(fiscalDateEnding, currentRatio:returnOnShareholdersEquity) |>
    pivot_longer(cols = c(currentRatio:returnOnShareholdersEquity), 
                 names_to = "param", values_to = "values") |>
    mutate(param = factor(param, levels = columns)) |>
    ggplot(aes(x = fiscalDateEnding, y = values)) +
    geom_rect(
      data = hline,
      aes(ymin = ymin, ymax = ymax, fill = color2),
      xmin = -Inf, xmax = Inf,
      alpha = 0.15,
      inherit.aes = FALSE
    ) +
    geom_line() +
    facet_wrap(. ~ param, scale = "free_y") +
    scale_fill_identity() +
    theme_bw() +
    ggtitle("Balance Sheet Metrics")
  
  return(plot)
}

cashflow_metric <- function(df, income) {
  df_c <- df |>
    mutate(operatingCashFlow = netIncome + depreciationDepletionAndAmortization,
           capitalExpenditureToNetEarning = capitalExpenditures / netIncome,
           stockBuybackToNetEarning = case_when(
             proceedsFromRepurchaseOfEquity < 0 ~ -proceedsFromRepurchaseOfEquity / income$netIncome,
             income$netIncome < 0 & proceedsFromRepurchaseOfEquity > 0 ~ NA_real_,
             income$netIncome < 0 & proceedsFromRepurchaseOfEquity < 0 ~-proceedsFromRepurchaseOfEquity / income$netIncome))
  
  hline <- tribble(
    ~param, ~hline_value, ~color2,
    "operatingCashFlow", 0, "red", 
    "capitalExpenditureToNetEarning", 0.5, "blue",
    "stockBuybackToNetEarning", 0.5, "red"
  ) |>
    mutate(
      param = factor(param),
      ymin = ifelse(color2 == "red", -Inf, hline_value),
      ymax = ifelse(color2 == "red", hline_value, Inf)
    )
  
  columns <- hline$param
  
  plot <- df_c |>
    select(fiscalDateEnding, operatingCashFlow, capitalExpenditureToNetEarning, stockBuybackToNetEarning) |>
    pivot_longer(cols = c(operatingCashFlow, capitalExpenditureToNetEarning, stockBuybackToNetEarning), 
                 names_to = "param", values_to = "values") |>
    mutate(param = factor(param, levels = columns)) |> 
    ggplot(aes(x = fiscalDateEnding, y = values)) +
    geom_rect(
      data = hline,
      aes(ymin = ymin, ymax = ymax, fill = color2),
      xmin = -Inf, xmax = Inf,
      alpha = 0.15,
      inherit.aes = FALSE
    ) +
    geom_line() +
    facet_wrap(. ~ param, scale = "free_y") +
    scale_fill_identity() +
    theme_bw() +
    ggtitle("Cash Flow Metrics")
  
  return(plot)
}

show_all <- function(name) {
  income <- get_data("INCOME_STATEMENT",name)
  share <- get_data("EARNINGS",name,share=T)
  balance <- get_data("BALANCE_SHEET",name)
  cashflow <- get_data("CASH_FLOW",name)
  plot1 <- income_metric(income) 
  plot2 <- share_metric(share)
  plot3 <- balance_metric(balance, income)
  plot4 <- cashflow_metric(cashflow, income)
  stacked_plot <- ggarrange(plot1,plot3,nrow=2)
  squished_plot <- ggarrange(plot4,plot2,ncol=2, widths = c(2,1))
  combineplot <- ggarrange(plotlist = list(stacked_plot,squished_plot), nrow = 2, heights = c(2,1))
  return(combineplot)
}

Let’s Look At Another Example

As a heuristics, we’ve made our dataviz where red is like lava, you want to stay above it. Blue is like the sky, you want to stay below it. The sweet zone is in between. 🤣 When there is a loess curve, we are trying to see if the share is consistently increasing.

Apple

show_all("AAPL")

Looking the income metrics, Apple seems to be doing pretty good. Gross profit margin, net earning margin, operating income margin are all above thresholds. Depreciation to gross profit ratio is appropriately below the threshold, which means there is no recent purchase of property, plants, machines, etc where these are the ones that will add to depreciation. There is also a low to no interest expense, which is good! No debt? Next we move on to balance sheet metrics, current ratio is not great, liquidity is not great, net receivable is ?OK, I guess it make sense, if your products are popular and provide some sort of finance option, you might have some receivables. Short term debt is much lower than long term debt, which is good. The ROSE is smelling pretty good there too! In terms of cash flow metrics, it’s looking really good, it has high cash flowing in, low CapEx, and consistently buying its own share from 2020 onwards.

Microsoft

show_all("MSFT")

As for Microsoft, now that we’re a bit more familiar with the sections, let’s just string our read instead of separating them. Good consistent profit for all profit, operating and net income. Interestingly, depreciation is high along with CapEx, did they buy property, plants or machine? Ah, they built data center? Interest expense is low, which is good. Good liquidity factor with current ratio above threshold, net receivables is OK same as Apple (a competitor), short/long debt is good as well. ROSE is close to the threshold (worth watching). Cash is flowing, not much stock buyback, but overall EPS is consistently increasing. With its investment in data centers for Azure, next few years we should be seeing a persistent depreciation to gross profit ratio, along with CapEx, right? I read somewhere where you can’t place all depreciation in a single year.

NVIDIA

show_all("NVDA")

Now let’s take a look at NVIDIA. Wow, gross profit, operating income, and net earning margin all really good, better than Apple and Microsoft! Well, make sense with all these data centers, they need GPUs from NVIDIA. Look at that depreciation and CapEx, barely any! That’s great, less to maintain and the current plants they have are adequate to supply the demand. Low interest expense too, not much debt interest. Liquidity is great with high current ratio! Net receivables is good too, these big companies are paying NVIDIA back! ROSE is also very fragrant! Cash is flowing through the roof. Not much stock buyback. Also exponential EPS! You know, Warren did say that be mindful of companies with R&D cost.

Intel

show_all("INTC")

Wow, first glance with the profits, we’re seeing lava red. We then see high rise in depreciation and CapEx. Did they buy more property, plants, or machines? Intel announces plans for an investment of more than $28 billion for two new chip factories in Licking County, Ohio. And maybe Germany and Arizona too? Interesting. Notice that the interest expense towards the end of 2025 was in 2 digit but negative? It’s because the the operating income was negative and a high interest expense. I wonder if I should make this absolute as opposed to keeping the negative. Anyway, this means that not only was Intel in the red but also paying quite a bit of interest from the debt, I assume. The current ratio looks pretty good, same goes with the net receivables. Short term debt is also much lower compared to long term. ROSE not so good. As for the cash flow, when we add depreciation and demortization back to net income, it brought the red back up. Notice how the EPS dropped significantly lately, and notice that the buyback of share is missing? We code it where if it’s a positive value of buyback, which means it’s issuing stock instead of repurchasing, hence NA. Wow, what do you think? Will they be able to turn this around? Do data centers use Intel chips or AMD’s threadripper?

AMD

show_all("AMD")

Interesting income statement metric results. Good gross profit margin, but the net earning is barely. Interesting depreciation trend, what happened in 2024, where CapEx didn’t budge? Great liquidity, pretty high net receivables. Wow, very high short-to-long term debt in ?2021-2022. ROSE is essentially 0. With cash flowing good towards 2025, and also high buybacks 2022 ish. Finally, uptrending EPS! This is an odd one. Pasting my observation onto Claude and wow, these findings are due to Xilinx acquisition. That makes sense! Didn’t build new plants, old property, plants, machines have already been amortized, hence low depreciation. The acquisition is funded by debt, hence high short-to-long term debt ratio. Very interesting, indeed! So, it could be true that data centers prefer AMD over Intel given the good profit?

Google

show_all("GOOG")

Very good profit of all 3 metrics. After 2020, depreciation downtrended which is good and so did CapEx. Not much debt. Downtrending current ratio but still good. Very good net receivables! ROSE is coming up. Great cash flow. There is buyback of equity. Rising EPS. All great signs for Google! Being an all-service (no hardware?) company, this is quite good and healthy!

3M

show_all("MMM")

Now on to 3M, not a tech company, but let’s see if our workflow of looking at financial statement will help us tell a story. Profit is not as great as other tech companies we looked at, though gross profit is above threshold, but the net earnings is in the lava. Notice both net earnings and operating margins dipped quite low in 2024? And then a pretty high interest expense to operating income ratio in 2025? I wonder if because of losing money, they borrowed long term, hence short-to-long term debt is not too high? Current ratio is acceptable, but why is net receivables so high for 3M? Clients were not able to pay 3M? ROSE is pretty good in 2024 and 2025 even when profits weren’t. But why? Cash flow with high variance last 3 years. There is stock buyback in 2025. And even though EPS downtrended past 2 years but still remained high. This is a very interesting one as well. 3M should be a company where there’s competitive advantage because they make lots of daily usables which doesn’t need a whole lot of R&D. But why the anomaly in 2024 requiring debt? What do you think?

Disney

show_all("DIS")

Alright, what about Disney? Profit doesn’t seem as good as I expected. Both gross profit and net earning margins were below threshold, except for operating income margin. Interesting, in 2021, there is increase in depreciation, CapEx, and interest expense with low short-to-long debt ratio. It almost looked like they borrowed some money to purchase something new? Did they rebuild a park or something? In terms of liquidity, it’s on the lava zone in 2025 and seemed like it downtrended for the past 3 years as well. Net receivables is OK? Though I would think it should be lower? ROSE is red. Cash flow looks good, this is interesting because whatever that caused the depreciation when added back now they have cash. Also interesting to note that from 2020 to 2024 they were issuing stock rather than buying back. Their EPS appear to be quite volatile for the pat 3 years.

Boeing

show_all("BA")

Last but not least, let’s look at Boeing. Three profit margin metrics in the lava zone. Spike of interest expense in 2021 along with depreciation. Something physical was bought with borrowed money that’s paid long term. Current ratio is good. Essentially no net receivables. Consistent floating ROSE on the red sea. Operating cash flow in the red for a few years then positive in 2025. CapEx spiked in 2025, ?what was spent in capital where it doesn’t really depreciate? Buyback stock is interesting, missing several past few years, essentially issuing stocks when we have NA data. EPS downtrend to the negatives.

Opportunities For Improvement

We need to recheck growth rate again, not sure if the code is correct
perhaps build this into an R package, and develop further
Learn about valuation metrics such as P/E, EV/EBITDA, P/B, P/S
Not really sure if short-to-long term debt ratio of 1 is a good threshold, seems too high.
include actual numbers on geom_label with ggrepel and reduce font size

Lessons learnt

Depreciation and CapEx seem to have strong correlation, which makes sense.
learnt Alpha Vantage API, quite straight forward
learnt to look at financial statement and its metrics

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Exploring Piperacillin/Tazobactam Probability of Target Attainment (PTA) in Pseudomonas

Sun, 15 Mar 2026 00:00:00 +0000

Exploring pip/tazo PTA for Pseudomonas using popPK simulation. Key finds: 30-min infusions fall short of 90% PTA at MIC 16; prolonged infusion helps, but neutropenic fever population sees the biggest drop in PTA. ~46% of susceptible PsA isolates carry blaOXA-2 — tazobactam matters more than I thought

Motivations

We’ve learnt a bit of PK/PD last time, here. Let’s apply that on Pip/tazo and Pseudomonas. An FDA statement Feb 2024 detailed that for susceptible dose dependent (SDD) breakpoint of 16 mcg/mL, we should utilize 4.5 g q6h over 3-hour infusion because the standard dosing of 4.5g IV every 6 hours over 0.5 hours do not adequate achieve > 90% PTA. There is also a mention on the limitation where the fT > mic of 50% was used to calculate PTA, which was not adequately validated for PsA. This is a great opportunity for us to take a look at this, now that we have a better understanding of what PTA and fT>mic mean from a data structure standpoint!

First, we’ll obtain the population PK parameters, make a model, and then perform the simulation, and visualize the PTA. We’ll be exploring A Pooled Pharmacokinetic Analysis for Piperacillin/Tazobactam Across Different Patient Populations: From Premature Infants to the Elderly. This model is more sophisticated than the previous one as it’s a pooled popPK model. We’ll then compare the PTA of the recommended dosing and infusion time, compared to standard dosing of 30 mins. And then look at some maximum amount of fT>mic used in the literature, and then explore the PTA given the threshold of fT>mic. Also, a curious question is, why do we need tazobactam for pseudomonas when piperacillin itself has activity against it? Could it be because of co-resistance of beta lactamase? Let’s take a look at all pseudomonas isolate that is pip/tazo susceptible and check for proportion of these beta lactamase genes in NCBI.

Disclaimer:

This is purely for educational purposes. Not a medical advice. If you find something wrong, please let me know so I can correct and continue to learn.

Objectives:

Piptazo Model

LLM code

library(mrgsolve)
library(tidyverse)

mod <- mcode(model = "piptazo", code = '
$PARAM
// --- Fixed effects (Table 3) ---
// Piperacillin
theta_V1_PIP  = 10.4,   // L/70kg
theta_CL_PIP  = 10.6,   // L/h/70kg
theta_V2_PIP  = 11.6,   // L/70kg
theta_Q2_PIP  = 15.2,   // L/h/70kg

// Tazobactam
theta_V1_TAZ  = 10.5,   // L/70kg
theta_CL_TAZ  = 9.58,   // L/h/70kg
theta_V2_TAZ  = 13.7,   // L/70kg
theta_Q2_TAZ  = 16.8,   // L/h/70kg

// Shared maturation-decline parameters
MAT50_wk      = 54.2,   // weeks PMA at 50% maturation (shared)
gamma1        = 3.35,   // shape: maturation
DEC50_PIP_yr  = 89.1,   // years PMA at 50% decline, PIP
DEC50_TAZ_yr  = 61.6,   // years PMA at 50% decline, TAZ
gamma2        = 1.92,   // shape: decline (shared)

// SCR effect on CL (shared PIP+TAZ, Eq. 4)
theta_SCR     = 0.346,  // dL/mg

// Protein binding / DBS corrections (Eqs. 23-25)
fUNB_PIP      = 0.645,  // fraction unbound piperacillin
fDBS_PIP      = 0.368,  // DBS:plasma ratio PIP
fDBS_TAZ      = 0.448,  // DBS:plasma ratio TAZ

// Study-specific corrections (Eqs. 21-22)
// Set to 1.0 for general non-Sime use; 1.73 for Sime et al. CL, 0.512 for Sime et al. V2
theta_CL_Sime = 1.0,
theta_V2_Sime = 1.0,

// Patient covariates (defaults: 70kg, 35yr, SCR 0.83 mg/dL reference adult)
TBW           = 70,     // kg
PMA_yr        = 35,     // postmenstrual age, years
SCR           = 0.83    // serum creatinine, mg/dL

$CMT CENT_PIP PERI_PIP CENT_TAZ PERI_TAZ

$MAIN
// --- Eq. 16: Size scaling relative to 70kg reference ---
double FSIZE = TBW / 70.0;

// --- Eq. 17: Maturation function (PMA in weeks) ---
double PMA_wk = PMA_yr * 52.1775;
double FMAT = pow(PMA_wk, gamma1) /
              (pow(PMA_wk, gamma1) + pow(MAT50_wk, gamma1));

// --- Eqs. 18-19: Decline functions (PMA in years) ---
double FDEC_PIP = 1.0 - pow(PMA_yr, gamma2) /
                        (pow(PMA_yr, gamma2) + pow(DEC50_PIP_yr, gamma2));

double FDEC_TAZ = 1.0 - pow(PMA_yr, gamma2) /
                        (pow(PMA_yr, gamma2) + pow(DEC50_TAZ_yr, gamma2));

// --- Eq. 20: Standardised SCR (Colin et al. equation) ---
double SCR_std = exp(1.42 - (1.17 + 0.203 * log(PMA_yr / 100.0)) /
                             sqrt(PMA_yr / 100.0));

// --- Eq. 4: SCR effect on CL (shared for PIP and TAZ) ---
double FSCR = exp(-theta_SCR * (SCR - SCR_std));

// --- Individual PK parameters ---
// ETA index key (Table 3 / Eqs. 6-14):
//   ETA(1) = V1  (shared PIP + TAZ)
//   ETA(2) = CL_PIP
//   ETA(3) = CL_TAZ
//   ETA(4) = V2  (shared PIP + TAZ)
//   ETA(5) = Q2  (shared PIP + TAZ)

// PIP (Eqs. 6-9)
double V1_PIP = theta_V1_PIP * FSIZE * exp(ETA(1));
double CL_PIP = theta_CL_PIP * pow(FSIZE, 0.75) * FMAT * FDEC_PIP * FSCR
                * theta_CL_Sime * exp(ETA(2));
double V2_PIP = theta_V2_PIP * FSIZE * theta_V2_Sime * exp(ETA(4));

// Eq. 9: compartmental allometry for Q2_PIP
// Q2_i ∝ (V2_i_individual / V2_i_typical)^0.75
double Q2_PIP = theta_Q2_PIP *
                pow(V2_PIP / (theta_V2_PIP * FSIZE * theta_V2_Sime), 0.75) *
                exp(ETA(5));

// TAZ (Eqs. 11-14)
double V1_TAZ = theta_V1_TAZ * FSIZE * exp(ETA(1));
double CL_TAZ = theta_CL_TAZ * pow(FSIZE, 0.75) * FMAT * FDEC_TAZ * FSCR
                * exp(ETA(3));
double V2_TAZ = theta_V2_TAZ * FSIZE * exp(ETA(4));

// Eq. 14: compartmental allometry for Q2_TAZ
double Q2_TAZ = theta_Q2_TAZ *
                pow(V2_TAZ / (theta_V2_TAZ * FSIZE), 0.75) *
                exp(ETA(5));

$OMEGA
// ETA(1): IIV V1 shared PIP+TAZ [42.6% CV -> omega2 = log(0.426^2 + 1)]
0.1537

$OMEGA
// ETA(2): IIV CL_PIP [43.2%]
0.1598

$OMEGA
// ETA(3): IIV CL_TAZ [41.5%]
0.1480

$OMEGA
// ETA(4): IIV V2 shared PIP+TAZ [85.4%]
0.5218

$OMEGA
// ETA(5): IIV Q2 shared PIP+TAZ [65.6%]
0.3598

$SIGMA
// EPS(1): PIP proportional error [30.2% -> sigma = 0.302^2]
0.0912

// EPS(2): PIP additive error [0.147 mg/L -> sigma = 0.147^2]
0.0216

// EPS(3): TAZ proportional error [28.5% -> sigma = 0.285^2]
0.0812

// EPS(4): TAZ additive error [0 FIX per Table 3]
0.0000

$ODE
dxdt_CENT_PIP = -(CL_PIP / V1_PIP) * CENT_PIP
                - (Q2_PIP / V1_PIP) * CENT_PIP
                + (Q2_PIP / V2_PIP) * PERI_PIP;

dxdt_PERI_PIP =  (Q2_PIP / V1_PIP) * CENT_PIP
                - (Q2_PIP / V2_PIP) * PERI_PIP;

dxdt_CENT_TAZ = -(CL_TAZ / V1_TAZ) * CENT_TAZ
                - (Q2_TAZ / V1_TAZ) * CENT_TAZ
                + (Q2_TAZ / V2_TAZ) * PERI_TAZ;

dxdt_PERI_TAZ =  (Q2_TAZ / V1_TAZ) * CENT_TAZ
                - (Q2_TAZ / V2_TAZ) * PERI_TAZ;

$TABLE
// Eq. 10: PIP total plasma (proportional + additive error, Table 3)
double Cp_PIP_total   = (CENT_PIP / V1_PIP) * (1.0 + EPS(1)) + EPS(2);

// PD-relevant: unbound PIP (Eq. 23: fUNB = 0.645 for non-Sukarnjanaset)
// No residual error on this — it is derived deterministically for simulation
double Cp_PIP_unbound = fUNB_PIP * (CENT_PIP / V1_PIP);

// Eq. 15: TAZ total plasma (proportional + additive error; additive = 0 FIX)
double Cp_TAZ_total   = (CENT_TAZ / V1_TAZ) * (1.0 + EPS(3)) + EPS(4);

// DBS concentrations (Eqs. 24-25), applied to total plasma
double Cp_PIP_DBS = fDBS_PIP * (CENT_PIP / V1_PIP);
double Cp_TAZ_DBS = fDBS_TAZ * (CENT_TAZ / V1_TAZ);

$CAPTURE
Cp_PIP_total Cp_PIP_unbound Cp_TAZ_total
Cp_PIP_DBS Cp_TAZ_DBS
V1_PIP CL_PIP V2_PIP Q2_PIP
V1_TAZ CL_TAZ V2_TAZ Q2_TAZ
FSIZE FMAT FDEC_PIP FDEC_TAZ FSCR SCR_std
')

Explaination:

$PARAM: the parameters of the model, which include the fixed effects (theta) and the patient covariates (TBW, PMA_yr, SCR). The fixed effects are the typical values of the PK parameters for a 70kg, 35yr, SCR 0.83 mg/dL reference adult. The patient covariates are the total body weight (TBW), postmenstrual age in years (PMA_yr), and serum creatinine (SCR).
$CMT: the compartments of the model, which include the central and peripheral compartments for both piperacillin (CENT_PIP, PERI_PIP) and tazobactam (CENT_TAZ, PERI_TAZ).
$MAIN: the main block where the individual PK parameters are calculated based on the fixed effects and the patient covariates. This includes size scaling (FSIZE), maturation function (FMAT), decline functions (FDEC_PIP and FDEC_TAZ), standardized SCR (SCR_std), and then the individual PK parameters for piperacillin (V1_PIP, CL_PIP, V2_PIP, Q2_PIP) and tazobactam (V1_TAZ, CL_TAZ, V2_TAZ, Q2_TAZ).
$OMEGA: the inter-individual variability (IIV) for the PK parameters, which are assumed to be log-normally distributed. The values are derived from the coefficients of variation (CV) reported in Table 3 of the paper.
$SIGMA: the residual unexplained variability (RUV) for the observed concentrations, which include proportional and additive error for both piperacillin and tazobactam.
$ODE: the ordinary differential equations that describe the change in drug amount in each compartment over time, based on the PK parameters.
$TABLE: the block where the output variables are defined, including the total plasma concentrations of piperacillin and tazobactam (with error), the unbound piperacillin concentration (which is relevant for PD), and the DBS concentrations.

Alright, the above was LLM generated, including the model! It’s quite good, but we have to verify it and recode from ground up and see if we understand it. The nice thing about this is that at least we have notes to compare and refer if we hit a road block. You can see mine below and I found starting from $MAIN is helpful and just add all the $PARAM and other equations as we build the model is very helpful! Also, we found out that the CRstd is from here and the equation is a bit different from the paper. We also found that the back-calculated IIV values were a bit different. But it’s a great draft overall! And we also noticed that there will be adjustments if we need to simualate neutropenic fever Sime et al or critically ill during early sepsis Sukarnjanaset et al. We’ll look at that in a bit.

my code

mod <- mcode(model = "piptazo_ken", code = '
$PARAM
theta_v1_pip = 10.4,
tbw = 70,
theta_cl_pip = 10.6, 
pma_year = 35,
gamma1 = 3.35,
gamma2 = 1.92,
scr = 0.82,
theta_scr = 0.346,
dec50_pip = 89.1,
theta_cl_sime = 1,
theta_v2_sime = 1,
funb_pip = 0.645,
fdbs_pip = 1,    // we are assuming we dont use dried bld sample
theta_v2_pip = 11.6,
theta_q2_pip = 15.2,
mat50 = 54.2


$CMT CENT_PIP PERI_PIP 

$MAIN
double fsize = tbw / 70;
double pma_week = pma_year * 52.17;
double fmat = pow(pma_week,gamma1) / (pow(pma_week,gamma1) + pow(mat50,gamma1));
double fdec_pip = 1 - (pow(pma_year, gamma2) / (pow(pma_year, gamma2) + pow(dec50_pip, gamma2)));
double scrstd = exp(1.42 - (1.17 + 0.203 * log(pma_year / 100.0)) / sqrt(pma_year / 100.0));
double fscr = exp(-theta_scr*(scr-scrstd));

double v1_pip = theta_v1_pip * fsize * exp(ETA(1));
double cl_pip = theta_cl_pip * pow(fsize, 0.75) * fmat * fdec_pip * fscr * theta_cl_sime * exp(ETA(2));
double v2_pip = theta_v2_pip * fsize * theta_v2_sime * exp(ETA(4));
double q2_pip = theta_q2_pip * pow(v2_pip/theta_v2_pip, 0.75) * exp(ETA(5));

$OMEGA
0.1667645 
0.1711123
0.1589037   // IIV CL for tazo ETA(3)
0.547726
0.3579094

$ODE
dxdt_CENT_PIP = -(cl_pip/v1_pip)*CENT_PIP - (q2_pip/v1_pip)*CENT_PIP + (q2_pip/v2_pip)*PERI_PIP;
dxdt_PERI_PIP = -(q2_pip/v2_pip)*PERI_PIP + (q2_pip/v1_pip)*CENT_PIP;

$TABLE
double free_pip = (CENT_PIP/v1_pip) * funb_pip;

$CAPTURE
free_pip')

Also, I only simulated piperacillin unbound concentration since the mic is focused mainly on that. And no point of including the proportional or additive residuals since we’re not estimating the variance of the test result. The model looks smaller than the LLM generated. That being said, still a great exercise! Especially the ODE part.

Probability of Target Attainment

Ok, let’s look at non critical care, non neutropenic febrile population with weight of 90kg and age 35 with Scr 0.83

For easier visualization, I placed a red dashed red horizontal line to indicate PTA of 90%, and also dashed black vertical line to indicate mic of 16, the highest mic to be classified as susceptible to piptazo. We can see that both the 30 min infusion regardless of 4g had less than 90% PTA. Now, what if we increase the age and Scr a little bit to represent average population who will need piptazo.

Age 50, Scr 1

OK, maybe on average, it might be OK with intermittent infusion as long as it’s 4g. What if we look at critically ill population with early sepsis

Critically Ill

Oh, that’s interesting, I would expect it to be worse but what’s showing here is the opposite. Looking at the calculation, it might be because of funb_pip == 1, which makes the free concentration higher. But in reality, this would also mean clearance is faster and higher as well. Since the way we code in the model doesn’t account that, I’m not sure if we can make sense of this result. But we’ll keep this because the paper actually questioned if fT > mic 50% might be too low for critically ill populations. We’ll explore that in a little bit.

Neutropenic Fever

Wow, this is very dramatic. Even prolonged infusion except for 4g (3hr) q6 infusions had barely above 90% PTA.

Maximum fT>mic used in the literature

According to some literature that ft> mic 50% is not suitable for PsA, though there is no consensus on what the optimal threshold should be. I found some papers that used 70% or even 100%. Let’s look at the PTA if we use these thresholds.

OK, we are seeing the PTA drops quite a bit if fT>mic is 100%. This is when the critically ill population parameter might come in handy. Some even said that this population may need fT>4xmic 100% to achieve optimal outcome. So let’s look at that as well.

fT > mic 100%

fT > 4 x mic 100%

Wow… 😵‍💫 When looking at the original paper, the number look quite similar to ours for extended infusion for both fT>mic 100% and fT>4xmic 100%.

Proportion of PsA in NCBI that would benefit from tazobactam

How are we going to do this? It might not be 100% but we tried filtering PsA of piptazo susceptible and the overlap it with piperacillin resistant, but there were zero overlap. What if we grab all PsA piptazo susceptible and check for beta lactamase genes with exact match?

Over here we search for allele:(blaTEM-1 blaTEM-2 blaTEM-3 blaTEM-4 blaTEM-5 blaTEM-6 blaTEM-7 blaTEM-8 blaTEM-9 blaTEM-10 blaTEM-12 blaTEM-26 blaSHV-1 blaSHV-2 blaSHV-5 blaSHV-12 blaCTX-M-1 blaCTX-M-2 blaCTX-M-3 blaCTX-M-9 blaCTX-M-14 blaCTX-M-15 blaCTX-M-27 blaPER-1 blaPER-2 blaVEB-1 blaVEB-9 blaGES-1 blaOXA-2 blaOXA-10 blaOXA-15 blaPSE-4) .

Then run through the same script as before. Let’s see what we find!

There were 212 isolates of PsA susceptible to piptazo, but only 124 isolates with assemblies. Of the 124 isolates we were able to grab the assemblies, we detected 46% (n=57) with blaOXA-2. Which means, there is a good chance that piperacillin would be hydrolyzed without the tazobactam!

Final Thought

Wow, these population PK and PK/PD studies are mathematically intense! High respect to those who were able to tease the signal out of the noise from all these studies. Definitely lots to learn! Now, I think I have a better understanding why CLSI and FDA had issued statements about mic 16 and piptazo dosing etc. This makes so much more sense now. 🙌

Opportunities For Improvement

get more literature on clinical outcomes and fT > mic of different thresholds, and same with PTA
does tazobactam mic matter in this setting?
does albumin matter much here?
what about cefepime PTA?

Lessons learnt

created an actual PTA plot of all the mics
learnt to recreate model based on popPK study, thank goodness they provide equations on the paper!
got a bit more comfortable with the model parameters in mrgsolve

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Learning PK/PD Simulation: A Beginner's Monte Carlo Analysis With mrgsolve in R

Mon, 09 Mar 2026 00:00:00 +0000

🧪 Diving into PK/PD for the first time — simulating ceftriaxone with mrgsolve in R. Free drug levels were… surprisingly high? Even pushed it to q48h dosing out of curiosity and the results left me with more questions than answers 🤔📈

Motivations

Learning pharmacokinetics (PK) and pharmocodynamics (PD) have always been an interest of mine. It’s always challenging to read through these population PK papers with all the numbers etc. What’s a better way of diving into the surface of these and see if we can at least know how to code a simulation to obtain the probability target attainment (PTA) of different minimal inhibitory concentration (mic) and learn the basics via code! Let’s dive on!

Disclaimer:

I am not a pharmacist and not an expert in PK/PD. This is a documentation for my own learning and for educational purposes only. Not a medical advice. If you noticed anything wrong here, please let me know! PLEASE BE ADVICE THAT THERE WAS AN ERROR IN MY MODEL WHEN CALCULATING FREE CEFTRIAXONE (MAKING SOME RESULTS INACCURATE), I LEFT THE MISTAKE IN THE SECTION AND SPECIFIED THE CORRECTION ON THE UPDATE SECTION.

Objectives:

What Is Population PK

Population pharmacokinetics (popPK) is a statistical approach that describes how medications behave in the body across groups of people, accounting for variability between individuals. Instead of studying one person intensively, popPK analyzes sparse data from many patients to understand typical medication behavior and why people differ in their medication exposure.

We’ll use Garot D et al Population pharmacokinetics of ceftriaxone in critically ill septic patients: a reappraisal as an example for learning.

What Are The Parameters of Interest On a Paper?

From the paper, we can see that there are a lot of parameters and numbers. But what are the parameters of interest? We will focus on the following parameters:

Looking at their table 3, we see these values:
CL = $\theta_1 + \theta_2 . (CL_{cr}/4.26)$
$\theta_1$ : Non-renal (baseline) clearance component
$\theta_2$ : Renal clearance scaling coefficient
V1 : Volume of distribution of the central compartment.
V2 : Volume of distribution of the peripheral compartment.
Q : Inter-compartmental clearance.
$\omega^2 (CL)$ : Between-subject variability of clearance.
$\omega^2 (V1)$ : Between-subject variability of volume of distribution of the central compartment.
$\omega^2 (V2)$ : Between-subject variability of volume of distribution of the peripheral compartment.

These are the parameters we’ll use in our mrgsolve model. I’ve always wondered what these parameters represent and it was a bit difficult to conceptualize until we dove into the code and finally understood the rationale! It’s a mixed effect model where the estimates were modeled as a function of the fixed effect (theta) and the random effect (eta), you will see this in the code later. The fixed effect represents the typical value of the parameter in the population, while the random effect represents the variability between individuals. The random effect is assumed to be normally distributed with a mean of zero and a variance of omega squared.

If we were to draw a flow chart of the above, it will look something like this:

One starts with medication being administered into the central compartment, and then it goes into either peripheral compartment (tissue etc) and medication clearance. Notice that the Q is a bidirectional flow between central and peripheral, whereas all other directions are either into central or out from central to clearance. This is very helpful for me to get a surface understanding of the distribution. Let’s get on with the code!

Let’s Code

library(mrgsolve)
library(tidyverse)

mod <- mcode(model = "ceftriaxone", code='
$PARAM
theta1 = 0.56,
theta2 = 0.32,
CLcr   = 4.26,   // median creatinine clearance of 68.5 ml min-1, hence ~4.26 L hr-1
V1     = 10.3,
V2     = 7.35,
Q      = 5.28,  
fu     = 0.10  // fraction of unbound, picked a static value from package insert range

$CMT CENT PERI

$MAIN
double CL  = theta1 + theta2 * (CLcr / 4.26);  // technically we could use 0.88 as reported on their result section
double CLi = CL * exp(ETA(1));                  // ETA here means log normal distibution of mean 
double V1i = V1 * exp(ETA(2));     
double V2i = V2 * exp(ETA(3));

$OMEGA
0.24   // omega2(CL) from table
0.23
0.42

$SIGMA
0.0576   // √0.0576 = 0.24, 

$ODE
dxdt_CENT = -(CLi/V1i)*CENT - (Q/V1i)*CENT + (Q/V2i)*PERI;
dxdt_PERI =  (Q/V1i)*CENT   - (Q/V2i)*PERI;

$TABLE
double Cp_total = (CENT / V1i)*(1+EPS(1)); 
double Cp_free = fu * Cp_total;

$CAPTURE Cp_free
')

dosing <- ev(amt = 2000, rate = 4000, ii = 24, addl = 2, cmt = "CENT")

set.seed(1)
sims <- mod |>
  ev(dosing) |>
  mrgsim(nid = 1000, end = 72, delta = 0.25) |>
  as_tibble()

ETA in the above means the random effect, which is assumed to be normally distributed with a mean of zero and a variance of omega squared. ETA is a greek letter (eh-ta). EPS here is Epsilon.

For ev, amount is dosing in mg; rate is amount given per hour; ii is frequency; addl is number of additional doses; cmt is the compartment where the dose is given. In this case, we are giving 2000 mg of ceftriaxone as a 30 minute infusion every 24 hours for 3 doses (1 initial dose + 2 additional doses) into the central compartment.

We will then need to set seed for reproducibility, pipe in your initial model with dosing, then nid is number of individuals you want to simulate, end is the end time of the simulation in hours, and delta is the time interval for the simulation output in hours. In this case, we are simulating 1000 individuals for 72 hours with a time interval of 0.25 hours (15 minutes).

Next, we’ll calculate the probability of target attainment (PTA) for different minimal inhibitory concentration (MIC) values. The PTA is the probability that the free drug concentration exceeds the MIC for a certain percentage of the dosing interval.

MIC <- 1

print(paste0("Probability of Target Attainment: ", sims |>
  filter(time >= 48) |>
  group_by(ID) |>
  summarise(fT = mean(Cp_free > MIC)) |>
  summarise(PTA = mean(fT >= 0.50)) |>
  pull()))

## [1] "Probability of Target Attainment: 0.996"

sims |>
  ggplot(aes(x=time,y=Cp_free,group=ID)) +
  geom_line(alpha=0.01) +
  geom_hline(yintercept = MIC, color = "red") +
  theme_bw()

In the above we choose mic of 1, filtered off time after 48 hours for steady state, then calculate the average free ceftriaxone that is above the mic, then assess the mean of times where free ceftriaxone is above 50% per simulated subject. We can see that the probability of target attainment is around 99.6%. We can also visualize the free ceftriaxone concentration over time with a red line indicating the mic of 1. Not too shabby! Now let’s assess when there is a difference in CrCl and albumin. I’ll spare you the code.

Changes in CrCl

code

library(glue)

crcl_vec <- c(1.8,7.2,10.8)
crcl_vec_i <- c(30, 120, 180)

# 30 ml/min = 1.8 L/hr
# 120 ml/min = 7.2 L/hr
# 180 ml/min = 10.8 L/hr

for (crcl in crcl_vec) {

mod <- mcode(model = "ceftriaxone", code=glue('
$PARAM
theta1 = 0.56,
theta2 = 0.32,
CLcr   = {crcl},
V1     = 10.3,
V2     = 7.35,
Q      = 5.28,  
fu     = 0.10  // fraction of unbound, picked a static value from package insert range

$CMT CENT PERI

$MAIN
double CL  = theta1 + theta2 * (CLcr / 4.26);  // technically we could use 0.88 as reported on their result section
double CLi = CL * exp(ETA(1));                  // ETA here means log normal distibution of mean 
double V1i = V1 * exp(ETA(2));     
double V2i = V2 * exp(ETA(3));

$OMEGA
0.24   // omega2(CL) from table
0.23
0.42

$SIGMA
0.0576   // √0.0576 = 0.24, 

$ODE
dxdt_CENT = -(CLi/V1i)*CENT - (Q/V1i)*CENT + (Q/V2i)*PERI;
dxdt_PERI =  (Q/V1i)*CENT   - (Q/V2i)*PERI;

$TABLE
double Cp_total = (CENT / V1i)*(1+EPS(1)); 
double Cp_free = fu * Cp_total;

$CAPTURE Cp_free
',crcl))

dosing <- ev(amt = 2000, rate = 4000, ii = 24, addl = 2, cmt = "CENT")

set.seed(1)
sims <- mod |>
  ev(dosing) |>
  mrgsim(nid = 1000, end = 72, delta = 0.25) |>
  as_tibble()

MIC <- 1

pta <- paste0("Probability of Target Attainment: ", sims |>
  filter(time >= 48) |>
  group_by(ID) |>
  summarise(fT = mean(Cp_free > MIC)) |>
  summarise(PTA = mean(fT >= 0.50)) |>
  pull(), " ,CrCl: ", crcl_vec_i[crcl_vec==crcl], "ml/min")


plot <- sims |>
  ggplot(aes(x=time,y=Cp_free,group=ID)) +
  geom_line(alpha=0.01) +
  geom_hline(yintercept = MIC, color = "red") +
  theme_bw() +
  ggtitle(pta)

plot(plot)
}

That’s interesting! That makes sense, increased CrCl will increase clearance of ceftriaxone, hence decrease in PTA. It’s still pretty good though! Though, what is considered acceptable? 90%? 70%? 50%? Also, the above PTA is based on 50% of a time free ceftriaxone is above MIC. What is the acceptable number for that then? 🤷‍♂️ What if, since ceftriaxone is albumin bound, if we model albumin into the model as well?

Changes With Hypoalbuminemia

Note: Important update. DO NOT READ THIS WITHOUT LOOKING AT THE UPDATE SECTION DOWN BELOW. THE FORMULA PROVIDED HERE IS WRONG.

Notice that our initial model had a fixed fraction of unbound (fu) of 0.1, which is the middle of the range reported in the package insert. However, in critically ill patients, hypoalbuminemia is common and can lead to an increase in the fraction of unbound drug, which can affect the pharmacokinetics and pharmacodynamics of ceftriaxone. Let’s see how we can model this in our mrgsolve code. From the paper in method section, they used the formula below to estimate free ceftriaxone from total ceftriaxone:

We’ll add that to our model and adjust the np (total concentration of protein binding sites) according to estimate with lower albumin (np = 295), this number again was from the paper in the discussion portion where their median albumin were ~25g/L.

code

mod <- mcode(model = "ceftriaxone", code='
$PARAM
theta1 = 0.56,
theta2 = 0.32,
CLcr   = 4.26,
V1     = 10.3,
V2     = 7.35,
Q      = 5.28,
np     = 517,  
kaff   = 0.0367 

$OMEGA
0.24
0.23
0.42

$SIGMA
0.0576

$CMT CENT PERI

$GLOBAL
double solveFree(double CTOT, double np, double kaff) {
  double cf   = (-(np+1/kaff-CTOT)+sqrt(pow(np+1/kaff-CTOT,2.0)+(4.0*CTOT/kaff)));
  return cf > 0 ? cf : 0;
}

$MAIN
double CL  = theta1 + theta2 * (CLcr / 4.26);
double CLi = CL * exp(ETA(1));
double V1i = V1 * exp(ETA(2));
double V2i = V2 * exp(ETA(3));

$ODE
double CTOT  = CENT / V1i;           // renamed: avoid clash with $TABLE
double CFREE = solveFree(CTOT, np, kaff);

dxdt_CENT = -CLi * CFREE
            - (Q / V1i) * CENT
            + (Q / V2i) * PERI;

dxdt_PERI =  (Q / V1i) * CENT
            - (Q / V2i) * PERI;

$TABLE
double CTOTAL      = CENT / V1i;      // notice this is not CTOT
double Cp_free     = solveFree(CTOTAL, np, kaff);
double Cp_bound    = CTOTAL - Cp_free;
double FU          = Cp_free / (CTOTAL + 1e-9);
double Cp_obs      = CTOTAL * (1 + EPS(1));

$CAPTURE CTOTAL Cp_free Cp_bound FU Cp_obs
')

dosing <- ev(amt = 2000, rate = 4000, ii = 24, addl = 2, cmt = "CENT")

set.seed(1)
sims <- mod |>
  param(np = 295) |>
  ev(dosing) |>
  mrgsim(nid = 1000, end = 72, delta = 0.25) |>
  as_tibble()

MIC <- 1

pta <- paste0("Probability of Target Attainment: ", sims |>
  filter(time >= 48) |>
  group_by(ID) |>
  summarise(fT = mean(Cp_free > MIC)) |>
  summarise(PTA = mean(fT >= 0.50)) |>
  pull(),", Albumin: ~25g/L, CrCl: ~63 ml/min")

plot <- sims |>
  ggplot(aes(x=time,y=Cp_free,group=ID)) +
  geom_line(alpha=0.01) +
  geom_hline(yintercept = MIC, color = "red") +
  # geom_text(aes(x=20,y=150,label=pta)) +
  theme_bw() +
  ggtitle(pta)

plot(plot)

Wow, that’s interesting! After we correctly fit in the free ceftriaxone estimation, it actually improved the PTA even when albumin is lower. What if we make albumin even lower to ~15g/L (np=~172), and increase our CrCl to 180 ml/min, and increase our fT >= 0.7 (more than 70% of the time free ceftriaxone is above mic), and see if we’ll be able to clear the medication faster?

PTA is still 100% !?!?! wow, ceftriaxone 2g really is a beast! Hmmm.. The free ceftriaxone is REALLY high, around ~200-300, can we simulate a q48h dosing and see what the PTA is like, even for our worse case scenario, low albumin, high CrCl, and stil cover ft>mic >= 70%?

?q48 Dosing

code

dosing <- ev(amt = 2000, rate = 4000, ii = 48, addl = 2, cmt = "CENT")

set.seed(1)
sims <- mod |>
  param(np = 172, CLcr = 10.8) |>
  ev(dosing) |>
  mrgsim(nid = 1000, end = 144, delta = 0.25) |>
  as_tibble()

MIC <- 1

pta <- paste0("PTA: ", sims |>
  filter(time >= 48) |>
  group_by(ID) |>
  summarise(fT = mean(Cp_free > MIC)) |>
  summarise(PTA = mean(fT >= 0.70)) |>
  pull(),", Albumin: ~15g/L, CrCl: ~180 ml/min, fT > mic >= 70%, q48h dosing")

plot <- sims |>
  ggplot(aes(x=time,y=Cp_free,group=ID)) +
  geom_line(alpha=0.01) +
  geom_hline(yintercept = MIC, color = "red") +
  theme_bw() +
  ggtitle(pta)

plot(plot)

Seriously!? PTA is still so high !? What does this actually mean? Is there literature on this? Maybe my code is not right… 🤔🤷‍♂️

Let’s look at fT > mic >= 99%.

## [1] "PTA: 0.979, Albumin: ~15g/L, CrCl: ~180 ml/min, fT > mic >= 99%, q48h dosing"

If you know anything about this, please let me know! this is for organism with mic <= 1, ceftriaxone 2g. Again, make note that this is purely for educational and learning purposes. The finding we got above is just a curious exploration. I wonder if there is some coding error on my part. Click the code above to expand for details. I also wonder if most of the trials we had before were based on higher mic, whereas the mic nowadays for ceftriaxone are mainly <= 1. 🤔

Update !!!

Apparently, our unit conversion above for free ceftriaxone was in mmol/L but the CENT/V1 was in mg/L. That will do it! Now let’s put the conversion in the model and see what we got?

😵‍💫 Ok. This looks more believable! The problem earlier on was because we did not convert mmol/L to mg/L. Kind of wished the article would have just used mg/L to begin with when calculating np (otal concentration of protein binding sites). Alright, all of our calculation with albumin were wrong!!! Let’s recalculate the others.

Looking at the above, q24h dosing is still pretty good! 👍

Wow, that’s good that we continue to be skeptical of a result that is “too good to be true” and continued to look into it. What I did was, I basically used Claude Code in a temp folder where it contains my blog content and also the pdf of the article we used and ask the question, “is the q48 dosing result robust?” and eventually Claude Code found the problem! I’m very impressed!

Opportunities For Improvement

Learn how they model popPK, this will really help us understand how they got those theta and omega estimates
I don’t quite understand the sigma portion yet, will dive into this the next time, especially when estimating these values
Try to learn other properties such as AUC/mic, Cmax/mic etc, and see how the PTA changes
Learn more from literature which is preferred regarding acceptable free medication level above mic and acceptable PTA
rewrite model in the future to include units in the comments, so that we don’t have the same mistake again

Lessons learnt

learnt some mrgsolve model coding (uses cpp)
learnt some basic pk/pd equations, popPK
learnt about the 2 compartments
found unexpected result for q48 dosing through simulation, still not sure if this is something real/true
learnt that thetas are not related to central/peripheral, rather theta1 is baseline clearance and theta2 is ?renal scaling
learnt big mistake in unit discordance causing erroneous results

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Learning Carbapenemase Producing Genes

Mon, 02 Mar 2026 00:00:00 +0000

Learnt major carbapenemase genes (KPC, NDM, OXA) using NCBI isolate data and molecular dynamics. Includes gene frequency trends, co-resistance patterns, and MM/PBSA binding comparisons of avibactam with KPC vs NDM to illustrate mechanistic differences 🧬

Motivations:

We’ve previously learnt about ESBL genes and took a peek under the hood of the nucleotides and explore NCBI library and assess their frequency. Why not let’s pick another AMR gene and learn! Let’s explore Carbapenemase producing organisms! In this blog, we’ll spare you the code, as we basically use the same workflow previous, change a few search keys and variables and out comes the result!

Objectives:

Which Are Carbapenemase Producing Genes?

These are the major carbapanemase:
class A - KPC.
class B Metallo-B-lactamases (MBLs) - NDM, VIM, IMP.
class D - OXA-48, OXA-181, OXA-232, OXA-244.

Carbapenemases are classified into three molecular classes based on their hydrolytic mechanism. Class A & D carbapenemases all utilizing a serine-based active site. Class B MBLs rely on zinc in their active site. This is interesting, because while Avibactam was developed to have activities against Class A, C, and D beta-lactamases. However, it does not work on Class B! 😵‍💫 Hence, before susceptibility result is back, knowing which carbapenemase exists would be ideal. In fact the NG-Test CARBA 5 (also called “Carba 5”) is a rapid immunochromatographic lateral flow assay that detects and differentiates the five most common carbapenemase families: KPC, NDM, VIM, IMP, and OXA-48-like. I heard it takes about 15 minutes to run one colony.

Interesting thing on MBL-producing Enterobacterales, the IDSA recommends either ceftazidime-avibactam + aztreonam combination therapy or cefiderocol monotherapy. The rationale for the combination is that aztreonam (a monobactam) is stable against metallo-β-lactamases, while avibactam inhibits the serine β-lactamases (ESBLs, AmpC, KPC, OXA-48-like) that frequently co-exist in MBL-producing organisms and would otherwise hydrolyze aztreonam.

How Are We Going To Do This?

Well, first of all, let’s get all NCBI bacterial isolates fasta with meropenem resistance here. Then download all carbapenemase producing genese, here, then insert this gene_family:(blaKPC blaNDM blaVIM blaIMP blaOXA-48 blaOXA-181 blaOXA-232 blaOXA-244) to the filter.

Then, run through the code we had previously here, assess exact match and visualize the frequency just like before! Assess what are the proportions of these fastas do not match our carbapenemase producing genes, as not all meropenem resistance is due to beta lactamases, some could be due to porin loss, overexpression of efflux pump, ESBL + porin loss, AmpC + porin loss!

After that, let’s visualize the distribution based on the submission dates.

Remember we mentioned that with MBLs we either need to use combination therapy of aztreonam + ceftaz/avibactam or cefidericol monotherapy due to co-existence of other resistance? Let’s take a look at all MBLs and see what other carbapenemase genes co-exist!

Lastly, lets test out our molecular dynamic experiment on KPC and NDM with avibactam! We should see a strong binding affinity for KPC and a very weak binding affinity for NDM! We’re going to include another post-simulation process called MM/PBSA and MM/GBSA as well. What that does it calculates the binding free energy of the ligand to the protein. The more negative the value, the stronger the binding affinity. This is a great way to quantify our results from our simulation and compare between different simulations!

Results

The Proportion of Carbapenemase producing Genes in Meropenem Resistant Organism?

We have a total of 1027 isolates, and 45.86% have detected carbapenamase genes! That’s with exact match, I did not check for low level mismatches.

The Frequency of Carbapanemase Genes

Wow, NDM-1 is at the top? I’ve always thought KPCs is more frequent. Note, these are the sequences that were submitted to NCBI, not necessarily resembling the actual distribution in the real world. But still, interesting to see that NDM-1 is more frequently submitted than KPCs.

Visualize Carbapanemase Gene Frequency By Year

Looking at the above, KPCs submissions were dominating up until 2018. In 2019, NDM-1 started to creep up to top 1. Since then, NDM-1 remained number one until 2025.

Do MBLs Frequently Have Co-resistance Of Other Carbapenamase?

primary_gene	gene	n
NDM-1	OXA-48	13
NDM-5	OXA-48	12
NDM-1	OXA-232	5
NDM-5	OXA-181	5
NDM-5	OXA-232	2
NDM-7	OXA-232	2
NDM-1	NDM-4	1
NDM-1	VIM-1	1
NDM-1	VIM-2	1

Interestingly when we look at MBL with co-resistance, it’s usually OXA-48 and OXA-48-like! But, when looking at all the MBLs (n=257) that were submitted, co-resistance with OXA is only 15.18% (n=39). There were 3 NDMs with another MBL. That makes sense to combine aztreonam and ceftaz/avibactam to counter OXA-48 beta lactamase. Note that we did not include ESBLs, ampC on our search.

Let’s Take a Look At Avibactam-KPC and Avibactam-NDM Molecular Dynamic Simulation

We’ll use the same pipeline as before, but this time we’ll add Molecular Mechanic / PBSA.

Installation

conda create -n gmxpbsa -c conda-forge gmx_mmpbsa ambertools
conda activate gmxpbsa

Write `mmpbsa.in`

You can use nano or nvim, then paste the below

&general
   startframe=1,
   endframe=500,
   interval=5,
   verbose=2,
/
&pb
   istrng=0.150,
   fillratio=4.0,
   inp=1,
   radiopt=0,
/

Note: Make sure to change the startframe and endframe to where the the protein rmsd and ligand rmsd is stable. Essentially sampling from the stable portion of the simulation.

When running MM/GBSA use the parameters below, maybe name is mmgbsa.in

&general
  startframe = 1,
  endframe = 500,
  interval = 1,
  verbose = 1,
  keep_files = 0,
/
&gb
  igb = 5,
  saltcon = 0.15,
/

To Run MM/PBSA or MM/GBSA

gmx_MMPBSA \
  -O \
  -i mmpbsa.in \
  -cs md.tpr \
  -ct md_noPBC.xtc \
  -ci index.ndx \
  -cg 1 13 \
  -cp topol.top \
  -o FINAL_RESULTS.dat \
  -eo FINAL_RESULTS.csv

Note: Make sure to write our regular pipeline first, create index etc, and leave the MM/PBSA or MM/GBSA until last.

Equation of the bond: Delta G_bind = Delta G_gas + Delta G_solv Where: Delta G_gas = gas-phase molecular mechanics energy (bonds, angles, dihedrals, van der Waals, electrostatics) BOND+ANGLE+DIHED+VDWAALS+EEL+1-4 VDW+1-4 EEL Delta G_solv = solvation free energy (how the molecule interacts with the surrounding water) EPB+ENPOLAR

Note: when you read the FINAL_RESULTS.csv, go to the last section, that’s the delta. Total = sum of all the columns except Total. Negative == 👍

KPC181-Avibactam

Alright, with the above, we have RMSD plateaud at around 20ns and RMSD ligand is pretty good and stable as well. Along with good H bonds and interaction energy, and reducing and converged minimal distance between protein and ligand and also distance between center of protein and ligand reduced and stablized as well. Let’s visualize the first frame and last frame to ensure before we run MM/PBSA and MM/GBSA.

Looks convincing! Let’s take a look at MM/PBSA and MM/GBSA.

Alright, we have quite a few columns in facets here, but most are not helpful since we have 0 data mainly because we used inp=1. But total binding energy is negative, which is good! You can see that on the TOTAL. The median (IQR) is -8.07(-16.79 - -1.29). Now what about GBPA ?

And the Median Total (IQR) is -10.615(-19.84 - -3.38) . Not too shabby!

NDM1-Avibactam

RMSD ligand seems quite big, hbond is intermittent, one of interaction energy crosses zero, the min distance variance is quite wide towards the end of simulation. From these numbers, it looked like it did not bind well, which is expected since avibactam does not work on MBLs. Let’s see visualize.

Wow, they’re not in the same position! It completely flipped! Usually in this setting, we shouldn’t need to perform MM/PBSA. But what if we did?

Wow, even though looking at TOTAL the median is in the negative, but you see significant fluctuations (large variance) with lots of zeros! Compare this to our previous MM/PBSA and MM/GBSA, you can see the difference!

What is interesting is that, I would imagine the ligand would have drifted away but it didn’t. Let’s investigate.

I think the ligand is stuck in the pocket as the protein was undergoing conformational change and stabilized after ~30ns, and I think it may have trapped the ligand in the pocket, hence it didn’t drift out of the pocket. I think 🤔 . Also, take note that the early simulation animation was without surface (only atoms), whereas the later one did have surface. With the matched protein and ligand of frame 0 and last frame proved that the initial pose was not optimal.

There you have it!

Note: While MM/PBSA provides relative binding estimates, these simulations do not capture full enzymatic hydrolysis dynamics and should be interpreted as comparative rather than absolute

Opportunities for improvement

need to learn ampC, porin loss, and other MDR genes
need to test our MM/PBSA and MM/GBSA more, adjust isp=2 and see how they look like
need to find a proper way to interpret/assess alphafold proteins prediction, which is considered good, which isn’t, and how to deal with them
need to dive into the math, physics, and organic chemistry of these simulations.
need to do replicates of 3, report seeds, and also include 2 other similar coordinate poses with high scores.
need to learnt covalent docking

Lessons Learnt

learnt carbapenemase genes
learnt MBLs may contain co-resistance of OXA, hence combo aztreonam
learnt MM/PBSA and MM/GBSA

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Assessing TEM, CTX-M, and KPC-2 With Molecular Docking and Molecular Dynamic Simulation

Sat, 21 Feb 2026 00:00:00 +0000

🧬 Testing beta-lactamase resistance with AlphaFold + DiffDock + GROMACS! Watch clavulanic acid bind TEM-5, CTX-M-15, KPC-2, and get rejected by TEM-30. Simulation confirms biology! 🔬💊

Motivations

Now that we’ve learnt the pipeline of molecular docking and molecular dynamic simulation. Let’s check some of the other proteins and ligand and see if these make sense. Let’s assess ESBL beta lactamase since we did something before ( here). Let’s check some of the hypothesis here, some TEMs are inhibitor resistant such as TEM-30, whereas ESBL beta lactamases like TEM-5 and CTX-M-15 can be susceptible to beta lactamase inhibitor such as clavulanic acid, whereas TEM-30, we should see that it won’t bind. We’ll also assess KPC2, which is a carbapanemase, it does bind to clavulanic acid, however, instead of being an inhibtor, it actually hydrolyzes it. But let’s see what MD results we get!

This time, we will get protein sequence of interest and use AlphaFold Server to predict our protein and generate pdb, and instead of relying on known coordinates of the protein, let’s use DiffDock to screen the best docking site, then use that for MD simulation. We will write some instructions on DiffDock, how to install and run it. But we will leave off the MD simulation part, we can refer to here. But I will run a good chunk of code to assess our results so that at least I don’t have to copy and paste multiple times to assess RMSD, RMSF, hydrogen bonds, gyration, and distance. We will also have some cool visuals! Let’s test this out!

Objectives:

Get Our Proteins

We go here and select the gene of interest and go to Refseq.

Then click on Fasta which will bring us to this.

Copy the protein sequence and we’ll move on to our next step. Also don’t forget to copy the other proteins of interest, in our case TEM-30, CTX-M-15, and KPC2.

Protein Prediction With AlphaFold

We will then visit Alphafold Server, you will have to login and then enter the sequence, and continue. Make sure to rename it to something you can recognize. Let it run, will likely take a minute. Then download it. Unzip it and you will see 5 cif files. I usually use the first one which ends with 0.

Using DiffDock to predict binding sites

Install

git clone https://github.com/gcorso/DiffDock.git
conda env create --file environment.yml
conda activate diffdock

You can check the github link out. From my experience, the above worked on Ubuntu but failed on my mac. I actually had to use Claude Code to help me install it. Could be just a me thing.

Let’s take a look at this protein with ChimeraX.

Do you see the big protein with a long tail? The long tail has low prediction score and is likely to be disordered, so we will remove that part and just keep the globular part. We can do that with ChimeraX, just select the tail and delete it. Then save it as a new pdb file.

Then we will run DiffDock to predict the binding site. We will use clavulanic acid as our ligand. You can download it from PubChem. Then we will run DiffDock with the following command:ea, we should be very careful not to use it.

obabel alphafold0.cif -O tem5.pdb

# make sure you're in DiffDock folder and has activate your conda env that used to install
python3 inference.py \
  --protein_path tem5.pdb \
  --ligand "OC(=O)[C@@H]2/C=C\1OC[C@@H](O)/C1=C\N2" \ 
  --out_dir results_tem5_step20 \
  --inference_steps 20 \
  --samples_per_complex 10 \
  --batch_size 5
  
# create ligand pdb
obabel rank1.sdf -O clav_acid.pdb

You see the ligand SMILES? 😀 We don’t need to download one from pubchem. You can just copy the SMILES from it. Woo hoo! Once you ran the above it will have 10 ranks. Open (with ChimeraX) the protein pdb first and then all the rank docked positions to visually assess the predicted docking sites.

Alright, it looks like there is one pocket (including the top 1 ranked position) is in that one pocket that in the middle of the picture.

If you take a look at the files produced by DiffDock, it ranks its confidence score at the end of the file, the lower the better.

Alright, go through the MD simulation procedure, wait and assess!

Note: I found that I could use 2 GTX 1080 and run each GPU with one protein-ligand interaction, and also use && and chain multiple mdrun commands so that it can go from one simulation to another after it’s done! For example gmx mdrun blab blah && cd /path/to/another && gmx mdrun blah blah. Also, make sure to use tmux when you’re running the production.

Assess Results

echo -e "\"Protein\" | \"UNL\"\nq" | gmx make_ndx -f md.gro -o index.ndx
echo "0" | gmx trjconv -s md.tpr -f md.xtc -o md_nojump.xtc -pbc nojump
echo "Protein_UNL System" | gmx trjconv -s md.tpr -f md_nojump.xtc -o md_noPBC.xtc -pbc mol -center -n index.ndx
echo '4 13' | gmx rms -s md.tpr -f md_noPBC.xtc -o rmsd_ligand.xvg -tu ns -n index.ndx
echo '4 4' | gmx rms -s md.tpr -f md_noPBC.xtc -o rmsd_protein.xvg -tu ns -n index.ndx
echo 4 | gmx rmsf -s md.tpr -f md_noPBC.xtc -o rmsf_protein.xvg -res 
echo 13 | gmx rmsf -s md.tpr -f md_noPBC.xtc -o rmsf_ligand.xvg 
echo '1' | gmx gyrate -s md.tpr -f md_noPBC.xtc -o gyrate.xvg 
echo '1 13' | gmx hbond -s md.tpr -f md_noPBC.xtc -num hbond_ligand_protein.xvg -tu ns 
echo '1 13' | gmx mindist -f md_noPBC.xtc -s md.tpr -od mindist_prot_lig.xvg -on numcont_prot_lig.xvg -d 0.4
gmx distance -f md_noPBC.xtc -s md.tpr -select 'com of group "Protein" plus com of group "UNL"' -oall distance_prot_lig.xvg
if grep -q "^;energygrps" md.mdp; then
    sed -i 's/^;energygrps/energygrps/' md.mdp
    echo "Uncommented energygrps"
elif grep -q "^energygrps" md.mdp; then
    echo "energygrps already active, doing nothing"
else
    echo "energygrps = Protein UNL" >> md.mdp
    echo "Added energygrps"
fi
gmx grompp -f md.mdp -c md.gro -p topol.top -o rerun.tpr 
gmx mdrun -s rerun.tpr -rerun md_nojump.xtc -e rerun.edr -ntmpi 1 -ntomp 4 
printf "Coul-SR:Protein-UNL\nLJ-SR:Protein-UNL\n0\n" | gmx energy -f rerun.edr -o interaction_energy.xvg
cp *.xvg /path/to/your/analysis

Note: Make sure to run the above after we’re done with all of the simulation, otherwise it will bottleneck both. Meaning, it will be slow for the above and also your active simulation. Well, I only have 4 core, so it might be different for yours! It might not matter at all. Above I would use -ntomp 2 if my other simulation is still running but i want to check the result.

Create function to visualize all

R Code

library(tidyverse)
library(xvm)
library(ggpubr)

plot_all <- function(path,int=T) {
prot <- read_xvg(paste0(path,"rmsd_protein.xvg"))
ligand <- read_xvg(paste0(path,"rmsd_ligand.xvg"))
rmsf_prot <- read_xvg(paste0(path,"rmsf_protein.xvg"))
rmsf_ligand <- read_xvg(paste0(path,"rmsf_ligand.xvg"))
gy <- read_xvg(paste0(path,"gyrate.xvg")) 
if (int) {
interaction <- read_xvg(paste0(path,"interaction_energy.xvg"))
plot_interaction <- plot_xvg(interaction)}
hbond <- read_xvg(paste0(path,"hbond_ligand_protein.xvg"))
mindist <- read_lines(paste0(path,"mindist_prot_lig.xvg"))
dist <- read_lines(paste0(path,"distance_prot_lig.xvg"))

plot_rmsd_prot <- plot_xvg(prot)
plot_rmsd_ligand <- plot_xvg(ligand)
plot_rmsf_prot <- plot_xvg(rmsf_prot)
plot_rmsf_ligand <- plot_xvg(rmsf_ligand)
plot_gy <- plot_xvg(gy)
plot_hbond <- tibble(hbond$hbond_ligand_protein.xvg$data) |> 
  distinct() |>
 ggplot(aes(x=`Time (ns)`,y=`Hydrogen bonds`)) +
 geom_line(color = "red", alpha=0.8) +
 theme_bw() +
  ggtitle("Hydrogen bonds")

mindist_list <- mindist[!str_detect(mindist, "^@|^#")] |> str_split(" ")
time <- mindist_val <- vector(mode = "numeric", length = length(mindist_list))
for (i in 1:length(mindist_list)) {
  time[i] <- mindist_list[[i]][1]
  mindist_val[i] <- mindist_list[[i]][3]
}

mindist_df <- tibble(time = time, mindist_val = mindist_val) |>
  mutate(time = as.numeric(time),
         mindist_val = as.numeric(mindist_val))

plot_mindist <- mindist_df |>
  ggplot(aes(x=time,y=mindist_val)) +
  geom_point(color = "red", alpha=0.7) +
  theme_bw() +
  ggtitle("Min Distance")


dist_list <- dist[!str_detect(dist, "^@|^#")] |> str_trim() |> str_split("    ")

time <- dist_val <- vector(mode = "numeric", length = length(dist_list))
for (i in 1:length(dist_list)) {
  time[i] <- dist_list[[i]][1] 
  dist_val[i] <- dist_list[[i]][2]
}

dist_df <- tibble(time = time, dist_val = dist_val) |>
  mutate(time = as.numeric(time),
         dist_val = as.numeric(dist_val))

plot_dist <- dist_df |>
  ggplot(aes(x=time,y=dist_val)) +
  geom_point(color = "red", alpha=0.7) +
  theme_bw() +
  ggtitle("Distance Between Protein and Ligand")

if (int) {
plotlist <- list(plot_rmsd_prot, plot_rmsd_ligand, plot_rmsf_prot, plot_rmsf_ligand,
                 plot_gy, plot_interaction, plot_hbond, plot_mindist, plot_dist) }
else {plotlist <- list(plot_rmsd_prot, plot_rmsd_ligand, plot_rmsf_prot, plot_rmsf_ligand,
                 plot_gy, plot_hbond, plot_mindist, plot_dist)}
return(ggarrange(plotlist = plotlist, ncol = 2))
}

TEM-5

plot_all("tem5_result/")

Overall, clavulanic acid and TEM-5 demonstrated stable binding throughout the 60 ns simulation. The protein RMSD plateaued early, confirming stable conformation, ligand rmsf has also plateaud. The total radius of gyration remained largely stable, and both Coulombic and Lennard-Jones interaction energies stayed consistently negative, indicating favorable protein–ligand interactions. Hydrogen bonds were maintained at around 2–4 throughout the simulation, which is adequate for a small molecule ligand. Both the center-of-mass and minimum distances converged to stable low values and remained consistent for the remainder of the trajectory. Collectively, these results support a successful molecular dynamics simulation with stable ligand binding.

CTX-M-15

plot_all("ctxm15_result/")

Overall, clavulanic acid and CTX-M-15 also demonstrated stable binding throughout the 50 ns simulation. Although the ligand RMSD shows significant noise — likely due to improper initial coordinate assignment when using the ACPYPE-generated .gro file instead of the docked ligand coordinates — the protein RMSD plateaued and remained stable. This is not a sign of dissociation as a true dissociation ( see here) would look like this. The total radius of gyration was similarly stable. Interaction energies and hydrogen bond counts were consistent throughout the trajectory, indicating sustained non-covalent interactions. Both the minimum distance and center-of-mass distance between the protein and ligand converged and remained low, further supporting stable binding. Also, upon visualizing the md.xtc in reference to the first frame of pdb, we can see there was at one point the ligand may have dissociated at a short period of time and then reattached.

TEM-30

plot_all("tem30_result/")

This simulation presents a clear case of true ligand dissociation, indicating that clavulanic acid does not bind well to TEM-30. Notably, the simulation terminated early. Both the protein and ligand RMSD rose continuously without plateauing, though the protein RMSD values may be inflated due to the same coordinate assignment error noted previously. More definitively, both hydrogen bond counts and interaction energies dropped to zero, and the minimum distance as well as the center-of-mass distance between the protein and ligand diverged progressively over time. Collectively, these findings confirm that stable binding was not achieved in this simulation. Below, you can see ligand flies away from the pocket site.

KPC2

plot_all("kpc2_result/")

Finally, the KPC-2 and clavulanic acid simulation also demonstrated stable binding throughout the 50 ns trajectory. As noted previously, the ligand RMSD cannot be accurately interpreted due to the coordinate assignment error. Nevertheless, both interaction energies and hydrogen bond counts remained consistent throughout, and the minimum distance as well as the center-of-mass distance between the protein and ligand converged to lower values and remained stable. Importantly, however, stable binding in this simulation does not imply that clavulanic acid acts as an inhibitor of KPC-2. In fact, KPC-2 is known to hydrolyze clavulanic acid — a covalent enzymatic process that a non-covalent molecular dynamics simulation such as this cannot capture or reflect.

Final Thought

Wow, having the previous workflow really helps with lower the risk of error! I definitely learnt that my mistake of using acpype coordinates have caused significant noise on rmsd ligand and should really use the docked ligand position to create the complex.gro. Still so much to learn! But this is a really cool simulation where we can test the tested hypothesis and see it with our own eyes! I’m so grateful and fortunate to be able to be at this time period to learn these without TOO much disappointments. And also so grateful for all these scientists to be able to share these techniques for free! That is truly amazing and inspiring! ❤️

Opportunities for improvement

I have been mistakenly using acpype gro coordinates to make complex.gro, where the rmsd ligand was way off but everything else seem to be fine. We should be using the docked pose to convert to gro using gmx editconf -f diffdock_pose.pdb -o ligand_positioned.gro
Learn how to find out if there is consistent non-covalent bond between ligand and protein, how do we then differentiate between the ligand inactivating the protein or that the protein hydrolyzes the ligand like KPC2
Learn how to perform covalent docking and covalent md simulation
rewrite md sim pipeline into something easier to automate. currently i have to copy and paste from my previous documentation, mind you it’s already REALLY helpful because i was able to do all those in the matter of minutes. Let’s see how we can further optimize that, more ergnomics.
Try colabfold locally to produce protein, might take some time

Lessons Learnt

I did not know that CTX-M-15 can bind to clavulanic acid, did the simulation first then realized it bound and verified literature and apparently it does! Simulation is another tool to help to learn something new!
I change the output md.mdp to 50000 instead of 5000 to reduce bottle neck between cpu and gpu
use && chaining to run one production after another
can independently use 2 or more GPU if motherboard allows
gromacs automatically chooses a GPU that has better capacity and assign that as 0?
need to center in order for a good visualization, otherwise you will see protein and ligand might split as it exits the edge of simulation box, it enters from the other end.

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Exploring Molecular Docking & Molecular Dynamic Simulations - A Note To Myself

Sat, 14 Feb 2026 00:00:00 +0000

🧬 Explored molecular docking & MD simulations with penicillin binding to PBP2x — lots of stumbling through GROMACS but slowly piecing it together! 💊 Still much more to learn, but we’re getting there! 🔬

Motivations:

Since last year I’ve been fascinated by how scientists are able to use computational methods and simulation of the physical world. Things such as moelcular dynamic is quite amazing! And we can learn by running through these processes. Since we know that penicillin binds to penicillin binding protein 2x, why don’t we use that as a stepping stone and see how far we can go? Oh, have you used Claude Code or OpenAI Codex? If not, these are great tools to maybe get to the end first and see the results and then document and learn step by step from 0 to n to get to that final result? I found that extremely helpful because I know that if this works, it should work by going through the steps again and there is light at the end of the tunnel! Also, not to mention, these tools as they’re getting to the end, will let you know if your machine is not powerful enough to get there 🤣 Now, buckle up! This is REALLY going to be bumpy. All codes are in bash. We’ll set a pipeline with either python or R in the future for more experiments!

Just so happen, today is Valentine’s Day. Happy Valentine’s Day! ❤️ Molecular docking and simulation is like a match making activity 🤣 What a coincidence!

Disclaimer:

I am not a biochemist. This blog serves as a note for reproducibility for my own and only for educational purposes and documentation of what worked and what didn’t, so that I won’t repeat the same mistake in the future. If you noticed any error, please educate me! Also, most codes below are run in Ubuntu bash, some in R for visualization. Also I used a lot of Claude to help discover, debug, learn.

Objectives:

Please take a look at this Gromacs Tutorials, has a lot o fanstastic code to help beginners like me!

What Is Molecular Docking & Molecular Dynamic Simulations?

Molecular docking is basically computational lock and key exploration - you’re predicting how a small molecule (like a medicine) will bind to a protein target by testing different orientations and conformations to find the lowest energy binding pose. It’s a static snapshot: protein and ligand are treated as relatively rigid (or semi-flexible), and you get binding scores that estimate affinity. Molecular dynamics (MD) simulation takes it way further - it’s like watching a molecular movie where you simulate the actual physics of atoms moving over time (picoseconds to microseconds), accounting for solvent, temperature, and all the wiggling and conformational changes that happen in real biological systems. Docking gives you the “where and how tight,” while MD gives you the “what happens next” - stability, induced fit, binding pathways, and whether that docked pose actually holds up when everything’s allowed to move realistically. You often use docking first to generate binding hypotheses, then validate or refine them with MD.

Molecular Docking

Installation

sudo apt update
sudo apt install autodock-vina # I have version `1.2.5`. 
sudo apt install openbabel # I have version 3.1.0

Download

Now, we have to download ligand and protein structures. Let’s go to RCSB and download our protein.

We’ll be working with Penicillin-binding Protein 2x.

This one is from Streptococcus pneumoniae with cefepime already bound to it. So at least we know where is the binding site and we can estimate using the coordinates on our penicillin.

Download the pdb. If we use ChimeraX to visualize the pdb, it will look something like this. With the ligand (cefepime) highlighted in green.

If we simply just read the pdb file of what we just downloaded, as you scroll through you will see ATOM means standard protein/nucleic acid atoms and HETATM = heteroatoms like ligands, waters or ions.

In the middle where we see lots of columns of numbers, the xyz coordinates of where ligand (cefepime aka 9WT) is located on this protein. We will use this coordinate to set up our docking later on. Take note that in the middle where we see lots of columns of numbers, the xyz coordinates of where ligand (cefepime aka 9WT) is located on this protein. The coordinates are around x=30, y=-15, z=50. Remember this, because we will need this for docking.

Next we’ll download a penicillin G where we will go to PubChem instead.

Convert Protein and Ligand Structures

This is not always the case, but because of our protein already contains a ligand, let’s remove that ligand and createa clean pbp2x_protein.pdb then pdbqt which is the format that vina uses.

# remove ligand from protein pdb
grep "^ATOM" 5OJ0.pdb > pbp2x_protein.pdb

# convert pdb and sif files to pdbqt for autodock
obabel pbp2x_protein.pdb -O pbp2x_protein.pdbqt -xr #(-xr removes non-polar hydrogens)
obabel Conformer3D_COMPOUND_CID_5904.sdf -O pcn.pdbqt -xh #(-xh add hydrogen needed for proper docking)

Run Vina

vina --receptor pbp2x_protein.pdbqt --ligand pcn.pdbqt \
     --center_x 30.0 --center_y -15.0 --center_z 50.0 \
     --size_x 30.0 --size_y 30.0 --size_z 30.0 \
     --exhaustiveness 16 \
     --num_modes 1 \
     --out pcn_docked.pdbqt 

## turn pdbqt back to pdb
obabel pcn_docked.pdbqt -O pcn_docked.pdb

--num_nodes will only show the top 1 predicted pose and turn it into pcn_docked.pdbqt. We will convert this back to pdb for visualization and later use in molecular dynamic simulations.

After it’s done. It will look something like this. For more question and answer information please see this. It has a lot of answers, one of them is what is a good search size?

You should probably avoid search spaces bigger than 30 x 30 x 30 Angstrom, unless you also increase “–exhaustiveness”.

With affinity of -6.83 kcal/mol. Is this considered OK? From my shallow reading, the smaller the better. General < -7 is good (some said -10 arbitarily). If it’s > -5, it means it’s less likely to bind. So this is borderline, but we can still use it for molecular dynamic simulations to see if it holds up. But before that, let’s try an experiment, what if we dock a compound that we know doesn’t bind to this protein, say aspirin?

Alright! Pretty good! -4.968 is the predicted binding affinity of aspirin to our protein target. Much less than our penicillin! Ideally with virtual screening, we want to have a lot of ligands that we want to run through and find the top hits.

Molecular Dynamic Simulation

Install Gromacs

# Install dependencies
sudo apt update
sudo apt install -y build-essential cmake git libfftw3-dev libopenmpi-dev wget

# Install NVIDIA drivers and CUDA (if not already installed)
sudo apt install -y nvidia-driver-535 nvidia-cuda-toolkit

# Download GROMACS
cd ~
wget https://ftp.gromacs.org/gromacs/gromacs-2024.4.tar.gz
tar xfz gromacs-2024.4.tar.gz
cd gromacs-2024.4

# Build with GPU support
mkdir build
cd build
cmake .. -DGMX_BUILD_OWN_FFTW=ON -DGMX_GPU=CUDA -DCUDA_TOOLKIT_ROOT_DIR=/usr/lib/cuda -DREGRESSIONTEST_DOWNLOAD=ON
make -j$(nproc)
sudo make install

# Add GROMACS to PATH permanently
echo 'source /usr/local/gromacs/bin/GMXRC' >> ~/.bashrc
source ~/.bashrc

# Verify installation
gmx --version

# Test GPU detection
gmx detect

Prepare Protein For Gromac

gmx pdb2gmx -f pbp2x_protein.pdb -o pbp2x_processed.gro -water tip3p -ff amber99sb-ildn

What this does is that it converts your protein PDB file into a simulation-ready format by adding hydrogen atoms, applying the AMBER99SB-ILDN force field parameters, and selecting the TIP3P water model. It outputs a processed structure file pbp2x_processed.gro and a topology file topol.top that contains all the molecular interaction parameters needed for running molecular dynamics simulations.

Prepare Ligand

acpype -i pcn_docked.mol2 -n 0 -a gaff2 -c bcc

This will create a directory called pcn_docked.acpype. what acpype does is that it takes your ligand structure (in this case pcn_docked.pdb) and generates the necessary topology and coordinate files for GROMACS. It uses the Antechamber tool to assign atom types and partial charges based on the AMBER force field, and outputs files like pcn_docked_GMX.itp (topology) and pcn_docked_GMX.gro (coordinates) that can be directly included in your GROMACS simulations.

Create Position Restraints For The Ligand

echo 0 | gmx genrestr -f pcn_docked.acpype/pcn_docked_GMX.gro \
             -o posre_ligand.itp \
             -fc 1000 1000 1000
             
## echo 0 means select "system"

Why do we need to do this? Because we want to make sure that our ligand doesn’t fly away during the equilibration phase. By creating a position restraint file for the ligand, we’re essentially telling GROMACS to apply a strong force (1000 kJ/mol/nm) to keep the ligand in place while the rest of the system (protein, water, ions) relaxes around it. This is especially important if we want to see how well our docked pose holds up under more realistic conditions without it drifting away from the binding site. I will use this ⛓️‍💥 to remind us where it is applied

Edit topol.top

By now you should have topol.top file. Open it and scroll down to

; Include Position restraint file
#ifdef POSRES
#include "posre.itp"
#endif

then add these chunk after it

; Include ligand position restraint file
#ifdef POSRES_LIGAND
#include "posre_ligand.itp"    ; remember this ⛓️‍💥 ?
#endif

Do you remember posre_ligand.itp that we created here ? We want to include this in topol.top so that when we’re at the phase of NVT and NPT, it will call this file to apply the restraint. We’re not done yet! More editing! Scary, right? I know.

After this, include these on your topol.top file as well.

#include "amber99sb-ildn.ff/forcefield.itp"
#include "pcn_docked.acpype/pcn_docked_GMX.itp"  ; Include ligand topology

[ system ]
Protein-Ligand Complex

[ molecules ]
Protein_chain_A    1
pcn_docked                1  ; Your ligand name from pcn_docked_GMX.itp

Take note that in [molecules] you have to insert your specific ligand name in your .itp file made from acpype.

Create The Complex

I’ve written myself a little cheat to do this by code

code

python3 << 'PYEOF'
   # Combine protein and ligand GRO files into complex.gro                      
                                         
   protein = "/your/path/pbp_test/pbp2x_processed.gro"
   ligand = "/your/path/pbp_test/pcn_docked.acpype/pcn_docked_GMX.gro"
   output = "/your/path/pbp_test/complex.gro"

   with open(protein) as f:
       prot_lines = f.readlines()

   with open(ligand) as f:
       lig_lines = f.readlines()

   # Parse protein
   prot_title = prot_lines[0].strip()
   prot_natoms = int(prot_lines[1].strip())
   prot_atoms = prot_lines[2:2+prot_natoms]
   prot_box = prot_lines[2+prot_natoms].strip()

   # Parse ligand
   lig_natoms = int(lig_lines[1].strip())
   lig_atoms = lig_lines[2:2+lig_natoms]

   total_atoms = prot_natoms + lig_natoms

   # GRO format: residue number (5 chars), residue name (5 chars), atom name
   (5 chars),
   # atom number (5 chars), x y z (8.3f each)
   # Atom numbers wrap at 99999

   with open(output, 'w') as f:
       f.write(f"{prot_title} with ligand\n")
       f.write(f"{total_atoms}\n")

       # Write protein atoms as-is
       for line in prot_atoms:
           f.write(line)

       # Write ligand atoms, renumbering atoms continuing from protein
       # Get the last residue number from protein
       last_prot_resnum = int(prot_atoms[-1][:5])
       new_resnum = last_prot_resnum + 1

       for i, line in enumerate(lig_atoms):
           # Renumber residue and atom
           atom_num = (prot_natoms + i + 1) % 100000
           # Format: %5d%-5s%5s%5d%8.3f%8.3f%8.3f
           resname = line[5:10]  # residue name
           atomname = line[10:15]  # atom name
           x = line[20:28]
           y = line[28:36]
           z = line[36:44]
           vel = line[44:] if len(line) > 44 else ""

           new_line =
   f"{new_resnum:5d}{resname}{atomname}{atom_num:5d}{x}{y}{z}"
           if vel.strip():
               new_line += vel
           else:
               new_line += "\n"
           f.write(new_line)

       # Write box vectors from protein
       f.write(f"{prot_box}\n")

   print(f"Combined {prot_natoms} protein + {lig_natoms} ligand =
   {total_atoms} total atoms")
   print("Written to complex.gro")

   # Verify
   with open(output) as f:
       lines = f.readlines()
   print(f"Output file: {len(lines)} lines")
   print(f"Header: {lines[0].strip()}")
   print(f"Atom count: {lines[1].strip()}")
   print(f"Last atom line: {lines[-2].strip()}")
   print(f"Box: {lines[-1].strip()}")
   PYEOF

Note: The above code may not work. Might have to rewrite it to make it more robust

We essentially want to combine our pbp2x_processed.gro, remember this?, and also our pcn_docked.gro, into a single protein-ligand complex and call it complex.gro.

Convert Oringally Docked Pose To gro

gmx editconf -f pcn_docked.pdb -o pcn_docked.gro

You go to this:

Then copy this:

Change the total atoms numbers 100842 from 10041 + 41 = 10082. Then insert the pcn_docked.gro coordinates right after the protein’s coordinates like so.

Warning! Note: Do not use acpype gro because the coordinates may not be the same, use this something like this gmx editconf -f diffdock_pose.pdb -o ligand_positioned.gro from your original docked pose pdb.

Define Simulation Box

gmx editconf -f complex.gro -o complex_box.gro -c -d 1.0 -bt dodecahedron

Before we can do anything useful, we need to give our protein-ligand complex a “home” — and that’s exactly what this step does. We’re using gmx editconf to center the complex and build a box around it, leaving at least 1.0 nm of breathing room between the protein and the box walls so things don’t awkwardly interact with themselves across periodic boundaries. We’re going with a dodecahedron shape instead of a plain cube because it’s more sphere-like, which means we need to fill it with about 30% less water — and less water means faster simulations. I think…

Solvate The System

gmx solvate -cp complex_box.gro -cs spc216.gro -o complex_solv.gro -p topol.top

A protein floating in an empty box isn’t very biologically realistic, so let’s add some water. gmx solvate takes the pre-equilibrated SPC/E water model (spc216.gro) and floods our box with water molecules around the complex. It also automatically updates topol.top to keep track of how many water molecules were added

Add Ions

Make sure to create ion.mdp before hand with the following parameter

ion.mdp

; ion.mdp - Parameters for adding ions

; Run control
integrator = steep        ; Steepest descent minimization
nsteps     = 50000        ; Maximum number of steps
emtol      = 1000.0       ; Convergence when max force < 1000 kJ/mol/nm
emstep     = 0.01         ; Initial step size (nm)

; Output control
nstlog     = 500          ; Frequency to write to log file
nstenergy  = 500          ; Frequency to write energies

; Neighbor searching
cutoff-scheme = Verlet
ns-type       = grid
nstlist       = 10
rlist         = 1.0       ; Short-range cutoff (nm)

; Electrostatics
coulombtype   = PME       ; Particle Mesh Ewald
rcoulomb      = 1.0       ; Coulomb cutoff (nm)

; Van der Waals
vdwtype       = Cut-off
rvdw          = 1.0       ; VdW cutoff (nm)

; Periodic boundary conditions
pbc           = xyz       ; 3D periodic boundaries

; Temperature and pressure (not really used, but good practice)
tcoupl        = no
pcoupl        = no
gen-vel       = no

Then to add ions

gmx grompp -f ion.mdp -c complex_solv.gro -p topol.top -o ion.tpr -maxwarn 1
echo 15 | gmx genion -s ion.tpr -o complex_solv_ions.gro -p topol.top -pname NA -nname  CL -neutral 
## select 15 or SOL

Our solvated system is probably carrying a net charge at this point, and running a simulation like that is a recipe for trouble. To fix this, we first prep a run input file with gmx grompp, then use gmx genion to swap out some water molecules for sodium (NA) and chloride (CL) ions. The -neutral flag handles the math for you and adds just enough ions to zero out the total charge.

Note: I learnt that -maxwarn can sometimes be a problem, if you use it too routinely, eventually something will break either during EM, NVT, NPT, or production. I try to debug it when there is a warning to make sure it doesn’t cause a problem later on.

Energy Minimization

Make sure to create em.mdp before hand with the following parameter

em.mdp

; Energy minimization parameters
integrator  = steep         ; Steepest descent minimization
emtol       = 1000.0        ; Stop when max force < 1000.0 kJ/mol/nm
emstep      = 0.01          ; Initial step size
nsteps      = 50000         ; Maximum number of steps

; Output control
nstlog      = 100           ; Write to log file every 100 steps
nstenergy   = 100           ; Write energies every 100 steps

; Neighbor searching
cutoff-scheme = Verlet
nstlist     = 10
ns_type     = grid
pbc         = xyz           ; Periodic boundary conditions

; Electrostatics
coulombtype = PME
rcoulomb    = 1.0

; Van der Waals
vdwtype     = Cut-off
rvdw        = 1.0

; Temperature and pressure coupling (off for EM)
tcoupl      = no
pcoupl      = no

gmx grompp -f em.mdp -c complex_solv_ions.gro -p topol.top -o em.tpr
gmx mdrun -v -deffnm em

At this point the system is solvated and neutralized, but it’s probably a bit of a mess geometrically — atoms may be too close together, bonds at weird angles, that sort of thing. Energy minimization is basically the “calm down” step where we let GROMACS iron out all those clashes and bad geometries before we start any real dynamics. We’re using the steepest descent algorithm, which just keeps nudging atoms downhill on the energy landscape until the forces are small enough that we’re happy. No actual physics happening here — just cleaning up the structure so we have a solid starting point.

NVT Equilibration

Make sure to create nvt.mdp before hand with the following parameter

nvt.mdp

; NVT EQUILIBRATION
; Position restraints on protein and ligand
define = -DPOSRES -DPOSRES_LIGAND.  ; remember this? ⛓️‍💥

; Run parameters
integrator              = md        ; leap-frog integrator
nsteps                  = 50000     ; 2 * 50000 = 100 ps
dt                      = 0.002     ; 2 fs
; Output control
nstxout                 = 500       ; save coordinates every 1.0 ps
nstvout                 = 500       ; save velocities every 1.0 ps
nstenergy               = 500       ; save energies every 1.0 ps
nstlog                  = 500       ; update log file every 1.0 ps
nstxout-compressed      = 500       ; save compressed coordinates every 1.0 ps
compressed-x-grps       = System    ; save the whole system
; Bond parameters
continuation            = no        ; first dynamics run
constraint_algorithm    = lincs     ; holonomic constraints 
constraints             = h-bonds   ; bonds involving H are constrained
lincs_iter              = 1         ; accuracy of LINCS
lincs_order             = 4         ; also related to accuracy
; Nonbonded settings 
cutoff-scheme           = Verlet    ; Buffered neighbor searching
ns_type                 = grid      ; search neighboring grid cells
nstlist                 = 10        ; 20 fs, largely irrelevant with Verlet
rcoulomb                = 1.0       ; short-range electrostatic cutoff (in nm)
rvdw                    = 1.0       ; short-range van der Waals cutoff (in nm)
DispCorr                = EnerPres  ; account for cut-off vdW scheme
; Electrostatics
coulombtype             = PME       ; Particle Mesh Ewald for long-range electrostatics
pme_order               = 4         ; cubic interpolation
fourierspacing          = 0.16      ; grid spacing for FFT
; Temperature coupling
tcoupl                  = V-rescale             ; modified Berendsen thermostat
tc-grps                 = Protein Non-Protein   ; two coupling groups - more accurate
tau_t                   = 0.1     0.1           ; time constant, in ps
ref_t                   = 300     300           ; reference temperature, one for each group, in K
; Pressure coupling
pcoupl                  = no        ; no pressure coupling in NVT
; Periodic boundary conditions
pbc                     = xyz       ; 3-D PBC
; Velocity generation
gen_vel                 = yes       ; assign velocities from Maxwell distribution
gen_temp                = 300       ; temperature for Maxwell distribution
gen_seed                = -1        ; generate a random seed

gmx grompp -f nvt.mdp -c em.gro -r em.gro -p topol.top -o nvt.tpr
gmx mdrun -deffnm nvt -nb gpu -pme gpu -bonded gpu

# or with cpu
gmx mdrun -deffnm nvt

Now the real fun begins — sort of. Before we let everything run free, we need to carefully bring the system up to temperature while keeping the protein and ligand held in place with position restraints. This NVT (constant volume and temperature) run heats things up to 300 K over 100 ps using the V-rescale thermostat, while the water and ions get to move around and settle in naturally. Think of it like slowly warming up before a workout.

NPT Equilibration

Make sure to create npt.mdp before hand with the following parameter

npt.mdp

; NPT EQUILIBRATION
; Position restraints on protein and ligand
define = -DPOSRES -DPOSRES_LIGAND.  ; remember this? ⛓️‍💥

; Run parameters
integrator              = md        ; leap-frog integrator
nsteps                  = 50000     ; 2 * 50000 = 100 ps
dt                      = 0.002     ; 2 fs
; Output control
nstxout                 = 500       ; save coordinates every 1.0 ps
nstvout                 = 500       ; save velocities every 1.0 ps
nstenergy               = 500       ; save energies every 1.0 ps
nstlog                  = 500       ; update log file every 1.0 ps
nstxout-compressed      = 500       ; save compressed coordinates every 1.0 ps
compressed-x-grps       = System    ; save the whole system
; Bond parameters
continuation            = yes       ; continuing from NVT
constraint_algorithm    = lincs     ; holonomic constraints 
constraints             = h-bonds   ; bonds involving H are constrained
lincs_iter              = 1         ; accuracy of LINCS
lincs_order             = 4         ; also related to accuracy
; Nonbonded settings 
cutoff-scheme           = Verlet    ; Buffered neighbor searching
ns_type                 = grid      ; search neighboring grid cells
nstlist                 = 10        ; 20 fs, largely irrelevant with Verlet
rcoulomb                = 1.0       ; short-range electrostatic cutoff (in nm)
rvdw                    = 1.0       ; short-range van der Waals cutoff (in nm)
DispCorr                = EnerPres  ; account for cut-off vdW scheme
; Electrostatics
coulombtype             = PME       ; Particle Mesh Ewald for long-range electrostatics
pme_order               = 4         ; cubic interpolation
fourierspacing          = 0.16      ; grid spacing for FFT
; Temperature coupling
tcoupl                  = V-rescale             ; modified Berendsen thermostat
tc-grps                 = Protein Non-Protein   ; two coupling groups - more accurate
tau_t                   = 0.1     0.1           ; time constant, in ps
ref_t                   = 300     300           ; reference temperature, one for each group, in K
; Pressure coupling
pcoupl                  = Parrinello-Rahman     ; Pressure coupling on in NPT
pcoupltype              = isotropic             ; uniform scaling of box vectors
tau_p                   = 2.0                   ; time constant, in ps
ref_p                   = 1.0                   ; reference pressure, in bar
compressibility         = 4.5e-5                ; isothermal compressibility of water, bar^-1
refcoord_scaling        = com                   ; scale center of mass of reference coordinates
; Periodic boundary conditions
pbc                     = xyz       ; 3-D PBC
; Velocity generation
gen_vel                 = no        ; velocity generated in NVT

gmx grompp -f npt.mdp -c nvt.gro -r nvt.gro -t nvt.cpt -p topol.top -o npt.tpr
gmx mdrun -deffnm npt -nb gpu -pme gpu -bonded gpu

# or with cpu
gmx mdrun -deffnm npt

Temperature is sorted, now let’s get the pressure and density right too. In this NPT (constant pressure and temperature) step, we swap in the Parrinello-Rahman barostat to let the box size adjust until the pressure stabilizes at 1.0 bar. The protein and ligand are still restrained here — we’re just letting the solvent finish getting comfortable. This step is what makes sure your water density is physically reasonable before you remove the training wheels and start production. Another 100 ps and you’re good to go.

Run Production

Make sure to create md.mdp before hand with the following parameter

md.mdp

; PRODUCTION MD
; Run parameters
integrator              = md        ; leap-frog integrator
nsteps                  = 5000000   ; 2 * 5000000 = 10 ns (10,000 ps)
dt                      = 0.002     ; 2 fs
; Output control
nstxout                 = 0         ; suppress bulky .trr file by specifying 0
nstvout                 = 0         ; suppress bulky .trr file by specifying 0
nstenergy               = 5000      ; save energies every 10 ps
nstlog                  = 5000      ; update log file every 10 ps
nstxout-compressed      = 5000      ; save compressed coordinates every 10 ps
compressed-x-grps       = System    ; save the whole system
compressed-x-precision  = 1000      ; precision with which to write to the compressed trajectory file
; energygrps            = Protein UNL ; turn this back on after gpu mdrun  
; Bond parameters
continuation            = yes       ; continuing from NPT
constraint_algorithm    = lincs     ; holonomic constraints 
constraints             = h-bonds   ; bonds involving H are constrained
lincs_iter              = 1         ; accuracy of LINCS
lincs_order             = 4         ; also related to accuracy
; Nonbonded settings 
cutoff-scheme           = Verlet    ; Buffered neighbor searching
ns_type                 = grid      ; search neighboring grid cells
nstlist                 = 10        ; 20 fs, largely irrelevant with Verlet
rcoulomb                = 1.0       ; short-range electrostatic cutoff (in nm)
rvdw                    = 1.0       ; short-range van der Waals cutoff (in nm)
DispCorr                = EnerPres  ; account for cut-off vdW scheme
; Electrostatics
coulombtype             = PME       ; Particle Mesh Ewald for long-range electrostatics
pme_order               = 4         ; cubic interpolation
fourierspacing          = 0.16      ; grid spacing for FFT
; Temperature coupling
tcoupl                  = V-rescale             ; modified Berendsen thermostat
tc-grps                 = Protein Non-Protein   ; two coupling groups - more accurate
tau_t                   = 0.1     0.1           ; time constant, in ps
ref_t                   = 300    300           ; reference temperature, one for each group, in K
; Pressure coupling
pcoupl                  = Parrinello-Rahman     ; Pressure coupling on in NPT
pcoupltype              = isotropic             ; uniform scaling of box vectors
tau_p                   = 2.0                   ; time constant, in ps
ref_p                   = 1.0                   ; reference pressure, in bar
compressibility         = 4.5e-5                ; isothermal compressibility of water, bar^-1
; Periodic boundary conditions
pbc                     = xyz       ; 3-D PBC
; Velocity generation
gen_vel                 = no        ; continuing from NPT

gmx grompp -f md.mdp -c npt.gro -t npt.cpt -p topol.top -o md.tpr
gmx mdrun -deffnm md -nb gpu -pme gpu

# or cpu
gmx mdrun -deffnm md

# if ctrl+c and want to resume/continue
gmx mdrun -v -deffnm md -nb gpu -pme gpu -cpi md.cpt -append

This is what we’ve been working toward. Restraints are off, the system is equilibrated, and we’re letting the simulation run freely for 10 nanoseconds. Every 10 ps the coordinates get saved to a compressed .xtc trajectory file for analysis later. Sit back, let it cook, and get ready for the analysis phase.

Note: The above default is 10 ns. We did extend to 50 ns to further assess the rmsd issue we saw initially (not documented here) (see note how to do so). Also! These are quite memory intensive! Make sure your harddrive has lots of storage!

Asessment

Run this first to re-center

# Step 1: Make molecules whole first
echo "0" | gmx trjconv -s md.tpr -f md.xtc -o md_nojump.xtc -pbc nojump

# Step 2: Center on protein and apply mol PBC
echo "1 0" | gmx trjconv -s md.tpr -f md_nojump.xtc -o md_noPBC.xtc -pbc mol -center

RMSD — Root Mean Square Deviation

What it measures: How much a structure deviates from a reference (usually the starting, post-equilibration frame).

A stable complex should reach a plateau. Continuous drift means the system hasn’t equilibrated or the ligand is dissociating.

# Protein backbone RMSD
echo '4 4' | gmx rms -s md.tpr -f md_noPBC.xtc -o rmsd_protein.xvg -tu ns 

# Ligand RMSD (after fitting to protein backbone — critical!)
echo '4 13' | gmx rms -s md.tpr -f md_noPBC.xtc -o rmsd_ligand.xvg -tu ns

We typically want to assess both protein and ligand (with respect to protein) rmsd. We essentially want to see a stable protein with rmsd plateauing, some said <2-3 Å ? 🤷‍♂️ Same goes with the ligand rmsd.

If we see large numbers on the ligand as time passes, that means there is instability or dissociation. Let’s take a look at our result!

code

library(tidyverse)
library(xvm)

prot <- read_xvg("rmsd_protein.xvg")
ligand <- read_xvg("rmsd_ligand.xvg")

plot_xvg(prot)

plot_xvg(ligand)

Backbone RMSD rises from 0 to ~0.5 nm within the first ~5 ns and plateaus around 0.5–0.6 nm for the remainder of the 50 ns simulation, indicating the protein equilibrates early and maintains a stable conformation throughout — consistent across all simulation lengths tested. The ligand (UNL) RMSD tells a different story: it fluctuates around 0.2–0.4 nm for the first ~20 ns, then drifts progressively upward to ~0.5–0.7 nm after ~25 ns with no plateau, suggesting the ligand undergoes a conformational transition away from its original docked pose mid-simulation. However, this should be interpreted alongside the minimum distance, COM distance, H-bond, and interaction energy data.

Note: I had to use echo “1 0” | gmx trjconv -s md.tpr -f md.xtc -o md_noPBC.xtc -pbc mol -center to re-center because there were some outliers of the RMSD of the ligand with 12-15 values. This disappeared after re-centering

Note: I also had to extend 10ns to 50ns to further assess if protein rmsd plateaud as it kept rising. To extend use this:

gmx convert-tpr -s md.tpr -extend 40000 -o md_extended.tpr

gmx mdrun -deffnm md_extended \
  -s md_extended.tpr \
  -cpi md.cpt \
  -nb gpu -pme gpu -bonded gpu -update gpu \
  -ntmpi 1 -ntomp 4 \
  -v

RMSF — Root Mean Square Fluctuation

What it measures: Per-residue (or per-atom) flexibility over time.

Identifies which regions of the protein and which atoms of the ligand are mobile. High flexibility at the binding site residues suggests the ligand isn’t holding them in place as expected.

# Per-residue protein flexibility
echo 4 | gmx rmsf -s md.tpr -f md_noPBC.xtc -o rmsf_protein.xvg -res 

# Per-atom ligand flexibility
echo 13 | gmx rmsf -s md.tpr -f md_noPBC.xtc -o rmsf_ligand.xvg

Binding site residues with low RMSF (< 1–1.5 Å) = well-restrained by ligand. If RMSF of active site residues is HIGH while your ligand RMSD is also high → ligand is not stabilizing the pocket. What does our say?

A few minor peaks around residues 200, 300, and 580–600 suggest localized loop flexibility mid-structure but nothing dramatic. Overall the RMSF profile is consistent with a stable, well-folded protein throughout the 50 ns simulation, with flexibility confined primarily to the N-terminal region as expected for a large multimeric protein like PBP2x.

rmsf_ligand <- read_xvg("rmsf_ligand.xvg")

plot_xvg(rmsf_ligand)

Ligand RMSF analysis shows per-atom fluctuations ranging from ~0.02–0.27 nm across all 41 atoms (system atoms 10041–10082), with a notable peak around atom 10068 corresponding to H7 on the aromatic ring region (benzene ring), suggesting this part of the ligand is the most dynamically flexible. Overall fluctuation levels are moderate and consistent with the dynamic pose sampling behavior observed throughout the simulation.

Now let’s visualize with ChimeraX and use color pallete of the temperature factor (bfactor) via gmx rmsf -s md.tpr -f md_noPBC.xtc -o rmsf.xvg -oq rmsf_bfactor.pdb -res. Blue means minimal wiggliness, white is middle, red is lots of wiggliness.

And we can see that (boxed by green color), our ligand rest quite comfortably in the pocket of prior cefepime with not a whole lot of wiggliness indicating not a whole lot of conformational change around the attached site.

Radius of Gyration (Rg)

What it measures: Compactness of the protein.

If the protein unfolds or the binding pocket opens/closes dramatically due to ligand binding/unbinding, Rg will change. It’s a global indicator of structural integrity.

echo '1' | gmx gyrate -s md.tpr -f md_noPBC.xtc -o gyrate.xvg

According to Claude, the radius of gyration plot for the 50 ns simulation shows total Rg remaining stable at ~2.9 nm throughout, confirming the protein maintains its overall fold with no unfolding or collapse. RgX stays relatively flat around ~2.75 nm. However RgY and RgZ show dramatic and unusual fluctuations between ~20,000–45,000 ps — RgY drops sharply from ~2.75 nm down to ~2.3 nm then recovers, while RgZ spikes from ~1.8 nm up to ~2.45 nm then returns to baseline. These large axial swings occurring simultaneously in opposite directions are concerning and could indicate significant domain reorganization, partial chain separation, or a PBC artifact requiring further investigation. Will visualize in ChimeraX to determine the cause.

In ChimeraX, load fullsystem.gro then load md_noPBC.xtc and enter command below. Then move to around 23000-30000 and see if it’s just a rotation.

hide solvent
hide :NA
hide :CL
cartoon
color bychain

Alright, it’s just a rotation! The RgY and RgZ fluctuations between ~20–45 ns are attributable to protein rotation/tumbling in the simulation box rather than genuine conformational change, as confirmed by visual inspection of the trajectory in ChimeraX. Total Rg remains flat throughout, and the axial variations reflect reorientation rather than structural instability. Overall the protein fold is well-maintained across the full 50 ns simulation

Ligand-Protein Interaction Energy

What it measures: Short-range Lennard-Jones (van der Waals) and Coulomb (electrostatic) energies between ligand and protein.

The most direct thermodynamic indicator. If the ligand is truly bound, the interaction energy should be negative (favorable) and stable. If it dissociates, the energy approaches 0.

Add this to md.mdp

energygrps = Protein UNL ; the UNL is your ligand, use whichever it's listed

then rerun:

gmx grompp -f md.mdp -c md.gro -p topol.top -n index.ndx -o rerun.tpr
gmx mdrun -s rerun.tpr -rerun md_noPBC.xtc -e rerun.edr -ntmpi 1 -ntomp 4

gmx energy -f md.edr -o interaction_energy.xvg 

# then enter these
Coul-SR:Protein-LIG
LJ-SR:Protein-LIG
0

interaction <- read_xvg("interaction_energy.xvg")
plot_xvg(interaction)

Interaction energy plots show LJ/vdW interaction is more stable and consistently negative (~-80 to -130 kJ/mol) throughout the simulation, while Coulomb interaction is highly variable (0 to -80 kJ/mol) with frequent excursions toward zero, indicating the ligand maintains physical contact with the protein but repeatedly loses and regains specific electrostatic interactions. This pattern is consistent with dynamic surface sampling rather than stable binding mode occupancy.

Note: For assessing interaction energy, we will have to rerun mdrun, only uses core, no gpu. But won’t take too long even for 50ns. I would do this after hbond. I tried to doing this together from the first production but it won’t let me.

Hydrogen Bond Analysis

What it measures: Number and occupancy of H-bonds between ligand and protein over the trajectory.

Critical for beta-lactam/PBP interactions — the acylation mechanism involves specific H-bonds. Persistent H-bonds = meaningful interaction.

more info than pdb during acpype conversion, so maybe try that out as well.

echo '1 13' | gmx hbond -s md.tpr -f md_noPBC.xtc -num hbond_ligand_protein.xvg -tu ns

Ligand-protein H-bond analysis reveals 1–3 persistent H-bonds throughout the simulation with only rare drops to zero, indicating the ligand maintains contact with the protein but does not settle into a single stable binding pose — consistent with the progressive RMSD drift. Rather than full dissociation, the ligand appears to be dynamically sampling multiple interaction geometries. This suggests weak or non-specific binding at this site, and a more favorable docking pose or alternative binding site may need to be explored.

Note: Try simulating ligand-protein complex where you know it won’t bind and see this hydrogen bonds to be 0 0 0 0 all the way. Quite often, when i mistakenly docked in the wrong coordinates, my first few minutes production has very low hydrogen bond average. Usually in those situation, I’ll stop instead of continuing. What do you guys do?

Binding Pocket Distance Analysis

What it measures: Distance between the ligand center-of-mass (or key atoms) and key binding site residues.

RMSD can be misleading if the ligand rotates in place. Tracking distances to known catalytic residues (e.g., active site Ser, Lys, Thr in PBPs) gives mechanistically interpretable data.

echo '1 13' | gmx mindist -f md_noPBC.xtc -s md.tpr -n index.ndx -od mindist_prot_lig.xvg -on numcont_prot_lig.xvg -d 0.4

gmx distance -f md_noPBC.xtc -s md.tpr -n index.ndx -select 'com of group "Protein" plus com of group "UNL"' -oall distance_prot_lig.xvg

code

mindist <- read_lines("mindist_prot_lig.xvg")

mindist_list <- mindist[!str_detect(mindist, "^@|^#")] |> str_split(" ")

time <- mindist_val <- vector(mode = "numeric", length = length(mindist_list))
for (i in 1:length(mindist_list)) {
  time[i] <- mindist_list[[i]][1]
  mindist_val[i] <- mindist_list[[i]][3]
}

mindist_df <- tibble(time = time, mindist_val = mindist_val) |>
  mutate(time = as.numeric(time),
         mindist_val = as.numeric(mindist_val))

plot_mindist <- mindist_df |>
  ggplot(aes(x=time,y=mindist_val)) +
  geom_point(color = "red", alpha=0.7) +
  theme_bw()

dist <- read_lines("distance_prot_lig.xvg")

dist_list <- dist[!str_detect(dist, "^@|^#")] |> str_trim() |> str_split("    ")

time <- dist_val <- vector(mode = "numeric", length = length(dist_list))
for (i in 1:length(dist_list)) {
  time[i] <- dist_list[[i]][1] 
  dist_val[i] <- dist_list[[i]][2]
}

dist_df <- tibble(time = time, dist_val = dist_val) |>
  mutate(time = as.numeric(time),
         dist_val = as.numeric(dist_val))

plot_dist <- dist_df |>
  ggplot(aes(x=time,y=dist_val)) +
  geom_point(color = "red", alpha=0.7) +
  theme_bw()

Minimum distance analysis between the ligand and protein confirms the ligand remains in close proximity (~0.15–0.25 nm) throughout the entire 50 ns simulation with no upward drift, ruling out full dissociation. Together with the persistent 1–3 protein-ligand H-bonds, this suggests the ligand maintains continuous contact with the protein surface but explores multiple binding geometries rather than converging on a single stable pose — consistent with weak or dynamic binding at this site.

Center of mass distance between ligand and protein remains stable at ~2.75–2.95 nm throughout the 50 ns simulation with no directional drift, confirming the ligand does not dissociate from the protein. Combined with the minimum distance (~0.15–0.25 nm) and persistent 1–3 H-bonds, the collective picture is one of a ligand that remains associated with the protein but dynamically samples multiple surface poses rather than adopting a single locked binding mode — suggesting the binding interaction is real but relatively weak or non-specific at this site.

Visual Inspection

🙌 These trajectory is from the last few steps of the 50ns. looks like it’s still at the same place! Fantastic!

Let’s plot our frame 0 and frame 5000 and see where our ligand is.

# Extract full system at time 0
gmx trjconv -s md.tpr -f md_noPBC.xtc -o frame0.pdb -dump 0
# Select System

# Extract full system at time 50000
gmx trjconv -s md.tpr -f md_noPBC.xtc -o frame50000.pdb -dump 50000
# Select System

In ChimeraX, open both, then:

hide solvent
hide protein
hide :NA
hide :CL
cartoon
matchmaker #2 to #1 pairing bb
color #1:UNL red
color #2:UNL green
transparency 80 target c

The matchmaker aligns both frames.

Great! Looks like it the coordinates are quite similar! Especially the beta lactam ring area, which is the most important part for the interaction. The tail area seems to have more wiggle room, which is consistent with our RMSF analysis.

Wow, I learnt so much, and so much more to learn! The physics is really fascinating! I don’t understanding all of the them, but at least this is a step to knowing what I don’t know, which is a lot! The trials and erros we’ve gone through, and thanks to Claude, I was able to get unstuck! But still, took quite a long time from experimentation, reproducing with different pdbs, then the documentation! My heart goes to those who do this for a living… it’s not easy! ❤️ Thanks to all who contribute to the scientific community! All the software I used are freely available! And you can reproduce this at your own home as well! Please be sure to cite them!

Opportunities for Improvement

Try out protein structures from AlphaFold Protein Structure Database
Try out ColabFold
Incorporate diffdock in discovering binding poses, compare it with fpocket, and perhaps also vina
I was told that using mol2 directly has more info than pdb during acpype
we did not assess covalent docking
I need to turn all of the above into a pipeline where there is less copy and paste and typing! So I can run more!
I am really curious about how certain ESBL beta lactamase has affinity to beta lactamase inhibitor. Want to see if gromacs can simulate this!
I should really be using index in gromacs
learn about MM-GBSA / MM-PBSA for post-processing
learn about protonation (physiological pH), probably using obabel

Lessons Learnt

learn that you can use echo 15 | gmx something to insert 15 onto the next command response. Or gmx something << EOF 15 EOF
learnt some basic gromacs workflow, interpretation, assessment
learnt autodock vina and diffdock
learnt to visualize with ChimeraX
for GTX 1080, average around 40-50ns/day

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Setting Up A Cluster of Tiny PCs For Parallel Computing - A Note To Myself

Fri, 16 Jan 2026 00:00:00 +0000

Enjoyed learning the process of setting up a cluster of tiny PCs for parallel computing. A note to myself on installing Ubuntu, passwordless SSH, automating package installation across nodes, distributing R simulations, and comparing CV5 vs CV10 performance. Fun project!

Motivations

Part of something I want to learn this year is getting a little more into parallel computing. How we can distribute simulation computations across different devices. Lately, we have more reasons to do this because quite a few of our simulations require long running computation and leaving my laptop running overnight or several days is just not a good use it. We have also tried cloud computing as well and without knowing how those distributed cores are, well, distributed, it’s hard for me to conceptualize how these are done and what else we could optimize. Hence, what is a better way of doing it on our own! Sit tight, this is going to be a bumpy one. Let’s go!

Objectives

Which PCs to Get?

Preferably something functional and cheap! Something like a used Lenovo M715q Tiny PCs or something similar.

Install Ubuntu

Download Ubuntu Server
Create a bootable USB using balenaEtcher
When starting Lenovo up, press F12 continuously until it shows an option to boot from USB. If F12 does not work, reboot and press F1 to BIOS. Go to Startup Tab, change CSM Support to Enabled. Then set Primary Boot Priority to USB by moving priority to first. Then F10 to save configuration and exit. It will then reboot to USB.
Make sure it’s connected to internet via LAN for smoother installation.
Follow the instructions to install Ubuntu, setting username, password etc. Then reboot.
Make sure to remove USB drive, if you didn’t it’ll remind you. Et voila!

The installations were very quick, compared to the other OS I’ve installed in the past. Very smooth as well. I thoroughly enjoyed seeting these up.

Align and Fix IPs

For organizational purpose, make sure you go to your router setting and set your computer clusters to convenient IPs such as 192.168.1.101, 192.168.1.102, 192.168.1.103 etc. You may have to reboot your computer clusters after changing it on your router.

Passwordless SSH

Next, you want to set up passwordless SSH. This is crucial for R to work!

1. Create a key

ssh-keygen -t ed25519

2. Send Copy of Key To Your Node

ssh-copy-id -i .ssh/my_key.pub username1@192.168.1.101

it will prompt you to enter your password, then after that you won’t need a pssword to ssh in.

Passwordless Sudo

This is optional. But if you’re like me, don’t want to repeat lots of typing on installation, and see if you can use bash or R to install packages, you’d need this.

ssh -t username2@192.168.1.102 'echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" | sudo tee /etc/sudoers.d/$(whoami)'

It would prompt you to enter your password. You would have to do this for all your nodes

Send Multiple Commands Via SSH

Install R

for host in username1@192.168.1.101 username2@192.168.1.102 username3@192.168.1.103; do
  ssh -t $host 'sudo apt update && sudo apt install -y r-base r-base-dev'
done

This is basically installing R on all of our clusters one after another.

Create A Template R script For Simulation

Why do we do this? We want to take advantage of the multicore of each nodes as opposed to using clusters on future as the overhead network may add on to the time and makes optimization less efficiency. Instead, we will send a script to each node so that it can fork its own cores to run the simulation. Also, if we specify packages on our script, we can automate the process of installing these packages on our nodes.

code

library(future)
library(future.apply)
library(dplyr)
library(SuperLearner)
library(ranger)
library(xgboost)
library(glmnet)

plan(multicore, workers = 4)

set.seed(1)

n <- 10000
W1 <- rnorm(n)
W2 <- rnorm(n)
W3 <- rbinom(n, 1, 0.5)
W4 <- rnorm(n)

# TRUE propensity score model
A <- rbinom(n, 1, plogis(-0.5 + 0.8*W1 + 0.5*W2^2 + 0.3*W3 - 0.4*W1*W2 + 0.2*W4))

# TRUE outcome model
Y <- rbinom(n, 1, plogis(-1 + 0.2*A + 0.6*W1 - 0.4*W2^2 + 0.5*W3 + 0.3*W1*W3 + 0.2*W4^2))

# Calculate TRUE ATE
logit_Y1 <- -1 + 0.2 + 0.6*W1 - 0.4*W2^2 + 0.5*W3 + 0.3*W1*W3 + 0.2*W4^2
logit_Y0 <- -1 + 0 + 0.6*W1 - 0.4*W2^2 + 0.5*W3 + 0.3*W1*W3 + 0.2*W4^2

Y1_true <- plogis(logit_Y1)
Y0_true <- plogis(logit_Y0)
true_ATE <- mean(Y1_true - Y0_true)

df <- tibble(W1 = W1, W2 = W2, W3 = W3, W4 = W4, A = A, Y = Y)

tune <- list(
  ntrees = c(500,1000),           
  max_depth = c(5,7),                  
  shrinkage = c(0.001,0.01)    
)

tune2 <- list(
  ntrees = c(250, 500, 1000),
  max_depth = c(3,5,7,9),
  shrinkage = c(0.001,0.005,0.01)
)

learners <- create.Learner("SL.xgboost", tune = tune, detailed_names = TRUE, name_prefix = "xgb")
learners2 <- create.Learner("SL.xgboost", tune = tune2, detailed_names = TRUE, name_prefix = "xgb")

# Super Learner library 
SL_library <- list(
  c("SL.xgboost", "SL.ranger", "SL.glm", "SL.mean"),
  c("SL.xgboost","SL.ranger"),
  c("SL.xgboost","SL.glm"),
  list("SL.ranger", c("SL.xgboost", "screen.glmnet")),
  c("SL.glmnet","SL.glm"),
  c("SL.ranger","SL.glm"),
  c(learners$names, "SL.glm"),
  c(learners$names, "SL.glmnet"),
  c("SL.gam","SL.glm"),
  c(learners2$names, "SL.glm"))

# sample
allnum <- START:END
n_sample <- length(allnum)
n_i <- 6000

# Function to run one TMLE iteration
run_tmle_iteration <- function(seed_val, df, n_i, SL_library) {
  set.seed(seed_val)
  data <- slice_sample(df, n = n_i, replace = T) |> select(Y, A, W1:W4)
  
  # Prepare data
  X_outcome <- data |> select(A, W1:W4) |> as.data.frame()
  X_treatment <- data |> select(W1:W4) |> as.data.frame()
  Y_vec <- data$Y
  A_vec <- data$A
  
  # Outcome model
  SL_outcome <- SuperLearner(
    Y = Y_vec,
    X = X_outcome,
    family = binomial(),
    SL.library = SL_library,
    cvControl = list(V = 5)
  )
  
  # Initial predictions
  outcome <- predict(SL_outcome, newdata = X_outcome)$pred
  
  # Predict under treatment A=1
  X_outcome_1 <- X_outcome |> mutate(A=1)
  outcome_1 <- predict(SL_outcome, newdata = X_outcome_1)$pred
  
  # Predict under treatment A=0
  X_outcome_0 <- X_outcome |> mutate(A=0)
  outcome_0 <- predict(SL_outcome, newdata = X_outcome_0)$pred
  
  # Bound outcome predictions to avoid qlogis issues
  outcome <- pmax(pmin(outcome, 0.9999), 0.0001)
  outcome_1 <- pmax(pmin(outcome_1, 0.9999), 0.0001)
  outcome_0 <- pmax(pmin(outcome_0, 0.9999), 0.0001)
  
  # Treatment model
  SL_treatment <- SuperLearner(
    Y = A_vec,
    X = X_treatment,
    family = binomial(),
    SL.library = SL_library,
    cvControl = list(V = 5)
  )
  
  # Propensity scores
  ps <- predict(SL_treatment, newdata = X_treatment)$pred
  
  # Truncate propensity scores 
  ps_final <- pmax(pmin(ps, 0.95), 0.05)
  
  # Calculate clever covariates
  a_1 <- 1/ps_final
  a_0 <- -1/(1 - ps_final)
  clever_covariate <- ifelse(A_vec == 1, 1/ps_final, -1/(1 - ps_final))
  
  epsilon_model <- glm(Y_vec ~ -1 + offset(qlogis(outcome)) + clever_covariate, 
                       family = "binomial")
  epsilon <- coef(epsilon_model)
  
  updated_outcome_1 <- plogis(qlogis(outcome_1) + epsilon * a_1)
  updated_outcome_0 <- plogis(qlogis(outcome_0) + epsilon * a_0)
  
  # Calc ATE
  ate <- mean(updated_outcome_1 - updated_outcome_0)
  
  # Calc SE
  updated_outcome <- ifelse(A_vec == 1, updated_outcome_1, updated_outcome_0)
  se <- sqrt(var((Y_vec - updated_outcome) * clever_covariate + 
                   updated_outcome_1 - updated_outcome_0 - ate) / n_i)
  
  return(list(ate = ate, se = se))
}

# Run iterations in parallel
for (num in 1:length(SL_library)) {
  if (num %in% c(1:9)) { next }
  cat(num)
  cat("TMLE iterations in parallel with 4 workers (multicore)...\n")
  start_time <- Sys.time()
  
  results_list <- future_lapply(START:END, function(i) {
    result <- run_tmle_iteration(i, df, n_i, SL_library[[num]])
    if (i %% 100 == 0) cat("Completed iteration:", i, "\n")
    return(result)
  }, future.seed = TRUE)
  
  end_time <- Sys.time()
  run_time <- end_time - start_time
  
  # Extract results
  predicted_ate <- sapply(results_list, function(x) x$ate)
  pred_se <- sapply(results_list, function(x) x$se)
  
  # Results
  results <- tibble(
    iteration = START:END,
    ate = predicted_ate,
    se = pred_se,
    ci_lower = ate - 1.96 * se,
    ci_upper = ate + 1.96 * se,
    covers_truth = true_ATE >= ci_lower & true_ATE <= ci_upper
  )
  
  # Summary stats
  summary_stats <- tibble(
    metric = c("true_ATE", "mean_estimated_ATE", "median_estimated_ATE", 
               "sd_estimates", "mean_SE", "coverage_probability", "bias"),
    value = c(
      true_ATE,
      mean(predicted_ate),
      median(predicted_ate),
      sd(predicted_ate),
      mean(pred_se),
      mean(results$covers_truth),
      mean(predicted_ate) - true_ATE
    )
  )
  
  # Create output directory if it doesn't exist
  if (!dir.exists("tmle_results")) {
    dir.create("tmle_results")
  }
  
  # Save detailed results (all iterations)
  write.csv(results, paste0("tmle_results/tmle_iterations",num,".csv"), row.names = FALSE)
  
  # Save summary statistics
  write.csv(summary_stats, paste0("tmle_results/tmle_summary",num,".csv"), row.names = FALSE)
  
  # Save simulation parameters
  sim_params <- tibble(
    parameter = c("n_population", "n_sample_iterations", "n_bootstrap_size", 
                  "SL_library", "n_workers", "runtime_seconds"),
    value = c(n, n_sample, n_i, 
              paste(SL_library[[num]], collapse = ", "), 
              4, as.numeric(run_time, units = "secs"))
  )
  write.csv(sim_params, paste0("tmle_results/simulation_parameters",num,".csv"), row.names = FALSE)
  
  # Save as RData for easy loading
  save(results, summary_stats, sim_params, true_ATE, file = paste0("tmle_results/tmle_results",num,".RData"))

}

What we did above is basically a template script (We are saving this as par_test_script.R), one where we can edit where to begin and end in terms of which iteration to start and end per node. And also instruction to save result. This is when we can put a little more effort in incorporating some instructions to inform us when task is completed (e.g., via email) and also it would also be nice to know what is the ETA of the entire task by perhaps benchmarking how long the first iteration took to complete, then multiple by total iters per node. Again, this can be sent via email, and also maybe only for the first node as opposed to all nodes, so we’re not bombarded with messages beginning and the end. 🤣

Install Packages On All Nodes

## List all of our nodes
my_clusters <- list(
  c("username1@192.168.1.101"),
  c("username2@192.168.1.102"),
  c("username3@192.168.1.103"))


## Grab all of the packages needed on our script  
packages <- gsub("library\\(([^)]+)\\)", "\\1",grep("^library",readLines("par_test_script.R"),value = T))

## Create function to run sudo
remote_r_sudo <- function(host, r_code, intern = FALSE) {
  escaped <- gsub('"', '\\\\"', r_code)
  cmd <- sprintf("ssh %s 'sudo Rscript -e \"%s\"'", host, escaped)
  system(cmd, intern = intern)
}

## Loop over to install
for (cluster_i in my_clusters) {
  print(cluster_i)
  for (package in packages) {
  command <- sprintf('if (!require("%s")) install.packages("%s")', package, package)
  remote_r_sudo(cluster_i, command)
  }
}

Make sure your computer doesn’t go to sleep with this. If this is the first time your nodes are installing these extensive libraries, it will take a while. Another way we can do this is to use future_lapply for all nodes and also tmux for all installations so that we don’t need to rely on our local workstation to be turned on to continue with the installation. See below on how we used tmux to set and forget method.

Upload Rscript to Nodes

Alright, now we have installed the appropriate packages above, let’s upload scripts to our nodes.

Distribute Work

num_list <- list()
clust_num <- 3
total_loop <- 1000
div_iter <- total_loop/clust_num
final_iter <- total_loop #only use this for custom e.g., if one node did not work and it's in charge of 300:500, we can put 500 for this and set first_iter as 300
first_iter <- 1
last_iter <- round(div_iter,0) + first_iter

for (i in 1:clust_num) {
  if (i == clust_num) {
    num_list[[i]] <- paste0(first_iter,":",final_iter)
    next
  }
  num_list[[i]] <- paste0(first_iter,":",last_iter)
  first_iter <- round(first_iter + div_iter, 0) 
  last_iter <- round(last_iter + div_iter, 0)
}

num_list

## [[1]]
## [1] "1:334"
## 
## [[2]]
## [1] "334:667"
## 
## [[3]]
## [1] "667:1000"

for (i in 1:length(my_clusters)) {
  username <- sub("@.*","",my_clusters[[i]])
  system(sprintf("sed 's/START:END/%s/g' par_test_script.R > par_test_script1.R & scp par_test_script1.R %s:/home/%s/par_test_script1.R",num_list[[i]],my_clusters[[i]],username))
}

We’ll iterate and insert the appropriate iters for each node and save it to par_test_script1.R. Then upload to each nodes with the code above.

Check set.seed in multicore

sample_df <- function(seed, df, n = 6000) {
  set.seed(seed)
  df_sample <- slice_sample(n = n, .data = df)
  return(df_sample)
}

future_lapply(100, function(x) sample_df(seed=x,df=df))

When we did the above on local computer and also in terminal with multicore. It’s still the same! Woo hoo!

The interesting thing is I didn’t have to set future.seed = T or future.seed = some_number for this. However, if we put a number on future.seed, it will return the reproducible data! This is great, next time I’ll just use this seed and I don’t have to use set.seed(i). 🙌

Run Rscript

for (i in 1:length(my_clusters)) {
  # set your tmux new session name, here we call it "test"
  cluster_name <- "test"
  
  # terminate any existing tmux with the existing name
  system(sprintf("ssh %s 'tmux kill-session -t %s 2>/dev/null || true'", my_clusters[[i]], cluster_name))
  
  # create new tmux session
  system(sprintf("ssh %s 'tmux new-session -d -s %s'", my_clusters[[i]], cluster_name))
  
  # run rscript in tmux
  system(sprintf("ssh %s 'tmux send-keys -t %s \"Rscript par_test_script1.R > result_%d.txt\"' ENTER",
                 my_clusters[[i]], cluster_name, i))
}

The code above is quite self-explanatory. Once the above code is run and completed, there we have it! it should be running in the background! 🙌 You can do a spot check and see if it’s actually running. Once completed, we’ll extract the data.

Extract Data

Since we have 10 combinations we want to assess, we will set nums as 1:10 and get our data! On your template script you can set however you want to save your data, and for extraction, just look for those and download them, read and merge! Or however you want to do it.

nums <- 1:10
df <- tibble()
for (num in nums) {
  print(num)
for (i in 1:length(my_clusters)) {
  response <- system(sprintf("scp %s:tmle_results/simulation_parameters%d.csv simulation_parameters%d.csv", my_clusters[[i]], num, num), intern = F)
  if (response == 1) { next }
  df_i <- read_csv(paste0("simulation_parameters",num,".csv"), show_col_types = F) 
  sl_i <- df_i |> filter(parameter == "SL_library") |> pull(value)
  df <- rbind(df, df_i |> mutate(method = sl_i, num = num))
}
}

df_sim_param <- df

df <- tibble()
for (num in nums) {
for (i in 1:length(my_clusters)) {
  response <- system(sprintf("scp %s:tmle_results/tmle_iterations%d.csv tmle_iterations%d.csv", my_clusters[[i]], num, num), intern = F)
  if (response == 1) { print(paste0(my_clusters[[i]]," is missing num", num)) ; next }
  df_i <- read_csv(paste0("tmle_iterations",num,".csv"), show_col_types = F) |>
    mutate(num = num)
  df <- rbind(df, df_i)
}
}

df_iter <- df

Take note that sometimes you may encounter issues, if for some reason the node is unable to complete the task, you can identify it then redistribute those tasks to the entire computer cluster.

Compare Time

Let’s take at our compute time for 1 cluster, 3 cluster with 5-fold cv, 3 cluster with 10-fold cv.

method	hour_1clus_cv5	hour_3clus_cv5	hour_3clus_cv10
SL.xgboost, SL.ranger, SL.glm, SL.mean	4.02	1.4126466	2.5179200
SL.xgboost, SL.ranger	4.00	1.4136567	2.5108584
SL.xgboost, SL.glm	0.47	0.1680019	0.3034212
SL.ranger, c("SL.xgboost", "screen.glmnet")	4.23	1.4960542	2.5165429
SL.glmnet, SL.glm	NA	0.1074466	0.1995869
SL.ranger, SL.glm	NA	1.2544446	2.2254909
xgb_500_5_0.001, xgb_1000_5_0.001, xgb_500_7_0.001, xgb_1000_7_0.001, xgb_500_5_0.01, xgb_1000_5_0.01, xgb_500_7_0.01, xgb_1000_7_0.01, SL.glm	3.29	1.8059939	3.3030737
xgb_500_5_0.001, xgb_1000_5_0.001, xgb_500_7_0.001, xgb_1000_7_0.001, xgb_500_5_0.01, xgb_1000_5_0.01, xgb_500_7_0.01, xgb_1000_7_0.01, SL.glmnet	NA	1.8956873	3.4821903
SL.gam, SL.glm	NA	0.1094693	0.2072266
xgb_250_3_0.001, xgb_500_3_0.001, xgb_1000_3_0.001, xgb_250_5_0.001, xgb_500_5_0.001, xgb_1000_5_0.001, xgb_250_7_0.001, xgb_500_7_0.001, xgb_1000_7_0.001, xgb_250_9_0.001, xgb_500_9_0.001, xgb_1000_9_0.001, xgb_250_3_0.005, xgb_500_3_0.005, xgb_1000_3_0.005, xgb_250_5_0.005, xgb_500_5_0.005, xgb_1000_5_0.005, xgb_250_7_0.005, xgb_500_7_0.005, xgb_1000_7_0.005, xgb_250_9_0.005, xgb_500_9_0.005, xgb_1000_9_0.005, xgb_250_3_0.01, xgb_500_3_0.01, xgb_1000_3_0.01, xgb_250_5_0.01, xgb_500_5_0.01, xgb_1000_5_0.01, xgb_250_7_0.01, xgb_500_7_0.01, xgb_1000_7_0.01, xgb_250_9_0.01, xgb_500_9_0.01, xgb_1000_9_0.01, SL.glm	NA	NA	4.6127172

Looking at the time, we can definitely see the improvement of time from 1 cluster to 3 cluster. Take a look at our good old tuned xgboost and logistic regression, it took use previously for a quadcore 3.29 hours to complete, down to 1.8 hours. You’d imagine that if we use 3 pc’s as a cluster, we would notice improvement to ~1.1 hours, but I guess not for xgboost. Will have to investigate this. But if we look at xgboost + logistic regression without tuning, we went from 0.47 hours to 0.17 hours which made sense! Very interesting. Now if we up our CV to 10 fold, then we see that it took longer (makes senses), but still better than using 1 quadcore. I’ve heard people said that if you increase your K-fold CV, you reduce your bias, but increase variance. Let’s see if that’s true in our case here.

method	bias_3clus_cv5	bias_3clus_cv10	variance_3clus_cv5	variance_3clus_cv10
SL.xgboost, SL.ranger, SL.glm, SL.mean	-0.0007695	-0.0007257	0.0001866	0.0001940
SL.xgboost, SL.ranger	-0.0007677	-0.0007257	0.0001866	0.0001940
SL.xgboost, SL.glm	-0.0010481	0.0001018	0.0001586	0.0001617
SL.ranger, c("SL.xgboost", "screen.glmnet")	-0.0008349	-0.0007257	0.0001868	0.0001940
SL.glmnet, SL.glm	-0.0449075	-0.0449065	0.0001502	0.0001503
SL.ranger, SL.glm	-0.0007695	-0.0007257	0.0001866	0.0001940
xgb_500_5_0.001, xgb_1000_5_0.001, xgb_500_7_0.001, xgb_1000_7_0.001, xgb_500_5_0.01, xgb_1000_5_0.01, xgb_500_7_0.01, xgb_1000_7_0.01, SL.glm	0.0006449	0.0010681	0.0001491	0.0001504
xgb_500_5_0.001, xgb_1000_5_0.001, xgb_500_7_0.001, xgb_1000_7_0.001, xgb_500_5_0.01, xgb_1000_5_0.01, xgb_500_7_0.01, xgb_1000_7_0.01, SL.glmnet	0.0005986	0.0010492	0.0001502	0.0001511
SL.gam, SL.glm	-0.0062967	-0.0062967	0.0001537	0.0001537
xgb_250_3_0.001, xgb_500_3_0.001, xgb_1000_3_0.001, xgb_250_5_0.001, xgb_500_5_0.001, xgb_1000_5_0.001, xgb_250_7_0.001, xgb_500_7_0.001, xgb_1000_7_0.001, xgb_250_9_0.001, xgb_500_9_0.001, xgb_1000_9_0.001, xgb_250_3_0.005, xgb_500_3_0.005, xgb_1000_3_0.005, xgb_250_5_0.005, xgb_500_5_0.005, xgb_1000_5_0.005, xgb_250_7_0.005, xgb_500_7_0.005, xgb_1000_7_0.005, xgb_250_9_0.005, xgb_500_9_0.005, xgb_1000_9_0.005, xgb_250_3_0.01, xgb_500_3_0.01, xgb_1000_3_0.01, xgb_250_5_0.01, xgb_500_5_0.01, xgb_1000_5_0.01, xgb_250_7_0.01, xgb_500_7_0.01, xgb_1000_7_0.01, xgb_250_9_0.01, xgb_500_9_0.01, xgb_1000_9_0.01, SL.glm	NA	0.0013250	NA	0.0001528

Wow, not too shabby! Indeed when we went from cv5 to cv10, we have reduced bias and slightly increased variance! How about that. Everything except gam + lr, which make sense because we don’t really tune them. Though that being said, I wonder what’s under the hood that controls the knot for gam in superlearner. Will need to check that out. With this, it looks like tuned xgboost + lr might have the best numbers. Well, now we’ve seen bias and variance, what about coverage?

method	coverage_3clus_cv5	coverage_3clus_cv10
SL.xgboost, SL.ranger, SL.glm, SL.mean	0.536	0.517
SL.xgboost, SL.ranger	0.536	0.517
SL.xgboost, SL.glm	0.811	0.799
SL.ranger, c("SL.xgboost", "screen.glmnet")	0.539	0.517
SL.glmnet, SL.glm	0.051	0.052
SL.ranger, SL.glm	0.536	0.517
xgb_500_5_0.001, xgb_1000_5_0.001, xgb_500_7_0.001, xgb_1000_7_0.001, xgb_500_5_0.01, xgb_1000_5_0.01, xgb_500_7_0.01, xgb_1000_7_0.01, SL.glm	0.882	0.878
xgb_500_5_0.001, xgb_1000_5_0.001, xgb_500_7_0.001, xgb_1000_7_0.001, xgb_500_5_0.01, xgb_1000_5_0.01, xgb_500_7_0.01, xgb_1000_7_0.01, SL.glmnet	0.881	0.876
SL.gam, SL.glm	0.926	0.926
xgb_250_3_0.001, xgb_500_3_0.001, xgb_1000_3_0.001, xgb_250_5_0.001, xgb_500_5_0.001, xgb_1000_5_0.001, xgb_250_7_0.001, xgb_500_7_0.001, xgb_1000_7_0.001, xgb_250_9_0.001, xgb_500_9_0.001, xgb_1000_9_0.001, xgb_250_3_0.005, xgb_500_3_0.005, xgb_1000_3_0.005, xgb_250_5_0.005, xgb_500_5_0.005, xgb_1000_5_0.005, xgb_250_7_0.005, xgb_500_7_0.005, xgb_1000_7_0.005, xgb_250_9_0.005, xgb_500_9_0.005, xgb_1000_9_0.005, xgb_250_3_0.01, xgb_500_3_0.01, xgb_1000_3_0.01, xgb_250_5_0.01, xgb_500_5_0.01, xgb_1000_5_0.01, xgb_250_7_0.01, xgb_500_7_0.01, xgb_1000_7_0.01, xgb_250_9_0.01, xgb_500_9_0.01, xgb_1000_9_0.01, SL.glm	NA	0.844

as not expecting gam + lr to have so much coverage! But looking at bias from the previous table, it's actually quite horrible. So it seems like gam + lr is assymetrical in its estimates, sometimes overestimating, sometimes underestimating, leading to a wider confidence interval, hence more coverage. But that being said, it's not a good estimator because of its bias. Tuned xgboost + glmnet seems to be the best bet here with low bias, low variance and decent coverage. Wow, I was not expecting gam + lr to have so much coverage! But looking at bias from the previous table, it's actually quite horrible. Let's visualize it!

5-fold CV

code

library(tidyverse)

num_df <- sim_param_cv5_clus5 |>
  select(num, method)

df_coverage <- df_iter_cv5_clus3 |>
  group_by(num) |>
  arrange(ate) |>
  mutate(iter = row_number()) |>
  mutate(cover = case_when(
    covers_truth == F & ate < true_ATE ~ "right_missed",
    covers_truth == F & ate > true_ATE ~ "left_missed",
    covers_truth == T ~ "covered"
  )) |>
  select(num, cover) |>
  group_by(num, cover) |>
  tally() |>
  ungroup(cover) |>
  mutate(prop = n*100/sum(n)) |>
  pivot_wider(id_cols = num, names_from = "cover", values_from = "prop") |>
  mutate(text = paste0("right missed: ",right_missed,"% covered: ",covered,"% left missed: ",left_missed,"%")) |>
  select(num, text)

method <- tibble(
  num = c(1:9),
  method = c("xgb + rf + lr + mean","xgb + rf","xgb + lr","rf + (xgb + preprocess w glmnet)","glmnet + lr","rf + lr","tuned xgb + lr","tuned xgb + glmnet","gam + lr")
)

plot <- df_iter_cv5_clus3 |>
  group_by(num) |>
  arrange(ate) |>
  mutate(iter = row_number()) |>
  mutate(cover = case_when(
    covers_truth == F & ate < true_ATE ~ "right_missed",
    covers_truth == F & ate > true_ATE ~ "left_missed",
    covers_truth == T ~ "covered"
  )) |>
  ggplot(aes(x=iter,y=ate,color=cover)) +
  geom_point(alpha=0.2) +
  geom_errorbar(aes(x=iter,ymin=ci_lower,ymax=ci_upper), alpha=0.2) +
  geom_hline(aes(yintercept=0.0373518), color = "blue") +
  geom_text(data = df_coverage,
            aes(x = 500, label = text),
            y = -0.05,  
            inherit.aes = FALSE,
            size = 3,
            hjust = 0.5) +
  scale_color_manual(values = c("covered" = "#619CFF", 
                                  "left_missed" = "#F8766D", 
                                  "right_missed" = "#00BA38")) +
  theme_bw() +
  facet_wrap(.~num, ncol = 1,labeller = as_labeller(setNames(method$method, method$num))) +
  theme(legend.position = "bottom")

lr: logistic regression, xgb: xgboost, rf : random forest, gam : generalized additive model.

Wow, look at gam + lr’s assymetrical coverage! This is so true then when we’re assessing, a point estimate of coverage is not adequate to assess the global usefulness of a method. We can see that this method is very bias indeed with asymmetrical tails. Since CV5 and CV10 do not have significant difference in coverage, we’ll skip the visualization.

Opportunities for improvement

plenty of opportunities to turn our personal project into a package that will help us
Use parallel computing on local to run system (such as installation) since this takes a lot of time
Write function to let us know when tasks are completed
Write function to estimate time of completion
Write function to redistribute missing iterations
learn openMPI
make a package for the functions above so I can reuse in the future

Lessons Learnt:

used more sprintf with this learning experience when using with system.
learn that in future_lapply in multicore future.seed=100 or whatever number will help reproduce the same data
Made a few pipeline to install packages on multiple nodes
learnt set.seed in multicore works fine
observed reduced bias with increase variance from cv5 to cv10

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Testing Super Learner's Coverage - A Note To Myself

Fri, 02 Jan 2026 00:00:00 +0000

Testing Super Learner with TMLE showed some interesting patterns 🤔 XGBoost + random forest only hit ~54% coverage, but tuned xgboost + GLM reached ~90%. Seems like pairing flexible learners with stable (even misspecified) models helps? Need to explore this more with different setups 📊

Motivations:

We have previously looked at TMLE without Super Learner and observed the poor coverage of TMLE with unspecified xgboost when compared to a correctly specified logistic regression. Now since we’ve learnt NNLS the default method behind Super Learner, why dont we test it out and take a look at the coverage! Let’s take a look at our previous coverage plot.

We saw that with xgboost and TMLE, our coverage is about 71.1-87.6% and the lower and upper tails are asymmetrical. What if we use SuperLearner, can we improve these coverage?

Objectives

Let’s Code

We will be using the same data generating mechanism as before, but this time we will be using Super Learner to estimate the propensity score and outcome regression.Let’s write a code where we can use multicore and also a cheap 2nd hand lenovo with quad-core and Ubuntu to run and store results. Part of my learning goal for 2026 is to experiment more with parallel computing and see if we can explore mathematical platonic space more using simulation! Stay tuned on that, more to come on the simple parallel computing cluster set up!

code

library(dplyr)
library(SuperLearner)
library(future)
library(future.apply)

# Set up parallel processing
plan(multicore, workers = 4)

set.seed(1)

n <- 10000
W1 <- rnorm(n)
W2 <- rnorm(n)
W3 <- rbinom(n, 1, 0.5)
W4 <- rnorm(n)

# TRUE propensity score model
A <- rbinom(n, 1, plogis(-0.5 + 0.8*W1 + 0.5*W2^2 + 0.3*W3 - 0.4*W1*W2 + 0.2*W4))

# TRUE outcome model
Y <- rbinom(n, 1, plogis(-1 + 0.2*A + 0.6*W1 - 0.4*W2^2 + 0.5*W3 + 0.3*W1*W3 + 0.2*W4^2))

# Calculate TRUE ATE
logit_Y1 <- -1 + 0.2 + 0.6*W1 - 0.4*W2^2 + 0.5*W3 + 0.3*W1*W3 + 0.2*W4^2
logit_Y0 <- -1 + 0 + 0.6*W1 - 0.4*W2^2 + 0.5*W3 + 0.3*W1*W3 + 0.2*W4^2

Y1_true <- plogis(logit_Y1)
Y0_true <- plogis(logit_Y0)
true_ATE <- mean(Y1_true - Y0_true)

df <- tibble(W1 = W1, W2 = W2, W3 = W3, W4 = W4, A = A, Y = Y)

tune = list(
  ntrees = c(500,1000),           # More trees for better performance
  max_depth = c(3,5),                    # Deeper trees capture interactions
  shrinkage = c(0.001,0.01)    # Finer learning rate control
)

learners <- create.Learner("SL.xgboost", tune = tune, detailed_names = TRUE, name_prefix = "xgb")

# Super Learner library 
SL_library <- list(c("SL.xgboost", "SL.ranger", "SL.glm", "SL.mean"),
                   c("SL.xgboost","SL.ranger"),
                   c("SL.xgboost","SL.glm"),
                   list("SL.ranger", c("SL.xgboost", "screen.glmnet")),
                   c(learners$names, "SL.glm"))

# sample
n_sample <- 1000
n_i <- 6000

# Function to run one TMLE iteration
run_tmle_iteration <- function(seed_val, df, n_i, SL_library) {
  set.seed(seed_val)
  data <- slice_sample(df, n = n_i, replace = T) |> select(Y, A, W1:W4)
  
  # Prepare data
  X_outcome <- data |> select(A, W1:W4) |> as.data.frame()
  X_treatment <- data |> select(W1:W4) |> as.data.frame()
  Y_vec <- data$Y
  A_vec <- data$A
  
  # Outcome model
  SL_outcome <- SuperLearner(
    Y = Y_vec,
    X = X_outcome,
    family = binomial(),
    SL.library = SL_library,
    cvControl = list(V = 5)
  )
  
  # Initial predictions
  outcome <- predict(SL_outcome, newdata = X_outcome)$pred
  
  # Predict under treatment A=1
  X_outcome_1 <- X_outcome |> mutate(A=1)
  outcome_1 <- predict(SL_outcome, newdata = X_outcome_1)$pred
  
  # Predict under treatment A=0
  X_outcome_0 <- X_outcome |> mutate(A=0)
  outcome_0 <- predict(SL_outcome, newdata = X_outcome_0)$pred
  
  # Bound outcome predictions to avoid qlogis issues
  outcome <- pmax(pmin(outcome, 0.9999), 0.0001)
  outcome_1 <- pmax(pmin(outcome_1, 0.9999), 0.0001)
  outcome_0 <- pmax(pmin(outcome_0, 0.9999), 0.0001)
  
  # Treatment model
  SL_treatment <- SuperLearner(
    Y = A_vec,
    X = X_treatment,
    family = binomial(),
    SL.library = SL_library,
    cvControl = list(V = 5)
  )
  
  # Propensity scores
  ps <- predict(SL_treatment, newdata = X_treatment)$pred
  
  # Truncate propensity scores 
  ps_final <- pmax(pmin(ps, 0.95), 0.05)
  
  # Calculate clever covariates
  a_1 <- 1/ps_final
  a_0 <- -1/(1 - ps_final)
  clever_covariate <- ifelse(A_vec == 1, 1/ps_final, -1/(1 - ps_final))
  
  epsilon_model <- glm(Y_vec ~ -1 + offset(qlogis(outcome)) + clever_covariate, 
                       family = "binomial")
  epsilon <- coef(epsilon_model)
  
  updated_outcome_1 <- plogis(qlogis(outcome_1) + epsilon * a_1)
  updated_outcome_0 <- plogis(qlogis(outcome_0) + epsilon * a_0)
  
  # Calc ATE
  ate <- mean(updated_outcome_1 - updated_outcome_0)
  
  # Calc SE
  updated_outcome <- ifelse(A_vec == 1, updated_outcome_1, updated_outcome_0)
  se <- sqrt(var((Y_vec - updated_outcome) * clever_covariate + 
                   updated_outcome_1 - updated_outcome_0 - ate) / n_i)
  
  return(list(ate = ate, se = se))
}

# Run iterations in parallel
for (num in 1:length(SL_library)) {
cat("TMLE iterations in parallel with 4 workers (multicore)...\n")
start_time <- Sys.time()

results_list <- future_lapply(1:n_sample, function(i) {
  result <- run_tmle_iteration(i, df, n_i, SL_library[[num]])
  if (i %% 100 == 0) cat("Completed iteration:", i, "\n")
  return(result)
}, future.seed = TRUE)

end_time <- Sys.time()
run_time <- end_time - start_time

# Extract results
predicted_ate <- sapply(results_list, function(x) x$ate)
pred_se <- sapply(results_list, function(x) x$se)

# Results
results <- tibble(
  iteration = 1:n_sample,
  ate = predicted_ate,
  se = pred_se,
  ci_lower = ate - 1.96 * se,
  ci_upper = ate + 1.96 * se,
  covers_truth = true_ATE >= ci_lower & true_ATE <= ci_upper
)

# Summary stats
summary_stats <- tibble(
  metric = c("true_ATE", "mean_estimated_ATE", "median_estimated_ATE", 
             "sd_estimates", "mean_SE", "coverage_probability", "bias"),
  value = c(
    true_ATE,
    mean(predicted_ate),
    median(predicted_ate),
    sd(predicted_ate),
    mean(pred_se),
    mean(results$covers_truth),
    mean(predicted_ate) - true_ATE
  )
)

# Create output directory if it doesn't exist
if (!dir.exists("tmle_results")) {
  dir.create("tmle_results")
}

# Save detailed results (all iterations)
write.csv(results, paste0("tmle_results/tmle_iterations",num,".csv"), row.names = FALSE)

# Save summary statistics
write.csv(summary_stats, paste0("tmle_results/tmle_summary",num,".csv"), row.names = FALSE)

# Save simulation parameters
sim_params <- tibble(
  parameter = c("n_population", "n_sample_iterations", "n_bootstrap_size", 
                "SL_library", "n_workers", "runtime_seconds"),
  value = c(n, n_sample, n_i, 
            paste(SL_library[[num]], collapse = ", "), 
            4, as.numeric(run_time, units = "secs"))
)
write.csv(sim_params, paste0("tmle_results/simulation_parameters",num,".csv"), row.names = FALSE)

# Save as RData for easy loading
save(results, summary_stats, sim_params, true_ATE, file = paste0("tmle_results/tmle_results",num,".RData"))

As previously, we’ve set up our true ATE and simulation and will sample 60% of the N=10000 and ran a bootstrap of 1000. This time, instead of solo ML, we will use Super Learner to ensemble several models and then estimate our ATE and if the 95% CI covers the true ATE. Below are the combinations we will investigate:

xgboost + randomforest + glm + mean
xgboost + randomforest
xgboost + glm
randomforest + (xgboost + screen.glmnet) + glm
xgboost_tuned + glm

What’s The Result

Wow, these are very interesting results! Looking at 1) where we have xgboost, randomforest, glm, and mean, our coverage was pretty horrible at ~50%. For 3) with xgboost and glm, coverage increased to ~80%, very similar to our solo tuned xgboost previously but at least with symmetrical non-coverage, very interesting. But when 2) we combined both xgboost and randomforest, the coverage dropped back to ~50%. Same thing happened when we used feature engineering 4) glmnet prior to xgboost, then couple with xgboost, coverage was only ~50%. But, when we 5) tune xgboost and combine it with glm, coverage increased to ~90%! I was not expecting this result but this is quite amazing! With regards to how long it took for each combination for a quadcore processor with multicore feature:

method	time_hours
SL.xgboost, SL.ranger, SL.glm, SL.mean	4.02
SL.xgboost, SL.ranger	4.00
SL.xgboost, SL.glm	0.47
SL.ranger, SL.xgboost, screen.glmnet	4.23
tuned SL.xghboost, SL.glm	3.29

Opportunities for improvement

attempt using optimized hyperparameters for both xgboost and randomforest
write a function for splitting multicore to several nodes
try using NNloglik / maximize on auc instead of nnls, would it work better?
need to test the theory that whether set.seed works differently with multicore? Or does future automatically chooses L'Ecuyer-CMRG Algorithm? does our current method of set.seed(i) of iteration number work ok?
need to try mcSuperLearner, built-in multicore

Lessons Learnt

learnt future_lapply
learnt multicore is so much faster!!! Though when we future_lapply the function it appears to have the same time as multisession
tested Super Learner, it’s pretty cool! It already has options for parallel computing
found out that mixing flexible model like xgboost (tuned) and logreg regularizes the ensembled model

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Happy New Year 2026

Thu, 01 Jan 2026 00:00:00 +0000

My 2026 New Year Resolutions. Reflect on 2025. Writing it down for 2026 to make it more accountable

My 2025 New Year Resolutions

Explore Gimp
~~Explore useful VIM key binding~~
~~Learn nodejs, javascript, fasthtml, fashapi, plumber to create a simple tool for calling API and storing data~~
~~Explore and implement LLM-assisted learning scenarios for eval score calibration (DE Level 3)~~
~~re-create automation at wrk~~
~~?sti dashboard~~
~~Complete my neural network study. This time we’re getting close!~~
Practice 华语
Dive into McElReath’s Statistical Rethinking 2nd time
~~Maintain coaching skill and practice more! ?reach out to CECM for 2~~
Finish 2 manuscripts

I did explore gimp a little bit but not enough to strike that off the list. We’ll see if I’ll resume that in 2026. One thing I found that often times it’s not the initial action that made me commit to learning something but usually it’s the second, third, or even fourth time with long period in between that brings me closer to understanding certain things. Or at least the illusion of understanding, that is. 🤣

I did start using vim key binding. Thanks Alec for the motivation! I need to get better this year for sure! With regards to plumber API, we did explore that! Wrote 2 blogs on it too! here and here.

Quite satisfied with some of the completion in 2025, LLM-assisted scenarios, completed neural network study, re-created automation, sti dashboard, maintaing coaching skill, prepared 1 manuscript instead of 2. Let’s work on that in 2026!

Something that I wasn’t expecting in 2025 was a year of diving head on into bioinformatics. Wow, I thought it was just 1 or 2 blogs but no, the various topics, the interesting math and methods behind it, I just couldn’t resist learning more and more of the surface of these topics! Very intriguing indeed! I did 8 blogs total on bioinformatics, and there are more that I want to dive into! Such as ampC, CRE, mec, vanA etc. Looking forward!

Things that didn’t go as planned -> I started out ok with 华语 with duolingo but then got tapered off. Didn’t really dive into Richard McElreath’s statistical rethinking the second time. Did only 1 manuscript. Didn’t put too much effort on gimp. Maybe better effort this year!

My 2026 New Year Resolutions

Explore molecular docking & medication discovery
Explore more bioinformatics (e.g ampC, CRE, mec, vanA etc), 59 skill
Use more parallel computing (at least once a month with future and personally built function for multicore)
Build a computer cluster
Explore simple quantum computing
Use more tidymodels, keras and torch; I do think I’ll be exploring more AI/ML models in 2026 due to research
Git, can’t get away from this
Healthy life style
Attend res conference at least 4x/month
work research
use more vim (at least cumulative 15 mins per week - try working on copy & pasting)
Rewatch Richard McElreath’s Statistical Rethinking, especially on Gaussian Process and ordered logistic regression

Everyday Is A School Day

Learning Chromosomal AmpC beta-lactamase Producing Organisms And Its Mechanics

Motivations

Disclaimer

Objectives:

How Is AmpC So Different From Other Beta-lactamase Genes?

Let’s Take A Look At NCBI

What Are The Typical Organisms Of Clinical Significance?

Why Is It That Serratia marcescens Not a High Risk for AmpC?

Let’s Look At Ecoli

Cefepime and AmpC Beta-Lactamase

What Does It Mean That Cefepime Is A Weak AmpC Inducer?

How Similar Are The Genes for AmpG/D/R Between Species?

AmpG

AmpD

AmpR

Interpretation

Opportunities For Improvement

Lessons learnt

Navigating Financial Statement And The Story It Tells Us - A Note To Myself

Motivations

Disclaimer:

Objectives:

The Skeleton of Financial Statements

Income Statement

Balance Sheet

Cash Flow

Let’s Take An Example

Income Statement

Gross Profit Margin

Depreciation

Interest Payment to Operating Income

Income Before Tax

Income After Tax

Net Earnings

Per Share Earning

Operating Margin

Metrics

Balance Sheet

Current Assets

Net Receivables To Gross Sale Ratio

The Current Ratio

Property, Plant, and Equipment

Short Term Debt

Long Term Debt

Retained Earnings

Treasury Stock

Return On Shareholders’ Equity

Metrics

Cash Flow

Operating Income

Capital Expenditure

Stock Buyback

Metrics

Combine All Metrics

Let’s Look At Another Example

Apple

Microsoft

NVIDIA

Intel

AMD

Google

3M

Disney

Boeing

Opportunities For Improvement

Lessons learnt

Exploring Piperacillin/Tazobactam Probability of Target Attainment (PTA) in Pseudomonas

Motivations

Disclaimer:

Objectives:

Piptazo Model

Probability of Target Attainment

Age 50, Scr 1

Critically Ill

Neutropenic Fever

Maximum fT>mic used in the literature

fT > mic 100%

fT > 4 x mic 100%

Proportion of PsA in NCBI that would benefit from tazobactam

Write `mmpbsa.in`