Foundations — Responsible AI deployment practices

The parent note (Responsible AI deployment practices) throws a lot of symbols at you very fast: $p$, $\alpha$, $n$, $(1-p{)}^n$, $\ln$, $D_{KL}$, $H$, $\log$, $p_i$. If any of those look like magic squiggles, this page is your ground floor. We build each one from nothing, anchor it to a picture, and only then let the parent use it.

We go in order — each idea leans on the one before it.

0. What is a "model" and a "prediction"?

Before any symbol, the object everything else talks about.

The picture: a box with an arrow going in (the input) and an arrow coming out (the prediction). Everything in this chapter is either (a) checking that arrow-out is safe, or (b) noticing when it stops being safe.

1. Probability $p$ — "how often does this happen?"

The picture: imagine a bag of 1000 marbles where exactly 1 is red. Reach in blindly — the chance of red is $p=1/1000=0.001$. That is exactly the "0.1% failure rate" the parent talks about.

Turning a percent into a $p$: divide by 100. So $5\%=0.05$, $0.1\%=0.001$, $100\%=1$.

2. Repeating a trial $n$ times, and the product $(1-p{)}^n$

Now the key move: the parent asks "if a failure happens with probability $p$, how many tries $n$ before we've probably seen at least one?"

The picture: the marble bag again. Red = failure with $p=0.001$. Not-red = $1-p=0.999$. A slice of a pie: a thin red sliver ($p$) and a huge grey rest ($1-p$).

Why multiply? Look at the figure. Each try is a coin that lands "safe" with probability $1-p$. Two safe tries in a row: $(1-p)\times (1-p)$. Three: $(1-p{)}^3$. The little superscript $n$ is just shorthand for "multiply it by itself $n$ times." As $n$ grows, this product shrinks toward $0$ — meaning eventually you're almost sure to have caught the failure at least once. That shrinking curve is the whole reason staged rollouts work.

3. The logarithm $\ln$ — "how many times did we multiply?"

We have $(1-p{)}^n\le \alpha$ and we want to solve for $n$. But $n$ is stuck up in the exponent. The tool that pulls an exponent down to earth is the logarithm.

The picture: think of $\ln$ as a ruler that measures "number of doublings/multiplications." Feeding a big number in gives a modest number out; that output is the hidden exponent.

Closing the loop: the derivation, one line at a time

4. Confidence $1-\alpha$ and the risk $\alpha$

The picture: a 20-slot spinner with 1 red slot. Landing red ($\alpha =1/20=0.05$) = we got unlucky and missed the bug. 19 grey slots = we caught it. Smaller $\alpha$ = fewer red slots = need more samples $n$.

Now the parent's formula reads in plain English:

$\underset{\text{how many samples}}{\underbrace{n}}\ge \frac{\ln (\underset{\text{risk of missing}}{\underbrace{\alpha }})}{\ln (1-\underset{\text{failure rate}}{\underbrace{p}})}$

"To be $1-\alpha$ confident of catching a failure that happens with probability $p$, watch at least this many samples." (See 5.2.4-A-B-testing for the same sample-size logic applied to experiments.)

5. Distributions $P$ — "the full shape of what's coming in"

Runtime monitoring compares training data to live data. To do that we need a single object describing "what inputs look like."

The picture: a histogram — a row of bars, one per outcome, heights summing to $1$. $P_{\text{train}}$ is the histogram the model learned on; $P_{\text{prod}}$ is the histogram of what's actually arriving in production. If those two shapes drift apart, the model is seeing a world it wasn't taught.

6. The $\sum$ symbol — "add up over all the boxes"

The picture: point at bar 1, compute something, write it down; point at bar 2, compute, write down; … then total everything. $\sum$ is a "for each bar, and add" instruction — nothing scarier.

Example: ${\sum }_{i}P(x_i)=1$ simply says "add up all bar heights and you get $1$," which is the defining rule of a distribution.

7. KL divergence $D_{KL}$ — "how surprised is the model?"

Now we can read the parent's drift formula (remember: $\log$ here means $\ln$, per our page convention).

$D_{KL}(P_{\text{train}}\Vert P_{\text{prod}})={\sum }_i{P}_{\text{train}}(x_i)\log \frac{P_{\text{train}}(x_i)}{P_{\text{prod}}(x_i)}$

Reading it piece by piece, using symbols we now own:

• $\frac{P_{\text{train}}(x_i)}{P_{\text{prod}}(x_i)}$ — for each outcome, the ratio of how often training expected it vs. how often it actually shows up. Ratio $=1$ ⇒ no surprise.
• $\log (\text{ratio})$ — the natural log turns "twice as common" and "half as common" into equal-sized opposite surprises, and makes ratio $1$ give exactly $0$.
• Multiply by $P_{\text{train}}(x_i)$ — weight each surprise by how important that outcome was to training.
• ${\sum }_i$ — add up the weighted surprises over every outcome.

8. Entropy $H$ — "how unsure is one prediction?"

Same log machinery, one prediction at a time (again, $\log =\ln$).

$H=-{\sum }_{i=1}^C{p}_i\log p_i$

The picture (see figure): two bar charts. A confident prediction is one tall spike — low entropy. An unsure prediction is flat bars of equal height — high entropy. Watch the average $H$ across many predictions climb, and you're watching the model lose its footing (the parent's "entropy 0.3 → 0.55" alarm).

How the foundations feed the topic

The figure below is the same map drawn on the board — read it if the code block won't render for you.

Every arrow is a "you need this before that." The two rivers — the sample-size river (left) and the monitoring river (right) — join at responsible deployment. Related downstream topics: 6.4.1-Adversarial-examples (attacks that spike entropy), 6.4.8-Fairness-metrics (per-group monitoring), 6.4.12-Explainability-methods, and 6.4.14-AI-governanceframeworks.

Equipment checklist

Cover the right side and answer aloud. If any stumps you, reread its section.