# Learning TMLE：影响函数与双重稳健估计学习笔记

中文交互课程的可编辑讲义。公式保留 TeX 源，Julia与R代码来自实际可执行源码；静态配图和实验见 index.html。

# 第 0 章：从双重稳健估计认识EIF

在SUPPORT/RHC队列中，5735位患者有1918人在30天内死亡。我们想进一步比较：**对于同一个目标人群，接受右心导管检查（RHC）与未接受RHC，30日死亡风险平均相差多少？**

接受RHC与未接受RHC的患者，基线状况可能不同。为了作这次比较，我们需要将两组放在共同的基线人群上。这也是双重稳健估计（doubly robust estimation）要解决的估计问题。

下面用$W$表示基线特征，$A$表示是否接受RHC（1为接受，0为未接受），$Y$表示30日是否死亡（1为死亡，0为存活）。若要把调整后的风险差解释为平均处理效应（average treatment effect, ATE），还需一致性、给定$W$后无未测量混杂，以及各类基线下两种处理都有机会出现这些识别条件。课程使用真实记录演示计算；[研究设计、调整变量与因果解释的范围](case-study.html)集中说明在案例说明页。

## 1. 用两个回归分别预测结局与处理概率

熟悉logistic回归的话，可以先从两个不同的响应变量理解它们。

**结局回归（outcome regression）$Q$预测死亡风险。** 用$A$与$W$预测$Y$，拟合后保留每个人的基线，分别把预测输入中的$A$设为1和0，就得到$\widehat Q(1,W)$与$\widehat Q(0,W)$。将每个人的两项预测相减，再对5735人平均，就是回归标准化（regression standardisation，也称g-computation）的估计。

**处理回归（treatment model）$g$预测接受RHC的概率。** 用$W$预测$A$，输出倾向评分（propensity score）$\widehat g(W)$。逆概率加权（inverse probability weighting, IPW）用它给实际结局加权：RHC组用$1/\widehat g(W)$，未RHC组用$1/[1-\widehat g(W)]$；各组的加权结局总和都除以总人数，再相减，得到面向同一总体的风险差估计。

<div class="dr-intro-models"></div>

两条路径依赖不同的模型：g-computation依靠结局风险预测，IPW依靠处理概率预测。既然两者都能从这份资料中学习，就可以尝试把它们组合起来。

## 2. 用加权残差补充预测，得到双重稳健估计

先保留$Q$给出的风险差估计，再查看实际结局与实际处理下的预测相差多少。对第$i$位患者，这个残差是$Y_i-\widehat Q(A_i,W_i)$。AIPW（augmented inverse probability weighting，增广逆概率加权）用$g$对残差加权：接受RHC者的残差除以其处理概率，未接受者的残差除以其未处理概率，并在风险差中取负号。最后把这些贡献的平均加到初始估计上。

$$
\widehat\psi_{\mathrm{AIPW}}
=\underbrace{\widehat\psi_{\mathrm{gcomp}}}_{\text{预测风险差的平均}}
+\underbrace{\frac1n\sum_{i=1}^n C_i}_{\text{加权残差的平均}}.
$$

> **符号回看：** $\widehat\psi$表示从样本得到的风险差估计；$n=5735$为总人数，$i$为患者行号。$C_i$是刚才定义的有正负号的加权残差：RHC组为$(Y_i-\widehat Q(1,W_i))/\widehat g(W_i)$，未RHC组为$-(Y_i-\widehat Q(0,W_i))/[1-\widehat g(W_i)]$。帽号表示拟合或样本计算的结果；风险差乘100后以百分点表示。

这个组合的关键是**双重稳健性（double robustness）**：在识别、重叠和通常的估计正则条件下，只要$Q$或$g$中的一个得到一致估计，AIPW就能一致估计目标风险差。这里“一致”指随着样本量增加趋近真实目标。

- **如果$Q$正确：** 给定基线和处理，残差的条件平均为0，加权残差在总体平均时也为0，保留正确的风险预测。
- **如果$g$正确：** 加权使两种处理下的残差都对应共同的基线人群，残差平均能够补上$Q$预测风险的偏差。

这项性质为两个模型提供了两条获得一致估计的途径；两者都不正确时，结果仍可能有偏。上述“平均为0”和“补上偏差”说明的是总体关系，一份有限样本的校正量通常仍有波动。

## 3. EIF告诉我们怎样构造这项修正

为什么恰好使用这样的加权残差？这就要认识影响函数（influence function, IF）。**固定一个估计目标和一个参考分布后，IF是把一条观测记录映射成一个数的函数。** 它的输出描述：让这类记录在分布中的权重略增时，目标的一阶变化率。对于这里的风险差，输入是一位患者的$(W,A,Y)$；输出同时考虑其结局残差、处理概率和两种处理下的预测风险差。

有效影响函数（efficient influence function, EIF）是在给定统计模型中决定效率界的那个IF。它让我们能沿着同一条数学规则做两件事：**构造估计的修正，以及研究估计的不确定性。** 在满足相应条件时，其方差决定估计误差能达到的渐近效率界。后续章节会从均值开始逐步构建这条规则。

对于当前风险差，先用拟合的$Q$、$g$和初始风险差计算每个人的EIF输出，再对真实记录平均，得到的恰好就是上面的加权残差平均。这里用的是**经验分布（empirical distribution）**：让已观察到的每条患者记录各占$1/n$的权重，再按这些权重求平均。“经验”指依据当前样本；RHC队列中$n=5735$，死亡记录的总权重就是$1918/5735$。EIF在它所属的分布下均值为0；这里则是用拟合分布的EIF计算原始患者记录，因此这个平均可以非零，并成为一阶校正量（first-order correction）。

<div class="dr-intro-correction"></div>

## 4. AIPW和TMLE把同一条规则用在不同位置

**AIPW修正最终估计值。** 保留初始$Q$与$g$，把刚才算出的校正量加到g-computation结果上。

**TMLE（targeted maximum likelihood estimation，目标最大似然估计）更新$Q$后重新标准化。** 这里更新的是条件均值函数的估计：保留初始回归系数和$g$，拟合一个沿EIF指定方向调整的系数，得到新的预测函数。让更新后的加权残差平均接近0，再用新函数的两臂预测计算风险差。对于二元结局，更新在logit尺度上完成，预测仍是0到1之间的概率。标准TMLE在相应条件下也具有双重稳健性。

<div class="dr-intro-routes"></div>

两种方法分别把修正落实到一个最终数值和一套风险预测上。图中的结果接近，反映的是本次拟合与数据；判断估计的准确性和置信区间，还需要考察模型拟合和推断条件。

## 5. 沿着同一张患者表完成TMLE

前面已经看过两种修正的位置。现在依次走过TMLE的六个步骤：前三步准备预测并拟合更新幅度，接着更新两臂风险、求平均，最后用EIF计算不确定性的尺度。每一步保留同一批患者，新增列用蓝色标出；所有拟合和汇总使用全部5735人。

<!-- tmle-step:0 -->
### ① 保留三列初始风险预测

前面已经拟合了结局回归。现在把它的输出接到患者表中：实际处理下的预测用来计算残差；两种处理下的预测用来比较同一基线人群的风险。三列都来自同一个初始$Q$。

$
\widehat Q_{A,i}=\widehat Q(A_i,W_i),\qquad
\widehat Q_{1,i}=\widehat Q(1,W_i),\qquad
\widehat Q_{0,i}=\widehat Q(0,W_i).
$

> **符号回看：** $i$为原患者行号；$W_i$为该人的基线，$A_i$为实际处理。$\widehat Q_{A,i}$用于和实际结局$Y_i$比较；$\widehat Q_{1,i}$、$\widehat Q_{0,i}$分别在输入RHC和未RHC时预测死亡风险。下标0和1表示处理水平，帽号表示已拟合，所有预测均为概率。

**交给下一步：** 一列实际处理下的预测，以及两列供标准化使用的预测。

<!-- tmle-step:1 -->
### ② 从AIPW的加权残差提取$H$

第①步保留了初始风险预测。回到本章第2节的AIPW：它先计算标准化风险差，再加上逐人加权残差$C_i$的平均。前面按RHC与未RHC分组定义的$C_i$，可以合在一行写：

$
C_i=\underbrace{\left\{\frac{A_i}{\widehat g_i}
-\frac{1-A_i}{1-\widehat g_i}\right\}}_{H_{A,i}}
(Y_i-\widehat Q_{A,i}).
$

> **符号回看：** $C_i$是第$i$人的校正贡献；$Y_i$是实际死亡结局，$\widehat Q_{A,i}=\widehat Q(A_i,W_i)$是初始预测。$\widehat g_i=\widehat g(W_i)$是拟合RHC概率；$A_i$取0或1，因此花括号自动选中相应组的权重。我们把这个残差前的系数记为$H_{A,i}$。

**$H_{A,i}$就是前面IPW的带符号逆概率权重。** IPW用它乘实际结局，AIPW用它乘“实际结局减初始预测”。为后面更新两臂预测，分别保留两种输入下的系数：

$
H_{1,i}=\frac1{\widehat g_i},\qquad
H_{0,i}=-\frac1{1-\widehat g_i},\qquad
H_{A,i}=A_iH_{1,i}+(1-A_i)H_{0,i}.
$

> **符号回看：** $H_{1,i}$、$H_{0,i}$分别对应输入RHC与未RHC，$H_{A,i}$按实际处理选其中一个。$H$无量纲；负号来自“RHC风险减未RHC风险”。在TMLE更新中，这个系数称为clever covariate（巧妙协变量）。

<div class="tmle-ipw-placeholder"></div>

**现在把同一项$C_i$放回初始拟合EIF。** 它还要加上个人预测风险差相对全体平均的偏离：

$
\widehat D_i^{\mathrm{init}}
=\underbrace{C_i}_{H_{A,i}(Y_i-\widehat Q_{A,i})}
+(\widehat Q_{1,i}-\widehat Q_{0,i})
-\widehat\psi_{\mathrm{gcomp}}.
$

> **符号回看：** $\widehat D_i^{\mathrm{init}}$是初始拟合EIF对第$i$条记录的输出；$\widehat Q_{1,i}-\widehat Q_{0,i}$是该人的初始预测风险差，$\widehat\psi_{\mathrm{gcomp}}$是全部5735人预测风险差的平均。这里所有$Q$、$g$及中心值均来自初始拟合。

所以，逐人的EIF输出一般与$C_i$不同；对全体取平均，额外的中心化项才会消掉。将每一项分别求和：

$
\begin{aligned}
\frac1n\sum_{i=1}^n\widehat D_i^{\mathrm{init}}
&=\frac1n\sum_{i=1}^n C_i
 +\frac1n\sum_{i=1}^n(\widehat Q_{1,i}-\widehat Q_{0,i})
 -\frac1n\sum_{i=1}^n\widehat\psi_{\mathrm{gcomp}}\\
&=\frac1n\sum_{i=1}^n C_i
 +\widehat\psi_{\mathrm{gcomp}}
 -\frac n n\widehat\psi_{\mathrm{gcomp}}\\
&=\frac1n\sum_{i=1}^n C_i.
\end{aligned}
$

> **符号回看：** $n=5735$；求和覆盖全部患者。第二行中，预测风险差的平均按定义等于$\widehat\psi_{\mathrm{gcomp}}$；最后一项则把同一个中心值加了$n$次，再除以$n$。相消的是这两项，加权残差平均仍可非零。

这里可以分清三个对象：$\widehat\psi_{\mathrm{gcomp}}$是由初始$\widehat Q$得到的一个风险差估计；$\widehat D^{\mathrm{init}}$是由初始$\widehat Q$、$\widehat g$和这个中心值组成的函数；将它对5735位患者的输出取平均，再加回初始估计，得到**一步估计（one-step estimation）**。在当前标准化风险差的设定下，这个一步估计恰好就是AIPW：

$
\begin{aligned}
\widehat\psi_{\mathrm{one\text{-}step}}=\widehat\psi_{\mathrm{AIPW}}
&=\widehat\psi_{\mathrm{gcomp}}
 +\frac1n\sum_{i=1}^n\widehat D_i^{\mathrm{init}}\\
&=\widehat\psi_{\mathrm{gcomp}}+\frac1n\sum_{i=1}^n C_i\\
&=\frac1n\sum_{i=1}^n
 \{\widehat Q_{1,i}-\widehat Q_{0,i}+C_i\}.
\end{aligned}
$

> **符号回看：** $\widehat\psi_{\mathrm{one\text{-}step}}$与$\widehat\psi_{\mathrm{AIPW}}$在这里是同一个最终点估计；$\widehat\psi_{\mathrm{gcomp}}$是校正前的初始估计，$\widehat D_i^{\mathrm{init}}$是初始EIF对第$i$人的输出，$C_i$是该人的加权残差。$n=5735$，求和后除以$n$表示对全体患者取平均；帽号表示拟合或样本计算，风险差乘100后以百分点表示。

<div class="tmle-eif-aipw-placeholder"></div>

**“一步”指在完成初始拟合后，作一次EIF校正。**

**TMLE从相同的初始拟合出发，把校正落实到预测函数上。** AIPW的一步估计保留初始预测，直接得到校正后的数值；TMLE保留$\widehat g$，沿同一个$H$更新$\widehat Q$，再用更新后的预测重新标准化。把$H$设为logistic更新的协变量，score就是$H$乘更新后的残差。下一步将用这个回归拟合更新幅度，使加权残差的全体平均接近0。

<!-- tmle-step:2 -->
### ③ 拟合一次只有一个系数的logistic回归

这里的“更新$Q$”，指把**条件均值函数的初始估计$\widehat Q$变成新的估计函数$\widehat Q^*$**。可以分清三个层次：

- **初始模型参数固定。** 本例初始logistic回归已拟合的所有系数$\widehat\beta$保持原值，初始$g$也固定。
- **新增一个待估系数。** $\varepsilon$（fluctuation parameter，波动参数）控制沿$H$方向的共同调整幅度。
- **新函数产生新预测。** 拟合得到$\widehat\varepsilon$后，初始$Q$与这项调整共同定义$\widehat Q^*$；表中的更新预测是新函数在每位患者输入上的取值。

具体做法是：把初始预测的logit作为offset（固定偏置项），以实际死亡结局$Y$为响应、$H$为唯一协变量，拟合**不额外加截距**的logistic回归。对任意输入$(a,w)$，这族预测函数写成：

$
\operatorname{logit}Q_\varepsilon(a,w)
=\underbrace{\operatorname{logit}\widehat Q(a,w)}_{\text{保留初始模型}}
+\underbrace{\varepsilon H(a,w)}_{\text{新增的调整项}}.
$

> **符号回看：** $a$是0或1的处理输入，$w$是基线输入；$H(a,w)$是第②步$H$对任意这类输入的写法。$Q_\varepsilon$是给定$\varepsilon$后的条件均值估计函数，$\varepsilon=0$时回到$\widehat Q$。拟合时输入实际$(A_i,W_i)$，得到逐人offset和$H_{A,i}$；offset系数固定为1。唯一待估系数$\varepsilon$在全体患者间共用；$\widehat Q^*=Q_{\widehat\varepsilon}$。logit作用于预测概率，回归响应仍是0/1的$Y_i$。

你熟悉的“协变量乘残差”score在这里就是$H$乘残差。拟合$\varepsilon$会让它的全样本平均接近0：

$
\frac1n\sum_i H_{A,i}\{Y_i-Q_{\widehat\varepsilon}(A_i,W_i)\}\approx0.
$

> **符号回看：** $n=5735$；$\widehat\varepsilon$是拟合完成的共同系数；花括号内是更新后的逐人残差。这是对$\varepsilon$的似然score方程，$H$由倾向评分构造。数值求解在容差内停止。

**为什么一个共同$\varepsilon$就够？** 当前要估计的是一个总体风险差。每次用当前$Q$重新标准化，EIF中“个人预测风险差减去全体平均”的那部分，经验平均自动为0。余下需要用更新解决的，就是上面这一条加权残差平均为0的方程。

在本例选定的logistic更新路径上，$H$固定，改变一个$\varepsilon$就能连续改变这个汇总数；下图展示了本次拟合找到的有限根。因此，一个$\varepsilon$足以完成这次针对目标的校正。这个判断依赖于我们选中了与EIF相配的方向，而不仅仅因为目标是一个数。$Q$在所有基线下的预测质量，仍需要靠初始回归的学习与模型检查。

**共同$\varepsilon$也会产生不同的逐人调整。** 每个人实际加到logit上的量是$\varepsilon$乘自己的$H$；符号、大小随处理和基线而变。下面用同一CSV的前两位患者对照，再看全5735人的方程如何接近0。

<div class="tmle-direction-placeholder"></div>

<!-- tmle-step:3 -->
### ④ 把同一个$\varepsilon$应用到两臂预测

第③步已经得到新的估计函数$\widehat Q^*$。现在分别输入每个人的$(1,W_i)$和$(0,W_i)$，算出两臂预测。每次求值都先将初始预测转成logit，加上同一个$\widehat\varepsilon$乘相应的$H$，再用expit转回概率。这里的expit是logit的反函数。

$
\widehat Q^*_{a,i}
=\operatorname{expit}\{\operatorname{logit}\widehat Q_{a,i}
+\widehat\varepsilon H_{a,i}\},\qquad a\in\{0,1\}.
$

> **符号回看：** $a$是本次输入的处理水平，$\widehat Q_{a,i}$与$H_{a,i}$取对应臂的那一列。星号表示更新后的$Q$；两臂共用第③步拟合的$\widehat\varepsilon$。更新在logit尺度相加，输出回到0到1之间的死亡概率。实际$W$、$A$、$Y$及初始$g$保持不变。

**交给下一步：** 更新后的两列死亡风险。下面可对照同一患者在更新前后经历的运算。

<!-- tmle-step:4 -->
### ⑤ 用更新后的$Q$重新标准化

现在回到最初的研究问题。对每个人，用更新后的RHC风险减去未RHC风险，再平均，就得到TMLE估计。它仍然是一个可以解释为“两种预测风险的平均差”的点估计。

$
\widehat\psi_{\mathrm{TMLE}}=\frac1n\sum_{i=1}^n
(\widehat Q^*_{1,i}-\widehat Q^*_{0,i}).
$

> **符号回看：** $\widehat\psi_{\mathrm{TMLE}}$是最终风险差；$\widehat Q^*_{1,i}$、$\widehat Q^*_{0,i}$是第④步更新后的两臂预测；平均覆盖全部$n=5735$人，结果乘100得到百分点。

**方程归零，究竟完成了什么？** 初始$Q$给出两种处理下的预测。实际死亡结局让我们计算每条记录的“实际结局减预测概率”残差，再查看这些残差怎样汇总。EIF中的$H$把它们按目标人群重新加权，再按“RHC减未RHC”汇总。这个平均值提供一项针对风险差的校正信息。

AIPW把它加到初始风险差上。TMLE则沿$H$更新$Q$，直到更新后的预测与实际结局在这项加权检查上吻合，再重新计算风险差。**归零表示这项样本内检查已满足；估计是否更接近真实目标，则是另一个需要真值才能直接判断的问题。**

<div class="tmle-calibration-placeholder"></div>

**为什么这种校正具有双重稳健性（double robustness）？** 可以沿着残差的来源理解：

- **$Q$正确时：** 在相同基线、相同处理下，预测就是平均死亡风险。这样的残差在总体中平均为0，再乘由处理与基线决定的$H$，平均仍为0。初始标准化已经给出目标；总体层面的校正不会把它推离目标。
- **$g$正确时：** 即使$Q$有偏差，正确的逆概率权重也能把各处理组观察到的残差，换算为共同目标人群中的平均预测偏差。将两臂的偏差相减，恰好补上初始风险差缺少的部分。
- **两者都有误差时：** 残差需要校正，而用于换算的权重也不准确，校正后可以留下偏差。其剩余部分同时涉及$Q$误差与$g$误差；AIPW这里涉及初始$Q$，TMLE则涉及更新后的$Q$。这就是为什么把其中一项估准会有帮助。

这里说的是对总体分布取平均的关系。AIPW直接使用这项校正；TMLE让更新后的$Q$满足同一结构的方程。对应到实际估计，双重稳健性是：在相应正则条件下，$Q$或$g$至少一个得到一致估计时，估计量随样本量增加趋向目标。有限样本还带有抽样误差，因而一次更新可能更接近，也可能更远离真实值。我们能从本次数据直接验证的是方程与计算；双重稳健解释的是这条校正为什么在上述条件下有用。

<details>
<summary>在已知参考分布中，方程归零后还能有偏差吗？</summary>

把这5735人的sex、RHC与30日死亡联合频率固定为一个**教学参考分布（reference distribution）**，记为$P_{\mathrm{ref}}$。现在只按sex调整，参考风险差可以直接算出。下面始终对这个固定分布取平均，以便单独观察$Q$、$g$误差的作用。

“$Q$正确”指使用参考分布中每个sex与处理组合的实际死亡比例；“$g$正确”指使用每个sex组的实际RHC比例。我们有意改动这些预测，分别制造三种情形。全部情形都采用相同的TMLE更新规则。

<div class="tmle-reference-placeholder"></div>

第三种情形中，方程已归零，TMLE仍偏离参考目标。这说明**解方程与消除全部估计误差不是同一件事**。前两种情形则展示了双重稳健的总体关系：有一项正确，就能回到参考目标。

图中的参考风险差只按sex调整；上面的实际分析使用更完整的$W$调整，两者对应不同的统计目标。$P_{\mathrm{ref}}$把本次样本频率当作已知概率；真实总体$P_0$仍然未知。这个对照展示校正机制，实际RHC分析的准确性还取决于模型拟合、抽样及因果识别条件。

<details>
<summary>回看参考实验怎样改变$Q$和$g$</summary>

sex取Female、Male的顺序。$Q$正确时使用四个参考死亡比例；$Q$有误差时，将未RHC预测分别增加0.12、0.06，将RHC预测分别减少0.06、0.12。$g$正确时使用两个参考RHC比例；第一种情形把两者都设为0.5，第三种情形把各自原值向0.5移动一半。所有预测仍在0到1之间。每种情形更新时，初始$Q$与$g$固定，只拟合共同$\varepsilon$，再用更新$Q$和固定$g$检查方程。

</details>
</details>

<!-- tmle-step:5 -->
### ⑥ 用更新后的EIF研究不确定性

得到点估计后，EIF还有第二个用途。把更新后的$Q$、固定的$g$与最终风险差代回EIF，给每位患者计算一个输出。它由“加权残差”和“个人预测风险差相对全体平均的偏离”相加组成：

$
\widehat D_i=H_{A,i}(Y_i-\widehat Q^*_{A,i})
+(\widehat Q^*_{1,i}-\widehat Q^*_{0,i})-\widehat\psi_{\mathrm{TMLE}}.
$

> **符号回看：** $\widehat D_i$是拟合EIF对第$i$条实际记录的输出；$\widehat Q^*_{A,i}$按实际$A$选取更新预测，$H$仍由初始$g$计算。最后减去的是第⑤步的全体风险差。各人的输出可以非零；其平均接近0：第一项由第③步求解，后两项由第⑤步中心化。

先计算这些输出的**经验方差（empirical variance）**，即依据当前样本，衡量逐人输出围绕其样本平均的离散程度。在RHC队列中，将5735个EIF输出分别减去它们的平均，平方后再取平均；这里用分母$n$，即5735。通常用于无偏估计总体方差的样本方差采用$n-1$；本教程此处采用经验分布下的方差，使用$n$。这些输出的离散程度提供估计误差的尺度。在独立观测、足够重叠及拟合误差余项可忽略等推断条件下，可用下式估计标准误（standard error, SE）：

$
\overline D=\frac1n\sum_{i=1}^n\widehat D_i,\qquad
\widehat{\mathrm{Var}}(\widehat D)=\frac1n\sum_{i=1}^n(\widehat D_i-\overline D)^2,\qquad
\widehat{\mathrm{SE}}=\sqrt{\frac{\widehat{\mathrm{Var}}(\widehat D)}n}.
$

> **符号回看：** $\widehat D_i$是第$i$位患者的EIF输出，$\overline D$是这些输出的样本平均；$\widehat{\mathrm{Var}}(\widehat D)$是上式算出的方差，$n$是独立观测数。开平方后得到风险差的标准误。图中按同一公式计算；第7–8章再解释有效推断所需的条件和误差控制。

**EIF的两次用途连起来了：** 第②–③步用它选择更新方向和求解方程；这一步用它衡量估计的不确定性。双重稳健保证的是相应条件下的一致性，有效区间估计还需要这里的推断条件。


我们用logistic回归完成初始Q、g拟合，也可以在这些位置使用合适的其他预测方法。TMLE的关键结构是后面的针对目标更新。第8章会将这里的每一步对应到Julia/R代码，实际查看求解过程。

接下来，我们先暂时合并两种处理，只问这5735人的30日死亡均值。均值的IF是$y-\mu$：输入一个结局$y$，输出它与参考均值$\mu$的差。**为什么这个差能描述分布变化对均值的影响？** 第1章从加权平均开始推导；第8章再回到同一队列，逐步完成AIPW与TMLE。

[进入第1章：从死亡均值推导IF →](#chapter-1)

<!-- 暂时隐藏补充阅读入口，保留材料以便恢复。
[补充阅读：估计目标、IPW/PSM、GLM score、IF均值与修正方程，以及Julia/R工作簿](chapter-0-details.html#chapter-0)
-->


---

# 第 1 章：如何从30日死亡比例推导均值IF？

第0章最后留下了一个问题：为什么均值的影响函数是$y-\mu$？这一章先从均值本身出发，把这条规则推出来，再与熟悉的logistic回归score对照。

仍然使用那5735位RHC队列患者：1918人在30天内死亡，3817人存活。本章沿用第0章末尾的均值问题，将两种处理合在一起，只读取30日结局。我们先计算死亡比例，再改变这两类结局的概率权重，观察均值怎样随之改变。这一步会为后面推导RHC标准化风险差的IF准备方法。

## 0. 从上一章的30日死亡均值继续推导

沿用已经确定的编码：原始`dth30`为Yes记$Y=1$，No记$Y=0$。1与0记录的是30日时的生命状态。若把从入组起算的全因死亡时间记为$T$，单位为天，这个编码可以写成：

$$
Y=\mathbf1\{T\le30\}.
$$

> **符号回看：** $\mathbf1$是条件成立取1、否则取0的指示函数（indicator function）；大写$T$是时间，$Y$是结局编码。小写$t$稍后表示概率扰动比例：大写$T$以天计，小写$t$表示无单位的概率变化步长。

<div class="course-visual" data-visual="survival-window"></div>

图中的示例日期帮助我们读懂0和1，计算仍使用原CSV的结局列。原研究已确认全体患者的死亡日期或180日存活，因此这5735条30日结局都有已知取值。

<details><summary>如果只随访了20天，能确定30日结局吗？</summary>

若20天后失访，且没有其他生命状态来源，30日结局应记为未知。给Y赋值需要知道30日时的生命状态。本数据的生命状态由原研究确认，因而这里可以直接计算完整结局列的平均。

</details>

## 1. 把死亡比例写成概率的加权平均

第0章算过的1918/5735，可以直接由这列0和1的平均得到。把相同结局合并，逐人求和便成为“每类人数乘上结局编码”；再把分母分给两项，就能看到各类概率怎样进入均值。用帽号标记从当前样本计算的结果：

$$
\begin{aligned}
\widehat\mu&=\frac{3817\times0+1918\times1}{5735}\\
&=0\times\frac{3817}{5735}+1\times\frac{1918}{5735}\\
&=\frac{1918}{5735}\approx0.334438.
\end{aligned}
$$

> **符号回看：** $\widehat\mu$是这份样本的死亡比例；3817、1918是人数，5735是总人数。分母分给每项后得到经验概率；显示小数四舍五入，分数保留精确值。

下图把同一次计算画出来：每位患者的结局占一行，组成向量（vector）；将全部5735项加总、再除以5735，输出一个标量（scalar），也就是死亡比例。显示窗口只预览若干患者行，求平均时用到完整结局列。

<div class="course-visual" data-visual="sample"></div>

接下来要改变的是概率权重，所以先把出发点固定下来。沿用第0章的经验分布$P_n$：每条RHC记录的权重为$1/5735$；本章取它作为参考分布$P=P_n$。因此，存活类的总权重是3817/5735，死亡类的总权重是1918/5735。

下面用$\mu$表示这个固定参考的均值；$\widehat\mu$则强调它是从样本算出的估计值。本例二者数值相同，所扮演的角色不同。第0章中用于讨论真实估计误差的$P_0$及其均值仍未知，这里先在已知参考处把导数算清楚。

将死亡概率简记为r，存活概率简记为c。后面的每一步都沿用这两个精确分数：

$$
r=\frac{1918}{5735},\quad c=\frac{3817}{5735},\quad r+c=1,\quad\mu=\mathbb E_P[Y]=0c+1r=r.
$$

> **符号回看：** $r$是参考死亡概率，$c$是存活概率，由各类人数除以总人数得到；$\mathbb E_P$是按P权重平均，$\mu$是结果。后续每次出现r或c，都沿用这两个分数。

<div class="course-visual" data-visual="distribution"></div>

这就是第0章的泛函（functional）写法：$\Psi(P)=\mathbb E_P[Y]=\mu$。输入是两类结局的概率，输出是它们的加权平均。要找均值的IF，现在只需沿着这个运算追踪：输入的概率改变后，输出跟着改变多少？

## 2. 先选一种具体的概率变化

为了计算变化率，需要一条可以连续调节的变化规则。先选择死亡结局1：从原分布的每一类拿出10%的权重，再把拿出的总量全部放到1这一类。

存活类原有c，保留90%后剩$0.9c$；死亡类原有r，保留后剩$0.9r$。两类一共拿出$0.1c+0.1r=0.1(c+r)=0.1$，全部加回死亡类，于是新权重为$0.9c$与$0.9r+0.1$。下图保留原权重、拿出部分和重新分配后的结果，可以逐步核对这次运算。

<div class="course-visual" data-visual="replacement"></div>

原始患者记录保持固定，重新分配的是结局0和1的概率。将接收权重的结局记为$z$，这次$z=1$；将拿出再放回的比例记为$t$，这次$t=0.1$。让t连续变化，就得到一整条分布变化的路径。

这里的10%是替换比例。死亡类自己拿出的$0.1r$又回到原类，死亡概率净增加的只有从存活类移来的$0.1c$，约为6.66个百分点。第0章将从存活移向死亡的概率量记为$\delta$；这次两种记法对应$\delta=tc$。分清替换比例与净转移量，后面才知道导数是对哪个量求的。

仍固定$z=1$，把10%换成一般的t，新概率以及它们的总和为：

$$
\begin{aligned}
p_0(t)&=(1-t)c,\\
p_1(t)&=(1-t)r+t,\\
p_0(t)+p_1(t)&=(1-t)c+(1-t)r+t\\
&=(1-t)(c+r)+t\\
&=(1-t)\times1+t=1-t+t=1.
\end{aligned}
$$

> **符号回看：** $p_0(t),p_1(t)$是两个新概率，$c,r$仍是固定原概率，$t$无单位。最后四行提取共同因子并消去$-t+t$，验证总概率仍为1。

<div class="course-visual" data-visual="mixture"></div>

刚才的逐项运算还可以压缩成一句分布公式。将全部概率放在z的分布称点质量（point mass），记$\delta_z$；它接收我们从原分布拿出的全部权重。于是：

$$
P_t=(1-t)P+t\delta_z.
$$

> **符号回看：** $P_t$是扰动后分布，$P$是原参考分布；$\delta_z$只把全部权重集中到选定结局。带下标的$\delta_z$表示一个分布，上文没有下标的$\delta$表示转移了多少概率。此处$0\le t\le1$表示普通混合：保留原分布的$1-t$，将$t$放在选定结局上。

## 3. 沿这条路径，均值究竟改变多少？

有了新概率，就能按原来的加权平均规则重新计算。仍取$z=1$，先把0和1各自乘上新概率，再逐行展开括号：

$$
\begin{aligned}
\Psi(P_t)&=0\times[c(1-t)]+1\times[r(1-t)+t]\\
&=0c-0ct+1r-1rt+1t\\
&=0-0+r-rt+t\\
&=r-rt+t\\
&=r+(-r+1)t\\
&=r+(1-r)t=r+ct.
\end{aligned}
$$

> **符号回看：** $\Psi(P_t)$是新风险；r是原死亡概率，c是$1-r$。第二行用分配律（distributive law），第三行计算0与1乘法；最后从两项$-rt+t$提出t。它们只部分抵消，留下ct。

<div class="course-visual" data-visual="mean-change"></div>

新均值已经整理成$r+ct$，原均值是r。先相减得到变化量，再除以这次使用的替换比例t，就得到每单位替换比例的变化率。这个商称为差商（difference quotient）：

$$
\begin{aligned}
\Psi(P_t)-\Psi(P)&=(r+ct)-r\\
&=(r-r)+ct=ct,\\
\frac{\Psi(P_t)-\Psi(P)}t&=\frac{ct}t=c\quad(t\ne0),\\
\left.\frac{d}{dt}\Psi(P_t)\right|_{t=0}&=c=1-r.
\end{aligned}
$$

> **符号回看：** 第一对括号是变化量，差商是“变化量÷步长”；导数（derivative）是差商在起点的极限。这里每个合法非零t的差商已等于c，所以取极限不会再改数值。ct是实际变化，c是每单位t的变化率。

<div class="course-visual" data-visual="rate"></div>

### 把选择的结局换成0，规律还一样吗？

刚才一直把权重放到死亡类。也可以放到存活类，这时选$z=0$；我们希望用同一条式子涵盖这两个选择。

将结局0和1各放一行，用j标记行，$y_j$是该行的结局编码，$p_j$是原概率。先为每行保留$(1-t)p_j$，再将t加到结局等于z的那一行。指示函数$\mathbf1\{y_j=z\}$在选中行取1，另一行取0，所以新概率统一写成$(1-t)p_j+t\mathbf1\{y_j=z\}$。把两行加起来，求和（summation）得到：

$$
\begin{aligned}
\Psi(P_t)&=\sum_j y_j[(1-t)p_j+t\mathbf1\{y_j=z\}]\\
&=\sum_j[y_jp_j-ty_jp_j+ty_j\mathbf1\{y_j=z\}]\\
&=\sum_j y_jp_j-t\sum_j y_jp_j+t\sum_j y_j\mathbf1\{y_j=z\}\\
&=\mu-t\mu+tz\\
&=\mu+t(z-\mu).
\end{aligned}
$$

> **符号回看：** $\sum_j$把两行相加；前两处和是均值μ，最后的指示开关只保留选中行，所以是z。t对两行相同，可提出求和。其中μ始终是扰动前固定参考分布的均值。

<div class="course-visual" data-visual="general"></div>

取z=0时，死亡类保留$(1-t)r$，因此从存活移向死亡的净概率量为$\delta=-tr$；取z=1时则为$\delta=tc$。这也解释了为什么同样的替换比例，在两个方向产生的变化量大小不同。

这个结果已经把原均值与变化分开：$\mu$是起点，$t(z-\mu)$是沿选定路径产生的变化。再像刚才一样减去原均值、除以非零步长，得到：

$$
\begin{aligned}
\Psi(P_t)-\Psi(P)
&=[\mu+t(z-\mu)]-\mu\\
&=(\mu-\mu)+t(z-\mu)=t(z-\mu),\\
\frac{\Psi(P_t)-\Psi(P)}{t}
&=\frac{t(z-\mu)}{t}=z-\mu\quad(t\ne0),\\
\lim_{t\to0}\frac{\Psi(P_t)-\Psi(P)}{t}
&=z-\mu.
\end{aligned}
$$

> **符号回看：** P和它的均值μ始终固定，z选定权重移向哪个结局，t调节替换比例。首两行消去原均值；第三行在t非零时约去分子、分母的t。差商已经与t无关，所以第四行取极限仍是同一个数。t=0时两分布重合，差商的0/0未定义，导数由附近差商的极限给出。

## 4. 变化率怎样成为影响函数？

我们现在有了两个可以核对的答案：向0替换时，变化率是$0-\mu=-r$；向1替换时，变化率是$1-\mu=c$。两次计算只改变了选中的结局z，原分布P和均值μ都相同。

把“给定一个结局，返回朝它替换时的均值变化率”写成函数，就是这个均值目标的影响函数（influence function，IF）。输入z是一个0或1，输出$z-\mu$是一个实数：

$$
D(z;P)=\left.\frac{d}{dt}\Psi((1-t)P+t\delta_z)\right|_{t=0}=z-\mu.
$$

> **符号回看：** $D(z;P)$接收具体结局z，输出相应变化率；分号右侧的P说明参考均值μ取自哪个分布。它与第0章的$D^{\mathrm{mean}}_P(z)$表示同一条规则：下标或分号都在标记固定参考。导数对替换比例t求，z在求导过程中保持固定。

两个可能输入的函数值都由刚才的导数确定了：0对应−μ，1对应1−μ。把它们合写，正是“输入减参考均值”。下图将求导结果与函数的两个输入对应起来。

<div class="course-visual" data-visual="rate-function"></div>

z在推导中用来强调“选哪个结局作为替换方向”。将这条函数用于一条已知记录时，通常把它的具体结局写成y。因此，$D(y;P)=y-\mu$正是第0章使用的规则；换输入字母后，计算没有改变。输入0得到约−0.3344，输入1得到约+0.6656。下图把两个输入与各自输出并排保留。

<div class="course-visual" data-visual="influence"></div>

规则已经确定，也就可以讨论它会以多大概率给出每种输出。从固定参考分布P抽取一条记录时，用大写Y表示尚未确定的结局；把它放入同一条函数，$D(Y;P)=Y-\mu$就是一个随机变量（random variable）。它以死亡概率1918/5735取值c，以存活概率3817/5735取值−r。下图将结局的概率直接对应到输出的概率。

<div class="course-visual" data-visual="random-influence"></div>

### 为什么两种非零输出的平均是0？

现在将所有可能的输出按出现概率平均。存活对应负值−r，死亡对应正值c；这两个数的大小不同，出现概率也不同。把每种输出乘上它在参考分布中的概率，再相加：

$$
\begin{aligned}
\mathbb E_P[D(Y;P)]&=c(0-r)+r(1-r)\\
&=0c-cr+r-r^2\\
&=-cr+r-r^2\\
&=r-r(c+r)\\
&=r-r\times1=0.
\end{aligned}
$$

> **符号回看：** c、r是两行权重，括号内是两种影响值；按各自概率加权后，正负贡献利用$c+r=1$恰好抵消。每种结局仍保留自己的影响值，0是加权汇总的结果。

<div class="course-visual" data-visual="centering"></div>

正负两部分抵消，是因为每种结局都减去了同一个、按这些概率计算的均值。把两类结局写回求和形式，这个理由会更清楚：

$$
\begin{aligned}
\mathbb E_P[Y-\mu]&=\sum_jp_j(y_j-\mu)\\
&=\sum_jp_jy_j-\sum_jp_j\mu\\
&=\mu-\mu\sum_jp_j\\
&=\mu-\mu\times1=0.
\end{aligned}
$$

> **符号回看：** μ对所有行固定，因此提出求和；第一项按均值定义为μ，概率和为1。中心化（centring）将函数置于均值零空间，下一讲会解释它为何与概率和约束有关。

<div class="course-visual" data-visual="centering-proof"></div>

这个0也接回了第0章关于“两种平均”的问题。刚才用P准备规则，又按P的概率平均，中心恰好匹配。如果保留旧规则$D(Y;P)=Y-\mu$，却改用$P_t$的概率平均，结果就是$\mathbb E_{P_t}D=\Psi(P_t)-\mu=t(z-\mu)$。它留下的是新旧均值之差。

如果希望在新分布下平均为0，就把规则中的中心一同换成新均值，使用$Y-\Psi(P_t)$。下图分别固定旧函数、更新平均权重，再更新函数中心，可以看到每一次改变的是哪个对象。

<div class="course-visual" data-visual="reference-distribution"></div>

### 同一个残差怎样连到logistic回归的score？

概率替换已经给出了均值IF。现在回到第0章提到的只有截距的logistic模型，用另一种求导来检查同一个残差。只看二元结局Y时，一个概率μ就确定了整个Bernoulli分布；用截距$\beta=\operatorname{logit}(\mu)$，是给同一组分布换一种参数化（parametrisation）。这里$0<\mu<1$，两种结局都有正概率。

先固定一条记录的结局y，写出它的概率，再取对数。对数似然（log-likelihood）沿截距的导数，便是单观测score：

$$
\begin{aligned}
p_\beta(y)&=\mu^y(1-\mu)^{1-y},\qquad \mu=\frac{e^\beta}{1+e^\beta},\\
\ell(\beta;y)&=y\log\mu+(1-y)\log(1-\mu)\\
&=y\{\beta-\log(1+e^\beta)\}+(1-y)\{-\log(1+e^\beta)\}\\
&=y\beta-\{y+(1-y)\}\log(1+e^\beta)\\
&=y\beta-\log(1+e^\beta),\\
s_\beta(y)&=\frac{\partial\ell(\beta;y)}{\partial\beta}
=y-\frac{e^\beta}{1+e^\beta}=y-\mu.
\end{aligned}
$$

> **符号回看：** y是固定的0或1，β是正在变化的截距，μ随β通过expit变化。$p_\beta(y)$给出该结局的概率；$\ell$是它的自然对数；$s_\beta$是一条记录贡献的导数。第三行将logit参数化代入两项，第五行合并$y+(1-y)=1$。这一段对β求导，前面的IF推导则对替换比例t求导。

因此，当前参考下的一位死亡患者，两种规则都输出约+0.6656；一位存活患者都输出约−0.3344。对score，符号说明增大截距怎样改变这条记录的对数似然；对均值IF，符号说明朝这个结局增加权重怎样改变死亡概率。

两者相同到什么程度？可以先把score加起来。下面$\widehat\beta$是只含截距的极大似然估计（maximum likelihood estimate），$\widehat\mu=\operatorname{expit}(\widehat\beta)$：

$$
\begin{aligned}
0&=\sum_{i=1}^n s_{\widehat\beta}(y_i)
=\sum_{i=1}^n(y_i-\widehat\mu)\\
&=\sum_{i=1}^n y_i-n\widehat\mu,\\
n\widehat\mu&=\sum_{i=1}^n y_i,\qquad
\widehat\mu=\frac1n\sum_{i=1}^n y_i=\frac{1918}{5735}.
\end{aligned}
$$

> **符号回看：** n是5735人，$\sum_i y_i$是1918个死亡。帽号表示用这份数据求出的拟合结果。这里解的是所有记录的score之和为0；每条记录仍有自己的正或负贡献。求出的概率等于本样本均值，因此它对应的均值IF经验平均也为0。第0章中未知真实$\mu_0$所对应的估计误差仍是$\widehat\mu-\mu_0$。

### 换一个目标，就能看清score与IF的分工

保持同一Bernoulli分布、同一个logistic score，假设这次想报告死亡概率的logit，即β。前面已经算出替换后的死亡概率$\mu_t=\mu+t(z-\mu)$；把这个结果放进logit，再用链式法则（chain rule）求导：

$$
\begin{aligned}
\beta_t&=\log\mu_t-\log(1-\mu_t),\\
D^{\mathrm{logit}}_P(z)
&=\left.\frac{d\beta_t}{dt}\right|_{t=0}\\
&=\left\{\frac1\mu+\frac1{1-\mu}\right\}(z-\mu)\\
&=\frac{(1-\mu)+\mu}{\mu(1-\mu)}(z-\mu)
=\frac{z-\mu}{\mu(1-\mu)}.
\end{aligned}
$$

> **符号回看：** $\mu_t$是替换后的死亡概率，$\beta_t$是它的logit。$D^{\mathrm{logit}}_P$表示新目标logit死亡概率的IF；导数仍对t求。$-\log(1-\mu_t)$求导时两次负号相消。$z-\mu$来自已经证明的$d\mu_t/dt$；前面的括号将概率变化换算为logit变化。

这样就看出：同一个score可以对应不同目标的IF。均值目标输出$z-\mu$，logit目标还需除以$\mu(1-\mu)$。这个除数也能从似然中读出：它是本模型的单观测Fisher信息（Fisher information），记为$I_\beta$，描述对数似然随β弯曲的程度：

$$
\begin{aligned}
\frac{d\mu}{d\beta}
&=\frac{e^\beta(1+e^\beta)-e^{2\beta}}{(1+e^\beta)^2}
=\frac{e^\beta}{(1+e^\beta)^2}=\mu(1-\mu),\\
-\frac{\partial s_\beta(y)}{\partial\beta}&=\mu(1-\mu),\qquad
I_\beta=\mathbb E_P\!\left[-\frac{\partial s_\beta(Y)}{\partial\beta}\right]=\mu(1-\mu),\\
D^{\mathrm{logit}}_P(y)&=I_\beta^{-1}s_\beta(y),\\
D^{\mathrm{mean}}_P(y)&=\frac{d\mu}{d\beta}\,D^{\mathrm{logit}}_P(y)
=\mu(1-\mu)\frac{y-\mu}{\mu(1-\mu)}=y-\mu.
\end{aligned}
$$

> **符号回看：** $I_\beta$是单条观测的信息，$I_\beta^{-1}$在这个一参数例子中就是倒数。第一行用商式求导；第二行对score再求导并取负号。其值与y无关，取期望后不变。最后两行先换算到logit目标，再乘expit的导数回到概率目标，两个比例因子抵消。这里的关系在当前Bernoulli模型中直接推得；一般模型的效率问题留到第6–7章。

<div class="glm-score-placeholder" data-glm-score="1"></div>

图中的每一行都来自同一位患者。读数时先指定目标：中间的放大值对应logit死亡概率，末列对应死亡概率。**先预测：若改为报告logit死亡概率，两种结局的IF绝对值都会变大吗？为什么符号保持不变？**

<details><summary>核对答案，并换用均值参数表示</summary>

会。当前$0<\mu(1-\mu)\le1/4$，除以它会放大绝对值，正分母保留符号。两列衡量的目标尺度不同。

还可以保持死亡概率目标，改用μ本身作似然参数。链式法则会改变score的数值：

$$
\begin{aligned}
s_\mu(y)&=\frac{\partial}{\partial\mu}\{y\log\mu+(1-y)\log(1-\mu)\}\\
&=\frac y\mu-\frac{1-y}{1-\mu}
=\frac{y(1-\mu)-\mu(1-y)}{\mu(1-\mu)}\\
&=\frac{y-y\mu-\mu+\mu y}{\mu(1-\mu)}
=\frac{y-\mu}{\mu(1-\mu)}.
\end{aligned}
$$

> **符号回看：** $s_\mu$对概率参数μ求导，$s_\beta$对logit参数β求导。二者描述同一组Bernoulli分布，但单位步长不同，所以数值不同。均值IF仍由同一个概率替换操作和均值目标确定，为$y-\mu$。

</details>

### 从回归参数的score走向分布路径的score

最后把“截距改变一点”也写成分布变化。另取一条路径：截距从β变为$\beta+t$，死亡概率随之变为$\mu_t=\operatorname{expit}(\beta+t)$。本段重新用t表示**logit尺度的增量**；它与前面的替换比例属于不同路径。

路径的得分函数（path score）是沿这条路径对数概率的导数。因为$d(\beta+t)/dt=1$，它恰好等于刚才的截距score。目标变化率则是expit的导数：

$$
\begin{aligned}
S_{\mathrm{logit}}(y)
&=\left.\frac{d}{dt}\log p_{\beta+t}(y)\right|_{t=0}
=s_\beta(y)=y-\mu,\\
\left.\frac{d\mu_t}{dt}\right|_{t=0}&=\mu(1-\mu),\\
\mathbb E_P[D^{\mathrm{mean}}_P(Y)S_{\mathrm{logit}}(Y)]
&=(1-\mu)(-\mu)(-\mu)+\mu(1-\mu)(1-\mu)\\
&=\mu(1-\mu)\{\mu+(1-\mu)\}
=\mu(1-\mu).
\end{aligned}
$$

> **符号回看：** S描述此处指定的logit路径，D描述均值目标。期望按固定P的概率计算：Y=0用权重$1-\mu$，Y=1用权重μ。两者逐项相乘再加权，结果等于目标沿这条路径的变化率。这是“梯度与方向的配对”在一个熟悉回归模型中的具体计算。

<div class="glm-score-placeholder" data-glm-score="pairing"></div>

现在三件事连起来了：改变回归参数会产生一条分布路径；score描述这条路径；IF与score相乘并按参考分布平均，给出目标沿路径的导数。刚才验证的是logit路径。下一讲回到概率替换路径，从它自己的概率公式推导score，再检查同样的配对关系。

## 5. 用刚推导的规则预测，再用原定义核对

现在有两种计算途径：直接用新概率求加权平均，或者用原均值加上$t(z-\mu)$。先选z=1、t=0.1，预测死亡比例增加多少、30日生存比例减少多少，再操作下方实验核对。随后回到前面的对象图，将它的替换比例t设为0，比较变化量、差商和导数各自的结果。

<div class="lab" data-lab="1"></div>

<details><summary>练习一答案：将20%权重集中到Y=1</summary>

新风险为$\mu+0.2(1-\mu)=r+0.2c$；变化量0.2c，变化率c。图中另用新概率直接加权求均值，可与这个结果相互核对。

<div class="course-visual" data-visual="exercise-one"></div>

</details>

<details><summary>练习二答案：将80%权重集中到Y=0</summary>

新风险为$\mu+0.8(0-\mu)=0.2r$；变化量−0.8r，变化率−r。原来的死亡类仍保留20%权重。

<div class="course-visual" data-visual="exercise-two"></div>

</details>

## 6. 如果报告的是30日生存概率

刚才的实验还显示了生存概率。它与死亡概率相加为1，所以死亡概率向上改变多少，生存概率就向下改变多少。将30日生存概率记为$S(30)=1-\mu$。沿同一路径：新生存概率减旧值为$[1-\Psi(P_t)]-[1-\mu]=-t(z-\mu)$，故其IF为$-(z-\mu)$。S(30)表示30日这个时点的生存概率。下一讲还会用字母S表示路径score；届时可依据参数和所在公式辨认两种用途。

<div class="course-visual" data-visual="survival-complement"></div>

<details><summary>为什么均值例子没有近似余项？负t能用吗？</summary>

回看§3的展开：结局值保持固定，变化只进入它们所乘的概率，每个新概率又都只含t的一次项。加权求和后仍只有常数项与t的一次项，因而$\Psi(P_t)=\mu+t(z-\mu)$精确成立。这就是均值对概率权重的线性（linearity），变化量恰好等于步长乘变化率。后续的条件均值含商式，分母也随路径改变，届时需要区分一阶部分与剩余项。

本章的结局只取0和1，参考概率c与r都严格为正，所以可沿点质量替换路径在起点附近求导。固定z=1时，使两类概率都严格为正的范围为$-r/c<t<1$；允许端点概率为0时可取闭区间。负t表示沿相反方向调整概率；普通“拿出再放回”的混合图像则适用于0到1之间的t。

连续分布中使用同类路径，需要另外核对正则子模型（regular submodel）的条件：加入点质量可能改变支持及密度性质。第五讲将用模型允许的平滑score方向来表达和检查导数。

<div class="course-visual" data-visual="boundary"></div>

</details>

## 7. 用代码复算均值与影响函数

<div class="lesson-language-control"><label>本章代码语言 <select data-lesson-language><option value="julia">Julia运算</option><option value="r">R运算</option></select></label><span>使用同一份RHC数据与相同的数学目标</span></div>

<div class="lesson-code-panel" data-lesson-panel="julia">


数学步骤已经齐全，现在可以让代码按相同顺序执行：读取原CSV的结局，计算参考均值；选择z与t，重算扰动后的均值；最后逐项求IF并核对加权平均。输入仍是这一份RHC数据，输出对应前面已经算过的数。

代码区可以选择Julia或R，每种语言都有实际脚本与逐行说明。先沿“输入、运算、输出”读一遍，再查看不熟悉的语法；CSV中的引号等读取细节由模块处理。每一行的作用，都可以回到前面的均值、概率替换或中心化运算中找到。

运行前输入是[同一份RHC原始CSV](../shared/data/public/rhc/source.csv)。读取与拟合定义见[RHCCase.jl](../shared/julia/RHCCase.jl)，完整[本讲脚本](julia/rhc_lessons/ch01.jl)可编辑；所有脚本可从其他工作目录运行，只须保留zh/与shared/相对位置。

```sh
julia --startup-file=no --history-file=no zh/julia/rhc_lessons/ch01.jl
```

```julia
# 第1讲：直接读取公开 RHC 原始记录，计算 30 日死亡均值。
# include 执行另一个文件，使读取函数可以在这里使用。
include(joinpath(@__DIR__, "..", "..", "..", "shared", "julia", "RHCCase.jl"))
# using 把模块导出的函数名带到当前脚本。
using .RHCCase
# DEFAULT_SOURCE 是随项目冻结的原始 CSV 的绝对路径。
rows = read_rhc_rows(DEFAULT_SOURCE)
# 一行对应一位患者；这里没有删人、补值或重采样。
observations = rhc_observations(rows)
# length 数出总人数，对应数学式里的 n。
n = length(observations)
# 每位患者的 Y：原字段 dth30 为 Yes 时等于 1，否则等于 0。
y = [person.y for person in observations]
# sum 把 0/1 相加，所以 events 就是死亡人数。
events = sum(y)
# 除法 / 得到样本均值：μ̂ = (Y₁ + … + Yₙ) / n。
risk = events / n
# 每位患者的影响值：Dᵢ = Yᵢ − μ̂。
influence = y .- risk
# 点号 .- 表示逐个相减；sum 再将影响值加起来。
mean_influence = sum(influence) / n
# 相同的原始记录可以按(X,A,Y)组合汇总人数，便于后续推导。
data = rhc_data(DEFAULT_SOURCE)
# mean_if 用各格人数加权，应与上面的逐人结果一致。
check = mean_if(data)
# @assert 让两个实际计算不一致时立即停止。
@assert isapprox(check.risk, risk) && abs(mean_influence) < 1e-12
println("原始患者数 n = ", n, "；30 日死亡人数 = ", events)
println("样本死亡风险 μ̂ = ", risk)
println("Y=0 的 IF = ", -risk, "；Y=1 的 IF = ", 1-risk)
println("逐人 IF 平均 = ", mean_influence, "；按组人数加权 IF 平均 = ", check.mean)
# 这是全队列的描述性均值；本讲尚未估计处理效果。
```


<details><summary>逐行解释：输入、运算与输出</summary>

### 代码第3行

```julia
include(joinpath(@__DIR__, "..", "..", "..", "shared", "julia", "RHCCase.jl"))
```

<div class="rhc-julia-object-map" data-julia-line="3" data-operation="setup"><div class="ov-expression" role="group" aria-label="代码第3行的输入对象"><strong>输入对象</strong> <span>无已有数据对象输入；载入程序定义。</span></div><div class="ov-expression" role="group" aria-label="代码第3行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-slate" data-object="rhc-module" data-direction="output" data-dim="container-or-no-value" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>读取与计算函数模块</strong><code>RHCCase</code><small>类型：Module</small><small>维度：模块，不是患者数据</small></span></div></div>

<p class="rhc-julia-no-formula">本行准备程序名称或定义，不计算统计量。</p>

<p class="rhc-julia-operation" data-julia-operation="3">include 读取并执行另一个 Julia 文件；joinpath 把路径片段拼起来，@__DIR__ 是当前脚本所在目录，三个 .. 依次返回上三级目录，找到共享 RHCCase.jl。此行载入函数定义，还没有对患者求均值。</p>

### 代码第5行

```julia
using .RHCCase
```

<div class="rhc-julia-object-map" data-julia-line="5" data-operation="setup"><div class="ov-expression" role="group" aria-label="代码第5行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-slate" data-object="rhc-module" data-direction="input" data-dim="container-or-no-value" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>读取与计算函数模块</strong><code>RHCCase</code><small>类型：Module</small><small>维度：模块，不是患者数据</small></span></div><div class="ov-expression" role="group" aria-label="代码第5行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-slate" data-object="rhc-exports" data-direction="output" data-dim="container-or-no-value" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>当前脚本可调用的函数名</strong><code>using .RHCCase</code><small>类型：导出名称绑定</small><small>维度：名称集合，不是数值向量</small></span> <span class="ov-object ov-slate" data-object="source-path" data-direction="output" data-dim="container-or-no-value" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>冻结原始 CSV 的位置</strong><code>DEFAULT_SOURCE</code><small>类型：String</small><small>维度：一个文件路径字符串</small></span></div></div>

<p class="rhc-julia-no-formula">本行准备程序名称或定义，不计算统计量。</p>

<p class="rhc-julia-operation" data-julia-operation="5">using 把已载入 RHCCase 模块公开的函数名和 DEFAULT_SOURCE 带到当前脚本；模块名前的点表示本地模块。DEFAULT_SOURCE 是原始 CSV 的文件路径，不是患者数据。</p>

### 代码第7行

```julia
rows = read_rhc_rows(DEFAULT_SOURCE)
```

<div class="rhc-julia-object-map" data-julia-line="7" data-operation="read"><div class="ov-expression" role="group" aria-label="代码第7行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-slate" data-object="source-path" data-direction="input" data-dim="container-or-no-value" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>冻结原始 CSV 的位置</strong><code>DEFAULT_SOURCE</code><small>类型：String</small><small>维度：一个文件路径字符串</small></span> <span class="ov-object ov-slate" data-object="rhc-exports" data-direction="input" data-dim="container-or-no-value" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>当前脚本可调用的函数名</strong><code>using .RHCCase</code><small>类型：导出名称绑定</small><small>维度：名称集合，不是数值向量</small></span></div><div class="ov-expression" role="group" aria-label="代码第7行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-slate" data-object="raw-records" data-direction="output" data-dim="n" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>原始患者记录</strong><code>rows</code><small>类型：Vector{Dict{String,String}}</small><small>维度：n 条字典记录，每条保留 63 个原字段</small></span></div></div>

$$
\mathrm{rows}=(r_1,\ldots,r_n)
$$

<p class="rhc-julia-operation" data-julia-operation="7">先调用 read_rhc_rows 读取原始 CSV，再用 = 把返回结果存为 rows；每项是一位患者的字段字典，原字段暂存为字符串。输入路径与输出记录是两个对象；读取器检查字段与患者编号，保留全部原始行。</p>

### 代码第9行

```julia
observations = rhc_observations(rows)
```

<div class="rhc-julia-object-map" data-julia-line="9" data-operation="encode"><div class="ov-expression" role="group" aria-label="代码第9行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-slate" data-object="raw-records" data-direction="input" data-dim="n" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>原始患者记录</strong><code>rows</code><small>类型：Vector{Dict{String,String}}</small><small>维度：n 条字典记录，每条保留 63 个原字段</small></span></div><div class="ov-expression" role="group" aria-label="代码第9行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-slate" data-object="observations" data-direction="output" data-dim="n" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>每位患者的三个二元标签</strong><code>observations</code><small>类型：Vector{NamedTuple{(:x,:a,:y),Tuple{Int,Int,Int}}}</small><small>维度：n 条 (x,a,y) 记录；顺序与原始行相同</small></span></div></div>

$$
O_i=(X_i,A_i,Y_i),\quad Y_i=\mathbf1\{\mathrm{dth30}_i=\mathrm{Yes}\}
$$

<p class="rhc-julia-operation" data-julia-operation="9">将 rows 交给 rhc_observations；按原顺序逐行把 sex、swang1、dth30 编成整数 x、a、y。每条结果是带字段名的 (x,a,y)，不是模型预测，也没有删除患者。</p>

### 代码第11行

```julia
n = length(observations)
```

<div class="rhc-julia-object-map" data-julia-line="11" data-operation="reduce"><div class="ov-expression" role="group" aria-label="代码第11行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-slate" data-object="observations" data-direction="input" data-dim="n" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>每位患者的三个二元标签</strong><code>observations</code><small>类型：Vector{NamedTuple{(:x,:a,:y),Tuple{Int,Int,Int}}}</small><small>维度：n 条 (x,a,y) 记录；顺序与原始行相同</small></span></div><div class="ov-expression" role="group" aria-label="代码第11行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-slate" data-object="sample-size" data-direction="output" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>患者总人数</strong><code>n</code><small>类型：Int</small><small>维度：标量，1 个整数</small></span></div></div>

$$
n=\operatorname{length}(O_1,\ldots,O_n)
$$

<p class="rhc-julia-operation" data-julia-operation="11">length 数容器里有多少条患者记录，把一个整数存入 n；容器有 n 条记录，n 本身只有一个数。</p>

### 代码第13行

```julia
y = [person.y for person in observations]
```

<div class="rhc-julia-object-map" data-julia-line="13" data-operation="extract"><div class="ov-expression" role="group" aria-label="代码第13行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-slate" data-object="observations" data-direction="input" data-dim="n" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>每位患者的三个二元标签</strong><code>observations</code><small>类型：Vector{NamedTuple{(:x,:a,:y),Tuple{Int,Int,Int}}}</small><small>维度：n 条 (x,a,y) 记录；顺序与原始行相同</small></span></div><div class="ov-expression" role="group" aria-label="代码第13行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-blue" data-object="outcomes" data-direction="output" data-dim="n" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>逐人的 30 日死亡指标</strong><code>y</code><small>类型：Vector{Int}</small><small>维度：n 维向量，每人一个 0/1</small></span></div></div>

$$
\mathbf Y=(Y_1,\ldots,Y_n)^\mathsf T
$$

<p class="rhc-julia-operation" data-julia-operation="13">方括号建立向量；for person in observations 依次取出一位患者，person.y 的点号从该记录取 y 字段。结果 y 保留每位患者的原顺序，长度是 n；Y=0/1 是结局标签，不是数组下标。</p>

### 代码第15行

```julia
events = sum(y)
```

<div class="rhc-julia-object-map" data-julia-line="15" data-operation="reduce"><div class="ov-expression" role="group" aria-label="代码第15行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-blue" data-object="outcomes" data-direction="input" data-dim="n" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>逐人的 30 日死亡指标</strong><code>y</code><small>类型：Vector{Int}</small><small>维度：n 维向量，每人一个 0/1</small></span></div><div class="ov-expression" role="group" aria-label="代码第15行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-blue" data-object="events" data-direction="output" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>30 日死亡人数</strong><code>events</code><small>类型：Int</small><small>维度：标量，1 个整数</small></span></div></div>

$$
M=\sum_{i=1}^nY_i
$$

<p class="rhc-julia-operation" data-julia-operation="15">sum 将 y 里的 n 个 0/1 相加：死亡者加 1，其他人加 0。输出 events 是死亡总人数这个整数标量，向量在这里收缩成一个数。</p>

### 代码第17行

```julia
risk = events / n
```

<div class="rhc-julia-object-map" data-julia-line="17" data-operation="divide"><div class="ov-expression" role="group" aria-label="代码第17行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-blue" data-object="events" data-direction="input" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>30 日死亡人数</strong><code>events</code><small>类型：Int</small><small>维度：标量，1 个整数</small></span> <span class="ov-object ov-slate" data-object="sample-size" data-direction="input" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>患者总人数</strong><code>n</code><small>类型：Int</small><small>维度：标量，1 个整数</small></span></div><div class="ov-expression" role="group" aria-label="代码第17行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-blue" data-object="risk" data-direction="output" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>全队列样本死亡比例</strong><code>risk</code><small>类型：Float64</small><small>维度：标量，1 个小数</small></span></div></div>

$$
\widehat\mu=\frac{M}{n}=\frac1n\sum_{i=1}^nY_i
$$

<p class="rhc-julia-operation" data-julia-operation="17">先用 / 将死亡人数 events 除以总人数 n，再把结果存为 risk；两个标量相除仍得到一个标量。risk 是全队列死亡比例，不是每位患者的模型预测，也不是处理效应。</p>

### 代码第19行

```julia
influence = y .- risk
```

<div class="rhc-julia-object-map" data-julia-line="19" data-operation="broadcast"><div class="ov-expression" role="group" aria-label="代码第19行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-blue" data-object="outcomes" data-direction="input" data-dim="n" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>逐人的 30 日死亡指标</strong><code>y</code><small>类型：Vector{Int}</small><small>维度：n 维向量，每人一个 0/1</small></span> <span class="ov-object ov-blue" data-object="risk" data-direction="input" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>全队列样本死亡比例</strong><code>risk</code><small>类型：Float64</small><small>维度：标量，1 个小数</small></span></div><div class="ov-expression" role="group" aria-label="代码第19行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-orange" data-object="influence" data-direction="output" data-dim="n" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>逐人的均值影响值</strong><code>influence</code><small>类型：Vector{Float64}</small><small>维度：n 维向量，允许负数</small></span></div></div>

$$
D_i=Y_i-\widehat\mu,\quad\mathbf D=\mathbf Y-\widehat\mu\mathbf1_n
$$

<p class="rhc-julia-operation" data-julia-operation="19">.- 中的点表示逐元素相减（broadcast）：给向量 y 的每一个元素都减去同一个标量 risk。输出 influence 仍有 n 项，Y=0 得到负的 risk，Y=1 得到 1-risk；这里没有求平均。</p>

### 代码第21行

```julia
mean_influence = sum(influence) / n
```

<div class="rhc-julia-object-map" data-julia-line="21" data-operation="reduce"><div class="ov-expression" role="group" aria-label="代码第21行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-orange" data-object="influence" data-direction="input" data-dim="n" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>逐人的均值影响值</strong><code>influence</code><small>类型：Vector{Float64}</small><small>维度：n 维向量，允许负数</small></span> <span class="ov-object ov-slate" data-object="sample-size" data-direction="input" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>患者总人数</strong><code>n</code><small>类型：Int</small><small>维度：标量，1 个整数</small></span></div><div class="ov-expression" role="group" aria-label="代码第21行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-orange" data-object="mean-influence" data-direction="output" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>逐人影响值的平均</strong><code>mean_influence</code><small>类型：Float64</small><small>维度：标量，1 个小数</small></span></div></div>

$$
\overline D=\frac1n\sum_{i=1}^nD_i=\frac1n\sum_{i=1}^n(Y_i-\widehat\mu)\approx0
$$

<p class="rhc-julia-operation" data-julia-operation="21">sum 先把 n 项 influence 相加，/ n 再除以总人数，得到一个标量 mean_influence。正负影响值在平均时抵消；实数恒等式为 0，浮点运算允许很小的误差；不是每个人的影响值都为 0。</p>

### 代码第23行

```julia
data = rhc_data(DEFAULT_SOURCE)
```

<div class="rhc-julia-object-map" data-julia-line="23" data-operation="aggregate"><div class="ov-expression" role="group" aria-label="代码第23行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-slate" data-object="source-path" data-direction="input" data-dim="container-or-no-value" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>冻结原始 CSV 的位置</strong><code>DEFAULT_SOURCE</code><small>类型：String</small><small>维度：一个文件路径字符串</small></span></div><div class="ov-expression" role="group" aria-label="代码第23行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-slate" data-object="coarse-data" data-direction="output" data-dim="container-or-no-value" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>同一批患者的分组计数容器</strong><code>data</code><small>类型：NamedTuple</small><small>维度：一个带字段的记录容器；data.cells 是 8 维向量</small></span></div></div>

$$
n_j=\#\{i:(X_i,A_i,Y_i)=(x_j,a_j,y_j)\},\quad\sum_{j=1}^8n_j=n
$$

<p class="rhc-julia-operation" data-julia-operation="23">rhc_data 重新读取同一原始 CSV，按 x、a、y 的 0/1 组合统计人数，再返回带字段的 data 容器。data.cells 的每个元素对应一种观测组合，其中 n 是该组合人数；data.n 为总人数5735。</p>

### 代码第25行

```julia
check = mean_if(data)
```

<div class="rhc-julia-object-map" data-julia-line="25" data-operation="validate"><div class="ov-expression" role="group" aria-label="代码第25行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-slate" data-object="coarse-data" data-direction="input" data-dim="container-or-no-value" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>同一批患者的分组计数容器</strong><code>data</code><small>类型：NamedTuple</small><small>维度：一个带字段的记录容器；data.cells 是 8 维向量</small></span></div><div class="ov-expression" role="group" aria-label="代码第25行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-slate" data-object="mean-check" data-direction="output" data-dim="container-or-no-value" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>按组计算均值的返回容器</strong><code>check</code><small>类型：NamedTuple{(:risk,:values,:mean)}</small><small>维度：一个容器，含 2 个标量和 1 个 8 维向量</small></span> <span class="ov-object ov-blue" data-object="check-risk" data-direction="output" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>按组人数加权死亡比例</strong><code>check.risk</code><small>类型：Float64</small><small>维度：标量，1 个小数</small></span> <span class="ov-object ov-orange" data-object="check-values" data-direction="output" data-dim="8" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>各观测组合的均值影响值</strong><code>check.values</code><small>类型：Vector{Float64}</small><small>维度：8 维向量，每格一项</small></span> <span class="ov-object ov-orange" data-object="check-mean" data-direction="output" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>按组人数加权的影响值平均</strong><code>check.mean</code><small>类型：Float64</small><small>维度：标量，1 个小数</small></span></div></div>

$$
\mathrm{check.risk}=\sum_{j=1}^8\frac{n_j}{n}y_j,\quad\mathrm{check.mean}=\sum_{j=1}^8\frac{n_j}{n}(y_j-\widehat\mu)
$$

<p class="rhc-julia-operation" data-julia-operation="25">mean_if(data) 现在实际调用共享函数，按格人数求死亡比例和影响值加权平均；把返回容器存为 check。check.risk 是死亡比例标量，check.values 是 8 项格影响值，check.mean 是按人数加权的影响值平均，三者不能互换。</p>

### 代码第27行

```julia
@assert isapprox(check.risk, risk) && abs(mean_influence) < 1e-12
```

<div class="rhc-julia-object-map" data-julia-line="27" data-operation="assert"><div class="ov-expression" role="group" aria-label="代码第27行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-blue" data-object="check-risk" data-direction="input" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>按组人数加权死亡比例</strong><code>check.risk</code><small>类型：Float64</small><small>维度：标量，1 个小数</small></span> <span class="ov-object ov-blue" data-object="risk" data-direction="input" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>全队列样本死亡比例</strong><code>risk</code><small>类型：Float64</small><small>维度：标量，1 个小数</small></span> <span class="ov-object ov-orange" data-object="mean-influence" data-direction="input" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>逐人影响值的平均</strong><code>mean_influence</code><small>类型：Float64</small><small>维度：标量，1 个小数</small></span></div><div class="ov-expression" role="group" aria-label="代码第27行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-slate" data-object="assertion-result" data-direction="output" data-dim="container-or-no-value" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>检查成功后继续执行</strong><code>@assert</code><small>类型：Nothing（条件失败则抛出 AssertionError）</small><small>维度：成功时无数值输出</small></span></div></div>

$$
\mathrm{check.risk}\approx\widehat\mu\quad\land\quad|\overline D|<10^{-12}
$$

<p class="rhc-julia-operation" data-julia-operation="27">@assert 要求两个条件同时成立；isapprox 检查按组人数加权的风险与逐人 risk 在默认数值容差内接近，&amp;&amp; 表示并且，abs 取绝对值，1e-12 是 10 的负 12 次方。成功继续，失败报错停止；此行没有重新拟合模型，也未直接检查 check.mean。</p>

### 代码第28行

```julia
println("原始患者数 n = ", n, "；30 日死亡人数 = ", events)
```

<div class="rhc-julia-object-map" data-julia-line="28" data-operation="print"><div class="ov-expression" role="group" aria-label="代码第28行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-slate" data-object="sample-size" data-direction="input" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>患者总人数</strong><code>n</code><small>类型：Int</small><small>维度：标量，1 个整数</small></span> <span class="ov-object ov-blue" data-object="events" data-direction="input" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>30 日死亡人数</strong><code>events</code><small>类型：Int</small><small>维度：标量，1 个整数</small></span></div><div class="ov-expression" role="group" aria-label="代码第28行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-slate" data-object="terminal-output" data-direction="output" data-dim="container-or-no-value" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>终端显示的文字和已有结果</strong><code>println(...)</code><small>类型：Nothing（副作用为写入终端）</small><small>维度：显示文本，不是新的统计量</small></span></div></div>

$$
n,\quad M
$$

<p class="rhc-julia-operation" data-julia-operation="28">println 依次显示引号中的中文标签、已有的 n 与 events，然后换行；逗号只分隔显示片段，不做求和。两项显示的是患者总人数与死亡人数，没有产生新估计量。</p>

### 代码第29行

```julia
println("样本死亡风险 μ̂ = ", risk)
```

<div class="rhc-julia-object-map" data-julia-line="29" data-operation="print"><div class="ov-expression" role="group" aria-label="代码第29行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-blue" data-object="risk" data-direction="input" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>全队列样本死亡比例</strong><code>risk</code><small>类型：Float64</small><small>维度：标量，1 个小数</small></span></div><div class="ov-expression" role="group" aria-label="代码第29行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-slate" data-object="terminal-output" data-direction="output" data-dim="container-or-no-value" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>终端显示的文字和已有结果</strong><code>println(...)</code><small>类型：Nothing（副作用为写入终端）</small><small>维度：显示文本，不是新的统计量</small></span></div></div>

$$
\widehat\mu
$$

<p class="rhc-julia-operation" data-julia-operation="29">println 在“样本死亡风险 μ̂”标签后显示已有的 risk，然后换行；读取标量，不再计算均值，也没有逐人预测。</p>

### 代码第30行

```julia
println("Y=0 的 IF = ", -risk, "；Y=1 的 IF = ", 1-risk)
```

<div class="rhc-julia-object-map" data-julia-line="30" data-operation="print"><div class="ov-expression" role="group" aria-label="代码第30行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-blue" data-object="risk" data-direction="input" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>全队列样本死亡比例</strong><code>risk</code><small>类型：Float64</small><small>维度：标量，1 个小数</small></span></div><div class="ov-expression" role="group" aria-label="代码第30行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-slate" data-object="terminal-output" data-direction="output" data-dim="container-or-no-value" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>终端显示的文字和已有结果</strong><code>println(...)</code><small>类型：Nothing（副作用为写入终端）</small><small>维度：显示文本，不是新的统计量</small></span></div></div>

$$
D(0)=-\widehat\mu,\quad D(1)=1-\widehat\mu
$$

<p class="rhc-julia-operation" data-julia-operation="30">println 显示两种可能结局标签的影响值：-risk 是 0-risk，1-risk 是 1 减同一中心。这里列出 Y=0 与 Y=1 的函数值，不是遍历患者、重算 n 项向量或预测死亡概率。</p>

### 代码第31行

```julia
println("逐人 IF 平均 = ", mean_influence, "；按组人数加权 IF 平均 = ", check.mean)
```

<div class="rhc-julia-object-map" data-julia-line="31" data-operation="print"><div class="ov-expression" role="group" aria-label="代码第31行的输入对象"><strong>输入对象</strong> <span class="ov-object ov-orange" data-object="mean-influence" data-direction="input" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>逐人影响值的平均</strong><code>mean_influence</code><small>类型：Float64</small><small>维度：标量，1 个小数</small></span> <span class="ov-object ov-orange" data-object="check-mean" data-direction="input" data-dim="1" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>按组人数加权的影响值平均</strong><code>check.mean</code><small>类型：Float64</small><small>维度：标量，1 个小数</small></span></div><div class="ov-expression" role="group" aria-label="代码第31行的输出对象"><strong>输出对象</strong> <span class="ov-object ov-slate" data-object="terminal-output" data-direction="output" data-dim="container-or-no-value" style="display:inline-flex;flex-direction:column;gap:4px;padding:8px;max-width:100%;overflow-wrap:anywhere;vertical-align:top"><strong>终端显示的文字和已有结果</strong><code>println(...)</code><small>类型：Nothing（副作用为写入终端）</small><small>维度：显示文本，不是新的统计量</small></span></div></div>

$$
\overline D,\quad\sum_{j=1}^8(n_j/n)D_j
$$

<p class="rhc-julia-operation" data-julia-operation="31">println 在两个不同标签后分别显示逐人影响值平均 mean_influence 与按组人数加权平均 check.mean。check.mean 的点号是读取字段；逗号只分隔文字和数值，这行没有再平均，也没有断言两者精确相等。</p>


</details>

<details><summary>用Julia复算本章图中的运算</summary>

[对象运算工作簿](julia/object_ch01.jl)承接上面原始读取步骤，并逐行说明概率向量、广播、替换路径、变化率和中心化。输入仍是同一RHC原CSV；输出包括向量与标量的核对结果。它保留原始患者行序，以`support_y`区分结局0、1这两行，以`y`表示逐人结局。这样能分清“对两类结局加权”与“对5735位患者求平均”的对应关系。

```sh
julia --startup-file=no --history-file=no zh/julia/object_ch01.jl
```

</details>



</div>

<div class="lesson-code-panel" data-lesson-panel="r" hidden>

R在控制台运行一行，也可以用Rscript顺序运行完整文件。直接复制到R控制台时，先把工作目录设为项目根目录；source()完整脚本或Rscript运行脚本时会自行定位项目。先读右侧表达式，再看左侧名字：`risk <- events / n`先算除法，再把结果保存为risk。名字指向对象；同一个名字可以接收新计算结果。

| 写法 | 本课用途 | 输出形状 |
| --- | --- | --- |
| `c(0, 1)` | 合并两个数 | 长度2向量 |
| `observations$y` | 按列名读取数据框 | 长度n向量 |
| `length(y)` / `nrow(rows)` | 数向量元素 / 数据行 | 一个整数 |
| `x[1]` / `q[1, 2]` | 按位置取向量元素 / 矩阵元素；从1开始 | 一个数 |
| `*`、`/`、`+`、`-` | 同行逐元素运算，标量可作用于整列 | 通常保留向量长度 |
| `%*%` | 矩阵乘法 | 维度由行列乘积决定 |
| `sum(x)` / `mean(x)` | 对完整向量求和 / 平均 | 一个数 |
| `==` / `<-` | 比较取逻辑值 / 赋值保存结果 | 逻辑对象 / 保存的对象 |
| `function(v)` / `vapply(...)` | 定义一次输入输出的规则 / 对每项应用规则 | 由函数和声明类型决定 |
| `stopifnot(...)` | 要求检查条件均成立 | 通过继续，失败停止 |

R的数值向量长度为n时，`dim(y)`通常为NULL；n×1是教学竖排形状。数据框（data.frame）按列保存不同变量，矩阵（matrix）保存同类型数值，列表（list）可同时保存设计矩阵、预测向量和标量。每条计算始终使用完整队列；两项结局支持与n位患者分别对齐。

输入是[同一公开RHC原CSV](../shared/data/public/rhc/source.csv)。共享定义：[RHCCase.R](../shared/R/RHCCase.R)与[EIFCase.R](../shared/R/EIFCase.R)。[完整R脚本](R/ch01.R)使用base R，保留项目目录结构即可从任意工作目录运行。

```sh
Rscript --vanilla zh/R/ch01.R
```

```r
# 第1讲：均值、路径与影响值的连续R入门工作簿
# 输入：冻结的公开RHC原CSV；输出：本讲对象与终端核对值；仅使用base R。
# commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
# sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
# if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch01.R")
# length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。
stopifnot(length(script_path) == 1L, !is.na(script_path))
# dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
# source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。
source(file.path(project_root, "shared", "R", "RHCCase.R"))
# read_rhc_rows读取官方原CSV；DEFAULT_SOURCE由共享文件定位。rows为5735×63 data.frame；每行仍是同一患者。
rows <- read_rhc_rows(DEFAULT_SOURCE)
# 将原字段sex、swang1、dth30编码为x、a、y三列0/1；输出n×3 data.frame，保留原始行序。
observations <- rhc_observations(rows)
# $按名称取出y列。y是长度n的数值向量，1表示30日死亡，0表示未死亡；长度为n，dim为NULL。
y <- observations$y
# length数向量元素，返回一个整数人数n=5735。nrow数data.frame的患者行，length数其变量列。
n <- length(y)
# sum将n项0/1相加，返回死亡人数标量1918；<-把右侧结果赋给左侧名字。
events <- sum(y)
# /是除法；两个标量相除得到样本30日死亡风险，单位为概率。
risk <- events / n
# c把0、1合成长度2数值向量。此处两项表示可能结局类别，分别对应结局0与1。
support_y <- c(0, 1)
# function(v)是接收一个结局的规则；==逐人判断，mean将TRUE当1、FALSE当0平均。vapply对两个类别分别调用并要求每次输出一个数，p长度2。
p <- vapply(support_y, function(v) mean(y == v), numeric(1))
# *按同一结局逐项相乘，sum把两项收缩为均值标量；这里冻结参考为经验结局分布。
mu <- sum(p * support_y)
# 选择接收新增权重的结局1；z是一个数值标量，仅允许0或1。
z <- 1
# 设置无量纲替换比例0.1；t取0至1，数学上改变概率权重，不修改原患者y。
t <- 0.1
# %in%检查属于允许类别；is.finite排除NA、无穷大，stopifnot检查合法路径步长。
stopifnot(z %in% support_y, is.finite(t), t >= 0, t <= 1)
# ==对两类逐项判断，as.numeric把FALSE/TRUE变成0/1；输出长度2点质量概率向量。
point <- as.numeric(support_y == z)
# 括号先运算；标量乘向量是逐元素缩放，两组分相加得到长度2新概率。
p_t <- (1 - t) * p + t * point
# 结局支持不变，只换新概率；逐项乘再求和得到新均值标量。
mu_t <- sum(p_t * support_y)
# 两个均值标量相减，delta单位为概率差。
delta <- mu_t - mu
# 选择的结局减冻结原均值，得到均值路径导数；目标为本讲的均值。
derivative <- z - mu
# if只选择一个分支；t为0时不做0/0，返回数值缺失NA_real_。非零t时返回一个变化率。
rate <- if (t == 0) NA_real_ else delta / t
# 乘法先于加法，计算一个新均值；对均值目标这是精确线性恒等式。
linear_mean <- mu + t * derivative
# R将一个标量从两项分别减去，输出长度2函数值表；固定P下D(y)=y−mu。
support_D <- support_y - mu
# 同一规则应用到全部n位患者，返回长度n数值向量；长度为n，dim为NULL。
influence <- y - risk
# 先sum全部n项再除n，得到一个平均；浮点下允许极小误差。
mean_influence <- sum(influence) / n
# 按原概率对两项函数表加权求和，得到与逐人平均相同的标量。
grouped_mean_D <- sum(p * support_D)
# 固定旧D，仅换新分布权重；这次平均通常非零。
old_mean_D <- sum(p_t * support_D)
# 以新均值为中心建立另一条函数的长度2值表。
new_support_D <- support_y - mu_t
# 新函数在新分布下的加权平均重新为零；与上一行使用旧函数的量不同。
new_mean_D <- sum(p_t * new_support_D)
# 逐人取0/1补集，返回长度n存活指标向量，行序不变。
alive <- 1 - y
# 存活指标先相加再除全部人数，得到一个30日存活风险标量。
survival <- sum(alive) / n
# 每位患者存活指标减存活均值，得到n项；等于死亡均值影响值的反号。
survival_influence <- alive - survival
# 同一原始CSV按(x,a,y)组合及(a,x)分组分别汇总，返回list；对应冻结的经验参考分布。
data <- rhc_data(DEFAULT_SOURCE)
# mean_if用各观测组合的概率计算均值及加权IF平均，输出list供独立核对。
check <- mean_if(data)
# 核对官方人数和事件数，以及两类加权均值的独立分数基准。
stopifnot(n == 5735L, events == 1918, abs(mu - 1918 / 5735) < 1e-14)
# 检查n项患者影响值、2项类别概率和合法概率和；患者与结局支持两种对齐不可混淆。
stopifnot(length(influence) == n, length(p_t) == 2L, abs(sum(p_t) - 1) < 1e-14, all(p_t >= 0))
# ||是短路或：t=0产生NA的分支无需检查未定义变化率；其余情况核对精确线性和变化率。
stopifnot(abs(mu_t - linear_mean) < 1e-14, is.na(rate) || abs(rate - derivative) < 1e-12)
# 要求三种正确中心化平均在数值容差内为零；患者间贡献可以互相抵消。
stopifnot(abs(mean_influence) < 1e-12, abs(grouped_mean_D) < 1e-12, abs(new_mean_D) < 1e-12)
# 核对旧函数新权重的平均等于均值变化、存活IF逐项反号，以及按组和逐人风险一致。
stopifnot(abs(old_mean_D - delta) < 1e-14, all(abs(survival_influence + influence) < 1e-14), abs(check$risk - risk) < 1e-14)
# cat按次序显示对象，分号文字只是分隔符；\n是换行，不计算新的统计量。
cat("n =", n, "; events =", events, "; risk =", risk, "; mu_t =", mu_t, "\n")
# 分开显示逐人平均、旧函数新权重平均与新函数新权重平均，避免把三个量混为同一对象。
cat("mean_influence =", mean_influence, "; old_mean_D =", old_mean_D, "; new_mean_D =", new_mean_D, "\n")
# 本讲描述同一公开队列的均值，不估计RHC处理效果；未知真实P0与经验Pn不同。
```

<details><summary>逐行解释：输入、输出、维度与数学式</summary>

<div class="r-line-card" data-r-line="4">

#### R第4行

```r
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
```

<p>输入：本行定义的常量或程序环境。输出：<code>script_argument</code> · character vector · 路径或参数字符串。</p>

commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。

</div>

<div class="r-line-card" data-r-line="6">

#### R第6行

```r
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
```

<p>输入：本行定义的常量或程序环境。输出：<code>source_files</code> · character vector · 路径或参数字符串。</p>

sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。

</div>

<div class="r-line-card" data-r-line="8">

#### R第8行

```r
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch01.R")
```

<p>输入：<code>source_files</code> · character vector · 路径或参数字符串；<code>script_argument</code> · character vector · 路径或参数字符串。输出：<code>script_path</code> · character vector · 路径或参数字符串。</p>

if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。

</div>

<div class="r-line-card" data-r-line="10">

#### R第10行

```r
stopifnot(length(script_path) == 1L, !is.na(script_path))
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。

</div>

<div class="r-line-card" data-r-line="12">

#### R第12行

```r
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：<code>project_root</code> · character vector · 路径或参数字符串。</p>

dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。

</div>

<div class="r-line-card" data-r-line="14">

#### R第14行

```r
source(file.path(project_root, "shared", "R", "RHCCase.R"))
```

<p>输入：<code>project_root</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。

</div>

<div class="r-line-card" data-r-line="16">

#### R第16行

```r
rows <- read_rhc_rows(DEFAULT_SOURCE)
```

<p>输入：本行定义的常量或程序环境。输出：<code>rows</code> · data.frame · 5735行×63列。</p>

read_rhc_rows读取官方原CSV；DEFAULT_SOURCE由共享文件定位。rows为5735×63 data.frame；每行仍是同一患者。

</div>

<div class="r-line-card" data-r-line="18">

#### R第18行

```r
observations <- rhc_observations(rows)
```

<p>输入：<code>rows</code> · data.frame · 5735行×63列。输出：<code>observations</code> · data.frame · 5735行×3列（x,a,y）。</p>

将原字段sex、swang1、dth30编码为x、a、y三列0/1；输出n×3 data.frame，保留原始行序。

</div>

<div class="r-line-card" data-r-line="20">

#### R第20行

```r
y <- observations$y
```

<p>输入：<code>observations</code> · data.frame · 5735行×3列（x,a,y）。输出：<code>y</code> · numeric vector · 长度n；dim为NULL。</p>

$按名称取出y列。y是长度n的数值向量，1表示30日死亡，0表示未死亡；长度为n，dim为NULL。

$$
\mathbf y=(Y_1,\ldots,Y_n)
$$


</div>

<div class="r-line-card" data-r-line="22">

#### R第22行

```r
n <- length(y)
```

<p>输入：<code>y</code> · numeric vector · 长度n；dim为NULL。输出：<code>n</code> · integer scalar · 长度1。</p>

length数向量元素，返回一个整数人数n=5735。nrow数data.frame的患者行，length数其变量列。

$$
n=5735
$$


</div>

<div class="r-line-card" data-r-line="24">

#### R第24行

```r
events <- sum(y)
```

<p>输入：<code>y</code> · numeric vector · 长度n；dim为NULL。输出：<code>events</code> · numeric scalar (double) · 长度1。</p>

sum将n项0/1相加，返回死亡人数标量1918；&lt;-把右侧结果赋给左侧名字。

$$
N_Y=\sum_iY_i
$$


</div>

<div class="r-line-card" data-r-line="26">

#### R第26行

```r
risk <- events / n
```

<p>输入：<code>events</code> · numeric scalar (double) · 长度1；<code>n</code> · integer scalar · 长度1。输出：<code>risk</code> · numeric scalar (double) · 长度1。</p>

/是除法；两个标量相除得到样本30日死亡风险，单位为概率。

$$
\widehat\mu=\frac{\sum_iY_i}{n}
$$


</div>

<div class="r-line-card" data-r-line="28">

#### R第28行

```r
support_y <- c(0, 1)
```

<p>输入：本行定义的常量或程序环境。输出：<code>support_y</code> · numeric vector · 长度2；按结局0、1对齐。</p>

c把0、1合成长度2数值向量。此处两项表示可能结局类别，分别对应结局0与1。

$$
\mathcal Y=\{0,1\}
$$


</div>

<div class="r-line-card" data-r-line="30">

#### R第30行

```r
p <- vapply(support_y, function(v) mean(y == v), numeric(1))
```

<p>输入：<code>support_y</code> · numeric vector · 长度2；按结局0、1对齐；<code>y</code> · numeric vector · 长度n；dim为NULL。输出：<code>p</code> · numeric vector · 长度2；按结局0、1对齐。</p>

function(v)是接收一个结局的规则；==逐人判断，mean将TRUE当1、FALSE当0平均。vapply对两个类别分别调用并要求每次输出一个数，p长度2。

$$
p_y=n^{-1}\sum_i\mathbf1(Y_i=y)
$$


</div>

<div class="r-line-card" data-r-line="32">

#### R第32行

```r
mu <- sum(p * support_y)
```

<p>输入：<code>p</code> · numeric vector · 长度2；按结局0、1对齐；<code>support_y</code> · numeric vector · 长度2；按结局0、1对齐。输出：<code>mu</code> · numeric scalar (double) · 长度1。</p>

*按同一结局逐项相乘，sum把两项收缩为均值标量；这里冻结参考为经验结局分布。

$$
\mu=\sum_{y=0}^1p_yy=1918/5735
$$


</div>

<div class="r-line-card" data-r-line="34">

#### R第34行

```r
z <- 1
```

<p>输入：本行定义的常量或程序环境。输出：<code>z</code> · numeric scalar (double) · 长度1。</p>

选择接收新增权重的结局1；z是一个数值标量，仅允许0或1。

$$
z\in\{0,1\}
$$


</div>

<div class="r-line-card" data-r-line="36">

#### R第36行

```r
t <- 0.1
```

<p>输入：本行定义的常量或程序环境。输出：<code>t</code> · numeric scalar (double) · 长度1。</p>

设置无量纲替换比例0.1；t取0至1，数学上改变概率权重，不修改原患者y。

$$
0\leq t\leq1
$$


</div>

<div class="r-line-card" data-r-line="38">

#### R第38行

```r
stopifnot(z %in% support_y, is.finite(t), t >= 0, t <= 1)
```

<p>输入：<code>z</code> · numeric scalar (double) · 长度1；<code>support_y</code> · numeric vector · 长度2；按结局0、1对齐；<code>t</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

%in%检查属于允许类别；is.finite排除NA、无穷大，stopifnot检查合法路径步长。

</div>

<div class="r-line-card" data-r-line="40">

#### R第40行

```r
point <- as.numeric(support_y == z)
```

<p>输入：<code>support_y</code> · numeric vector · 长度2；按结局0、1对齐；<code>z</code> · numeric scalar (double) · 长度1。输出：<code>point</code> · numeric vector · 长度2；按结局0、1对齐。</p>

==对两类逐项判断，as.numeric把FALSE/TRUE变成0/1；输出长度2点质量概率向量。

$$
\delta_z(y)=\mathbf1(y=z)
$$


</div>

<div class="r-line-card" data-r-line="42">

#### R第42行

```r
p_t <- (1 - t) * p + t * point
```

<p>输入：<code>t</code> · numeric scalar (double) · 长度1；<code>p</code> · numeric vector · 长度2；按结局0、1对齐；<code>point</code> · numeric vector · 长度2；按结局0、1对齐。输出：<code>p_t</code> · numeric vector · 长度2；按结局0、1对齐。</p>

括号先运算；标量乘向量是逐元素缩放，两组分相加得到长度2新概率。

$$
p_{t,y}=(1-t)p_y+t\mathbf1(y=z)
$$


</div>

<div class="r-line-card" data-r-line="44">

#### R第44行

```r
mu_t <- sum(p_t * support_y)
```

<p>输入：<code>p_t</code> · numeric vector · 长度2；按结局0、1对齐；<code>support_y</code> · numeric vector · 长度2；按结局0、1对齐。输出：<code>mu_t</code> · numeric scalar (double) · 长度1。</p>

结局支持不变，只换新概率；逐项乘再求和得到新均值标量。

$$
\mu_t=\sum_yp_{t,y}y
$$


</div>

<div class="r-line-card" data-r-line="46">

#### R第46行

```r
delta <- mu_t - mu
```

<p>输入：<code>mu_t</code> · numeric scalar (double) · 长度1；<code>mu</code> · numeric scalar (double) · 长度1。输出：<code>delta</code> · numeric scalar (double) · 长度1。</p>

两个均值标量相减，delta单位为概率差。

$$
\Delta\mu=\mu_t-\mu
$$


</div>

<div class="r-line-card" data-r-line="48">

#### R第48行

```r
derivative <- z - mu
```

<p>输入：<code>z</code> · numeric scalar (double) · 长度1；<code>mu</code> · numeric scalar (double) · 长度1。输出：<code>derivative</code> · numeric scalar (double) · 长度1。</p>

选择的结局减冻结原均值，得到均值路径导数；目标为本讲的均值。

$$
\dot\mu=z-\mu
$$


</div>

<div class="r-line-card" data-r-line="50">

#### R第50行

```r
rate <- if (t == 0) NA_real_ else delta / t
```

<p>输入：<code>t</code> · numeric scalar (double) · 长度1；<code>delta</code> · numeric scalar (double) · 长度1。输出：<code>rate</code> · numeric scalar (double) · 长度1。</p>

if只选择一个分支；t为0时不做0/0，返回数值缺失NA_real_。非零t时返回一个变化率。

$$
(\mu_t-\mu)/t=z-\mu\quad(t\ne0)
$$


</div>

<div class="r-line-card" data-r-line="52">

#### R第52行

```r
linear_mean <- mu + t * derivative
```

<p>输入：<code>mu</code> · numeric scalar (double) · 长度1；<code>t</code> · numeric scalar (double) · 长度1；<code>derivative</code> · numeric scalar (double) · 长度1。输出：<code>linear_mean</code> · numeric scalar (double) · 长度1。</p>

乘法先于加法，计算一个新均值；对均值目标这是精确线性恒等式。

$$
\mu_t=\mu+t(z-\mu)
$$


</div>

<div class="r-line-card" data-r-line="54">

#### R第54行

```r
support_D <- support_y - mu
```

<p>输入：<code>support_y</code> · numeric vector · 长度2；按结局0、1对齐；<code>mu</code> · numeric scalar (double) · 长度1。输出：<code>support_D</code> · numeric vector · 长度2；按结局0、1对齐。</p>

R将一个标量从两项分别减去，输出长度2函数值表；固定P下D(y)=y−mu。

$$
D_P^{\rm mean}(y)=y-\mu
$$


</div>

<div class="r-line-card" data-r-line="56">

#### R第56行

```r
influence <- y - risk
```

<p>输入：<code>y</code> · numeric vector · 长度n；dim为NULL；<code>risk</code> · numeric scalar (double) · 长度1。输出：<code>influence</code> · numeric vector · 长度n；dim为NULL。</p>

同一规则应用到全部n位患者，返回长度n数值向量；长度为n，dim为NULL。

$$
D_i=Y_i-\widehat\mu
$$


</div>

<div class="r-line-card" data-r-line="58">

#### R第58行

```r
mean_influence <- sum(influence) / n
```

<p>输入：<code>influence</code> · numeric vector · 长度n；dim为NULL；<code>n</code> · integer scalar · 长度1。输出：<code>mean_influence</code> · numeric scalar (double) · 长度1。</p>

先sum全部n项再除n，得到一个平均；浮点下允许极小误差。

$$
n^{-1}\sum_i(Y_i-\widehat\mu)=0
$$


</div>

<div class="r-line-card" data-r-line="60">

#### R第60行

```r
grouped_mean_D <- sum(p * support_D)
```

<p>输入：<code>p</code> · numeric vector · 长度2；按结局0、1对齐；<code>support_D</code> · numeric vector · 长度2；按结局0、1对齐。输出：<code>grouped_mean_D</code> · numeric scalar (double) · 长度1。</p>

按原概率对两项函数表加权求和，得到与逐人平均相同的标量。

$$
\sum_yp_yD_P^{\rm mean}(y)=0
$$


</div>

<div class="r-line-card" data-r-line="62">

#### R第62行

```r
old_mean_D <- sum(p_t * support_D)
```

<p>输入：<code>p_t</code> · numeric vector · 长度2；按结局0、1对齐；<code>support_D</code> · numeric vector · 长度2；按结局0、1对齐。输出：<code>old_mean_D</code> · numeric scalar (double) · 长度1。</p>

固定旧D，仅换新分布权重；这次平均通常非零。

$$
\sum_yp_{t,y}D_P^{\rm mean}(y)=\mu_t-\mu
$$


</div>

<div class="r-line-card" data-r-line="64">

#### R第64行

```r
new_support_D <- support_y - mu_t
```

<p>输入：<code>support_y</code> · numeric vector · 长度2；按结局0、1对齐；<code>mu_t</code> · numeric scalar (double) · 长度1。输出：<code>new_support_D</code> · numeric vector · 长度2；按结局0、1对齐。</p>

以新均值为中心建立另一条函数的长度2值表。

$$
D_{P_t}^{\rm mean}(y)=y-\mu_t
$$


</div>

<div class="r-line-card" data-r-line="66">

#### R第66行

```r
new_mean_D <- sum(p_t * new_support_D)
```

<p>输入：<code>p_t</code> · numeric vector · 长度2；按结局0、1对齐；<code>new_support_D</code> · numeric vector · 长度2；按结局0、1对齐。输出：<code>new_mean_D</code> · numeric scalar (double) · 长度1。</p>

新函数在新分布下的加权平均重新为零；与上一行使用旧函数的量不同。

$$
\sum_yp_{t,y}D_{P_t}^{\rm mean}(y)=0
$$


</div>

<div class="r-line-card" data-r-line="68">

#### R第68行

```r
alive <- 1 - y
```

<p>输入：<code>y</code> · numeric vector · 长度n；dim为NULL。输出：<code>alive</code> · numeric vector · 长度n；dim为NULL。</p>

逐人取0/1补集，返回长度n存活指标向量，行序不变。

$$
L_i=1-Y_i
$$


</div>

<div class="r-line-card" data-r-line="70">

#### R第70行

```r
survival <- sum(alive) / n
```

<p>输入：<code>alive</code> · numeric vector · 长度n；dim为NULL；<code>n</code> · integer scalar · 长度1。输出：<code>survival</code> · numeric scalar (double) · 长度1。</p>

存活指标先相加再除全部人数，得到一个30日存活风险标量。

$$
\widehat S(30)=1-\widehat\mu
$$


</div>

<div class="r-line-card" data-r-line="72">

#### R第72行

```r
survival_influence <- alive - survival
```

<p>输入：<code>alive</code> · numeric vector · 长度n；dim为NULL；<code>survival</code> · numeric scalar (double) · 长度1。输出：<code>survival_influence</code> · numeric vector · 长度n；dim为NULL。</p>

每位患者存活指标减存活均值，得到n项；等于死亡均值影响值的反号。

$$
D_i^{\rm survival}=-D_i^{\rm mean}
$$


</div>

<div class="r-line-card" data-r-line="74">

#### R第74行

```r
data <- rhc_data(DEFAULT_SOURCE)
```

<p>输入：本行定义的常量或程序环境。输出：<code>data</code> · list · 命名容器；各成员按自身维度。</p>

同一原始CSV按(x,a,y)组合及(a,x)分组分别汇总，返回list；对应冻结的经验参考分布。

</div>

<div class="r-line-card" data-r-line="76">

#### R第76行

```r
check <- mean_if(data)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度。输出：<code>check</code> · list · 命名容器；各成员按自身维度。</p>

mean_if用各观测组合的概率计算均值及加权IF平均，输出list供独立核对。

</div>

<div class="r-line-card" data-r-line="78">

#### R第78行

```r
stopifnot(n == 5735L, events == 1918, abs(mu - 1918 / 5735) < 1e-14)
```

<p>输入：<code>n</code> · integer scalar · 长度1；<code>events</code> · numeric scalar (double) · 长度1；<code>mu</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

核对官方人数和事件数，以及两类加权均值的独立分数基准。

</div>

<div class="r-line-card" data-r-line="80">

#### R第80行

```r
stopifnot(length(influence) == n, length(p_t) == 2L, abs(sum(p_t) - 1) < 1e-14, all(p_t >= 0))
```

<p>输入：<code>influence</code> · numeric vector · 长度n；dim为NULL；<code>n</code> · integer scalar · 长度1；<code>p_t</code> · numeric vector · 长度2；按结局0、1对齐。输出：执行检查、显示或控制流程。</p>

检查n项患者影响值、2项类别概率和合法概率和；患者与结局支持两种对齐不可混淆。

</div>

<div class="r-line-card" data-r-line="82">

#### R第82行

```r
stopifnot(abs(mu_t - linear_mean) < 1e-14, is.na(rate) || abs(rate - derivative) < 1e-12)
```

<p>输入：<code>mu_t</code> · numeric scalar (double) · 长度1；<code>linear_mean</code> · numeric scalar (double) · 长度1；<code>rate</code> · numeric scalar (double) · 长度1；<code>derivative</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

||是短路或：t=0产生NA的分支无需检查未定义变化率；其余情况核对精确线性和变化率。

</div>

<div class="r-line-card" data-r-line="84">

#### R第84行

```r
stopifnot(abs(mean_influence) < 1e-12, abs(grouped_mean_D) < 1e-12, abs(new_mean_D) < 1e-12)
```

<p>输入：<code>mean_influence</code> · numeric scalar (double) · 长度1；<code>grouped_mean_D</code> · numeric scalar (double) · 长度1；<code>new_mean_D</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

要求三种正确中心化平均在数值容差内为零；患者间贡献可以互相抵消。

</div>

<div class="r-line-card" data-r-line="86">

#### R第86行

```r
stopifnot(abs(old_mean_D - delta) < 1e-14, all(abs(survival_influence + influence) < 1e-14), abs(check$risk - risk) < 1e-14)
```

<p>输入：<code>old_mean_D</code> · numeric scalar (double) · 长度1；<code>delta</code> · numeric scalar (double) · 长度1；<code>survival_influence</code> · numeric vector · 长度n；dim为NULL；<code>influence</code> · numeric vector · 长度n；dim为NULL；<code>check</code> · list · 命名容器；各成员按自身维度；<code>risk</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

核对旧函数新权重的平均等于均值变化、存活IF逐项反号，以及按组和逐人风险一致。

</div>

<div class="r-line-card" data-r-line="88">

#### R第88行

```r
cat("n =", n, "; events =", events, "; risk =", risk, "; mu_t =", mu_t, "\n")
```

<p>输入：<code>n</code> · integer scalar · 长度1；<code>events</code> · numeric scalar (double) · 长度1；<code>risk</code> · numeric scalar (double) · 长度1；<code>mu_t</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

cat按次序显示对象，分号文字只是分隔符；\n是换行，不计算新的统计量。

</div>

<div class="r-line-card" data-r-line="90">

#### R第90行

```r
cat("mean_influence =", mean_influence, "; old_mean_D =", old_mean_D, "; new_mean_D =", new_mean_D, "\n")
```

<p>输入：<code>mean_influence</code> · numeric scalar (double) · 长度1；<code>old_mean_D</code> · numeric scalar (double) · 长度1；<code>new_mean_D</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

分开显示逐人平均、旧函数新权重平均与新函数新权重平均，避免把三个量混为同一对象。

</div>

</details>

</div>

<div class="case-workbench" data-case-study="1"></div>

## 接下来解释概率变化的方向与score

第0章用过的$y-\mu$，现在有了来历：把一小部分分布权重放到结局y，均值每单位替换比例的变化就是$y-\mu$。对固定P，两种结局对应的影响值按P的概率平均为0；换一个分布作平均，则要重新核对函数使用的中心。均值的线性使这些变化可以精确计算。

下一讲回到同一条替换路径，把概率变化再拆开看：某一类概率改变了多少，相对于它原来的概率又改变了多少？我们将像刚才对logit路径那样，求出这条路径的score，再与均值IF配对，逐步走向更一般的分布方向。


---

# 第 2 章：用score表示概率变化，算出目标的方向导数

第一讲固定同一真实队列的经验参考分布：死亡概率$r=1918/5735$，存活概率$c=3817/5735$。本讲继续研究死亡均值。问题是：**改变每一类概率的速率，怎样与$D(y)=y-r$配对，得到目标变化率？**

## 1. 区分步长与概率变化的方向

仍朝$z=1$替换。先逐行计算新减旧：

$$
\begin{aligned}
p_0(t)-p_0&=(1-t)c-c=c-tc-c=-tc,\\
p_1(t)-p_1&=(1-t)r+t-r=r-tr+t-r=t(1-r)=tc.
\end{aligned}
$$

> **符号回看：** $p=(c,r)$为固定原概率，$p(t)$为新概率；$t$是无量纲路径参数。每行变化除以非零t得到方向$h=(-c,c)$。t决定走多远，h决定每单位t如何分配变化。

概率和约束要求$\sum_jh_j=-c+c=0$；增加一格的概率时，需要从其他格移出相同总量。向量（vector）此处只是按行排列的一列数。

## 2. score记录相对于原概率的变化率

同样的绝对变化，对常见与罕见类别的相对幅度不同。定义路径得分（score）：

$$
S_j=\frac{h_j}{p_j},\qquad S=(-c/c,c/r)=(-1,c/r).
$$

> **符号回看：** $h_j$是第j行概率的绝对变化率，$p_j$是原概率，$S_j$是相对变化率。score描述路径的相对变化，倾向得分g描述给定基线下接受RHC的概率。

对数（natural logarithm）把相对比例变成相减：$\log[p_j(t)/p_j]=\log p_j(t)-\log p_j$。log在正数p处的变化率是1/p。复合变化先计算p随t的变化，再乘log随p的变化，这叫链式法则（chain rule），因此：

$$
\left.\frac d{dt}\log p_j(t)\right|_0
=\frac1{p_j}\left.\frac d{dt}p_j(t)\right|_0
=\frac{h_j}{p_j}=S_j.
$$

> **符号回看：** 导数在原分布$t=0$计算，因此分母取原概率$p_j$。$h_j/p_j$给出起点的相对变化率；对数差商在$t\to0$时趋于这个值。

score按原概率平均为零：$\mathbb E_P S=\sum_jp_j(h_j/p_j)=\sum_jh_j=0$。这正是概率和约束换成相对刻度后的样子。

## 3. 导数为什么是梯度与方向的配对？

对任意有限支持线性路径$p_j(t)=p_j+th_j$，直接计算均值变化：

$$
\begin{aligned}
\left.\frac d{dt}\sum_jy_j(p_j+th_j)\right|_0&=\sum_jy_jh_j,\\
\sum_jp_jD_jS_j&=\sum_jp_j(y_j-\mu)\frac{h_j}{p_j}\\
&=\sum_j(y_j-\mu)h_j\\
&=\sum_jy_jh_j-\mu\sum_jh_j\\
&=\sum_jy_jh_j-\mu\times0.
\end{aligned}
$$

> **符号回看：** $D_j=y_j-\mu$是均值IF，S是当前路径score。第一处约去正的$p_j$，最后利用合法方向和为0。$\mathbb E_P[DS]$称内积（inner product）：先将同行的$D_j$与$S_j$相乘，再按P加权求和。

对于点替换z=1，配对为$c(-r)(-1)+r(c)(c/r)=cr+c^2=c(r+c)=c$，恰好回到第一讲的变化率。向0的方向另有自己的S，D规则保持不变。

## 4. 将性别和处理也纳入观测

现在保留同一个人的$O=(X,A,Y)$：X为原始sex编码，A为早期RHC，Y为死亡。三者都取0或1，因此共有$2\times2\times2=8$种观测组合。按各组合统计人数，得到联合频数表（joint frequency table）；每行对应一种$(X,A,Y)$取值。固定一种组合$o_*$，其原经验概率$p_*=n_*/5735$；先把每种组合的概率乘$1-t$，再向选中组合加t，因此$S_j=-1+\mathbf1\{j=*\}/p_*$。

整体死亡均值的IF仍只看y。于是：

$$
\sum_jp_jD_jS_j=-\sum_jp_jD_j+\frac{p_*D_*}{p_*}=0+D_*=y_*-r.
$$

> **符号回看：** 星号标记选定的一个$(X,A,Y)$观测类型；$p_*$是该观测组合的概率。先用第一讲均值零消掉第一项，再约去$p_*$。分组更细，均值目标没有改变。

## 改变步长，会改变起点score吗？

把t从0.1改到0.3，起点score会变成三倍吗？先操作二类实验，再在同一联合频数表中选一种观测组合核对。

<div class="lab" data-lab="2"></div>
<div class="case-workbench" data-case-study="2"></div>

<details><summary>答案与理由</summary>

不会。当前概率变化是th，因此距离增为三倍；h和S都定义在原分布，仍固定。S的分母始终取原概率，以保持同一个起点方向。

</details>

<details><summary>什么时候可以用点质量扰动分布？</summary>

本章各观测组合的概率全部正，选支持内一点时存在双侧小区间让新概率仍正。连续分布P通常不给某个点正概率，向该点加质量会改变支持或支配测度，不能自动称正则子模型（regular submodel）。第五讲将对模型允许的全部平滑方向验证梯度恒等式。score均值零表达概率和约束；IF则还需要给出正确的方向导数。

</details>

## 用代码计算方向、score与加权配对

<div class="lesson-language-control"><label>本章代码语言 <select data-lesson-language><option value="julia">Julia运算</option><option value="r">R运算</option></select></label><span>使用同一份RHC数据与相同的数学目标</span></div>

<div class="lesson-code-panel" data-lesson-panel="julia">


输入仍是同一原CSV。脚本输出所选格方向h、S以及均值变化率和配对；网页台面另列原概率、新概率、D及逐格pDS。观察t改变时，最后配对保持起点导数。

运行前输入是[同一份RHC原始CSV](../shared/data/public/rhc/source.csv)。读取与拟合定义见[RHCCase.jl](../shared/julia/RHCCase.jl)，完整[本讲脚本](julia/rhc_lessons/ch02.jl)可编辑；所有脚本可从其他工作目录运行，只须保留zh/与shared/相对位置。

```sh
julia --startup-file=no --history-file=no zh/julia/rhc_lessons/ch02.jl
```

```julia
# 公开 RHC 队列：X=性别，A=是否 RHC，Y=30 日死亡；全部量由原始记录计算。
# 核心定义见EIFCase.jl的BEGIN_CH02段；本讲仍只研究终点事件均值。
include(joinpath(@__DIR__, "..", "..", "..", "shared", "julia", "RHCCase.jl"))
using .RHCCase
using Printf

data = rhc_data()
direction = point_direction(data, 4) # 第4格：x=0,a=1,y=1；索引从1开始。
p = [c.p for c in data.cells]
t = 0.01
pt = linear_path(p, direction.score, t)
new_mean = sum(pt[i] * c.y for (i,c) in enumerate(data.cells))
@printf("原风险=%.6f，新风险=%.6f，变化率=%.6f\n", data.marginal_risk, new_mean, (new_mean-data.marginal_risk)/t)
@printf("直接导数=%.6f，IF×score配对=%.6f\n", direction.derivative, direction.pairing)
for (i,c) in enumerate(data.cells)
    @printf("(%d,%d,%d): h=%+.6f, score=%+.6f\n", c.x, c.a, c.y, direction.h[i], direction.score[i])
end
```


<details><summary>查看本讲数学函数的源码</summary>

下列函数由RHCCase复用，计数来自真实原文件；它们没有内置真实总体答案。

```julia
# 第2讲：t改变位置；h、score与起点导数不随t改变。
function point_direction(data, index::Integer)
    1 <= index <= length(data.cells) || throw(ArgumentError("Invalid cell index"))
    p = [c.p for c in data.cells]
    h = [(i == index ? 1.0 : 0.0) - p[i] for i in eachindex(p)]
    score = h ./ p
    influence = mean_if(data)
    derivative = sum(c.y * h[i] for (i, c) in enumerate(data.cells))
    pairing = weighted_inner(p, influence.values, score)
    (; index, h, score, derivative, pairing)
end
function linear_path(p, score, t::Real)
    checked_probabilities(p); checked_vector(score, length(p))
    isfinite(t) || throw(ArgumentError("Finite path parameter required"))
    abs(dot(p, score)) <= 1e-12 || throw(ArgumentError("Score must be centred under p"))
    updated = p .* (1 .+ t .* score)
    checked_probabilities(updated)  # 不截断；超出当前全正模型就失败。
    updated
end
```

</details>



</div>

<div class="lesson-code-panel" data-lesson-panel="r" hidden>

输入是[同一公开RHC原CSV](../shared/data/public/rhc/source.csv)。共享定义：[RHCCase.R](../shared/R/RHCCase.R)与[EIFCase.R](../shared/R/EIFCase.R)。[完整R脚本](R/ch02.R)使用base R，保留项目目录结构即可从任意工作目录运行。

```sh
Rscript --vanilla zh/R/ch02.R
```

```r
# 第2讲：概率方向与均值导数
# 输入：冻结的公开RHC原CSV；输出：本讲对象与终端核对值；仅使用base R。
# commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
# sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
# if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch02.R")
# length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。
stopifnot(length(script_path) == 1L, !is.na(script_path))
# dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
# source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。
source(file.path(project_root, "shared", "R", "RHCCase.R"))
# 从同一官方CSV计算各观测组合的概率及经验模型，输出list；后续所有数值由输入记录决定。
data <- rhc_data()
# 第4格是(x,a,y)=(0,1,1)；R索引从1开始。返回h、score、导数与配对的list。
direction <- point_direction(data, 4L)
# 连续两个$从data取cells表再取p列，输出长度8概率向量。
p <- data$cells$p
# 设置无量纲路径步长，一个数值标量。
t <- 0.01
# 保持格顺序计算8项新概率；共享函数拒绝非法概率。
pt <- linear_path(p, direction$score, t)
# 各观测组合的新概率乘对应结局，再对8种观测组合求和，得到一个新均值。
new_mean <- sum(pt * data$cells$y)
# 显示旧风险、新风险及变化率，除数t非零。
cat("risk =", data$marginal_risk, "; new risk =", new_mean, "; rate =", (new_mean - data$marginal_risk) / t, "\n")
# 显示直接导数和IF与score配对；两者应相同。
cat("derivative =", direction$derivative, "; IF-score pairing =", direction$pairing, "\n")
# [c(...)]选择三列；data.frame按同一格拼接h和score，print显示8行，保持原数据。
print(data.frame(data$cells[c("x", "a", "y")], h = direction$h, score = direction$score))
```

<details><summary>逐行解释：输入、输出、维度与数学式</summary>

<div class="r-line-card" data-r-line="4">

#### R第4行

```r
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
```

<p>输入：本行定义的常量或程序环境。输出：<code>script_argument</code> · character vector · 路径或参数字符串。</p>

commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。

</div>

<div class="r-line-card" data-r-line="6">

#### R第6行

```r
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
```

<p>输入：本行定义的常量或程序环境。输出：<code>source_files</code> · character vector · 路径或参数字符串。</p>

sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。

</div>

<div class="r-line-card" data-r-line="8">

#### R第8行

```r
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch02.R")
```

<p>输入：<code>source_files</code> · character vector · 路径或参数字符串；<code>script_argument</code> · character vector · 路径或参数字符串。输出：<code>script_path</code> · character vector · 路径或参数字符串。</p>

if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。

</div>

<div class="r-line-card" data-r-line="10">

#### R第10行

```r
stopifnot(length(script_path) == 1L, !is.na(script_path))
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。

</div>

<div class="r-line-card" data-r-line="12">

#### R第12行

```r
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：<code>project_root</code> · character vector · 路径或参数字符串。</p>

dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。

</div>

<div class="r-line-card" data-r-line="14">

#### R第14行

```r
source(file.path(project_root, "shared", "R", "RHCCase.R"))
```

<p>输入：<code>project_root</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。

</div>

<div class="r-line-card" data-r-line="16">

#### R第16行

```r
data <- rhc_data()
```

<p>输入：本行定义的常量或程序环境。输出：<code>data</code> · list · 命名容器；各成员按自身维度。</p>

从同一官方CSV计算各观测组合的概率及经验模型，输出list；后续所有数值由输入记录决定。

</div>

<div class="r-line-card" data-r-line="18">

#### R第18行

```r
direction <- point_direction(data, 4L)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度。输出：<code>direction</code> · list · 命名容器；各成员按自身维度。</p>

第4格是(x,a,y)=(0,1,1)；R索引从1开始。返回h、score、导数与配对的list。

$$
h_j=\mathbf1(j=4)-p_j,\quad S_j=h_j/p_j
$$


</div>

<div class="r-line-card" data-r-line="20">

#### R第20行

```r
p <- data$cells$p
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度。输出：<code>p</code> · numeric vector · 长度8；按(x,a,y)格对齐。</p>

连续两个$从data取cells表再取p列，输出长度8概率向量。

</div>

<div class="r-line-card" data-r-line="22">

#### R第22行

```r
t <- 0.01
```

<p>输入：本行定义的常量或程序环境。输出：<code>t</code> · numeric scalar (double) · 长度1。</p>

设置无量纲路径步长，一个数值标量。

</div>

<div class="r-line-card" data-r-line="24">

#### R第24行

```r
pt <- linear_path(p, direction$score, t)
```

<p>输入：<code>p</code> · numeric vector · 长度8；按(x,a,y)格对齐；<code>direction</code> · list · 命名容器；各成员按自身维度；<code>t</code> · numeric scalar (double) · 长度1。输出：<code>pt</code> · numeric vector · 长度8；按(x,a,y)格对齐。</p>

保持格顺序计算8项新概率；共享函数拒绝非法概率。

$$
p_{t,j}=p_j(1+tS_j)
$$


</div>

<div class="r-line-card" data-r-line="26">

#### R第26行

```r
new_mean <- sum(pt * data$cells$y)
```

<p>输入：<code>pt</code> · numeric vector · 长度8；按(x,a,y)格对齐；<code>data</code> · list · 命名容器；各成员按自身维度。输出：<code>new_mean</code> · numeric scalar (double) · 长度1。</p>

各观测组合的新概率乘对应结局，再对8种观测组合求和，得到一个新均值。

$$
\mu_t=\sum_jp_{t,j}y_j
$$


</div>

<div class="r-line-card" data-r-line="28">

#### R第28行

```r
cat("risk =", data$marginal_risk, "; new risk =", new_mean, "; rate =", (new_mean - data$marginal_risk) / t, "\n")
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度；<code>new_mean</code> · numeric scalar (double) · 长度1；<code>t</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

显示旧风险、新风险及变化率，除数t非零。

</div>

<div class="r-line-card" data-r-line="30">

#### R第30行

```r
cat("derivative =", direction$derivative, "; IF-score pairing =", direction$pairing, "\n")
```

<p>输入：<code>direction</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

显示直接导数和IF与score配对；两者应相同。

$$
\dot\mu=\sum_jp_jD_jS_j
$$


</div>

<div class="r-line-card" data-r-line="32">

#### R第32行

```r
print(data.frame(data$cells[c("x", "a", "y")], h = direction$h, score = direction$score))
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度；<code>direction</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

[c(...)]选择三列；data.frame按同一格拼接h和score，print显示8行，保持原数据。

</div>

</details>

</div>

## 接下来将联合分布拆成三个机制

已区分步长、概率变化、方向、score和方向导数，验证均值的配对。下一讲将联合分布分解为三个机制，弄清标准化目标究竟使用哪些机制。


---

# 第 3 章：分解联合分布，构造标准化风险差

整体死亡比例无法区分RHC组与未RHC组为何不同。本讲从真实队列按性别、处理和结局汇总的计数出发，明确每个分母，再构造两种处理面对同一人群的标准化目标。

## 1. 在指定组内计算条件概率

X=0为原sex字段Female，X=1为Male。以下所有计数均由原始CSV计算，见台面。具体地，女性共有2543人，其中906人接受RHC，这906人中348人死亡；348对应**接受RHC的女性中死亡**。分母不同，问题就不同：

$$
p_X(0)=\frac{2543}{5735},\quad
g(0)=\frac{906}{2543},\quad
Q(1,0)=\frac{348}{906}.
$$

> **符号回看：** $p_X$是人群构成，g是给定X的RHC概率，Q是给定A、X的死亡风险。条件均值（conditional mean）Q等于组内0/1平均；这里使用当前表的饱和经验拟合（saturated empirical fit）：每个(a,x)组各自估计一个死亡风险。

## 2. 为什么联合分布能拆开？

连乘依次补上条件，分母会约去：

$$
\begin{aligned}
p(x,a,y)&=p(y\mid a,x)p(a\mid x)p(x),\\
p(0,1,1)&=\frac{348}{906}\frac{906}{2543}\frac{2543}{5735}=\frac{348}{5735}.
\end{aligned}
$$

> **符号回看：** 第一行按Y、A、X三个机制分解，第二行是女性RHC死亡这一格。虽然写作p(0,1,1)，三个坐标的顺序仍为X、A、Y；连乘顺序不改变坐标顺序。

<div class="case-workbench" data-case-study="3"></div>

## 3. 标准化（standardisation）后，两臂为何使用相同的人群权重？

先让同一组人分别面对两种处理的拟合风险：

$$
\Psi_X(P)=\sum_xp_X(x)\{Q(1,x)-Q(0,x)\}.
$$

> **符号回看：** 下标X强调这里只按sex分层；两臂都使用同一人群的外层权重$p_X$。真实表给出约0.0736921，即7.36921pp，是性别标准化的观察关联。

未经调整差使用不同权重：$\mathbb E[Y\mid A=1]-\mathbb E[Y\mid A=0]$。前者女性权重为906/2184，后者为1637/3551。将它们与标准化使用的共同权重2543/5735比较，就能看出两种计算怎样使用人群构成。

## 4. 只改一个机制会怎样？

给定Q与pX，标准化公式没有g，所以只改变g不改变目标。**g决定每个处理层能提供多少结局信息，因此会影响Q的估计精度。** 例如某层极少接受RHC，该层的RHC风险就较难估计。 第4讲的分母和第7讲的方差会解答这个问题。

<div class="lab" data-lab="3"></div>

先预测：将两层g都设成0.5，标准化差和未经调整差各怎样变？再改变一个Q，观察两者。

<details><summary>答案与理由</summary>

g都为0.5时，实际两臂的X构成同为原pX，所以未经调整差等于标准化差；后者没有改变。改变Q则改变某组风险，通常同时改变两种差。界面在各条件组内单独归一化；纯g操作始终保持Q与pX固定。

</details>

## 5. 用只含处理变量的模型拟合初始风险

先用只含A的风险模型：每臂一个死亡比例，跨X共用。它刻意忽略sex带来的组内差异，便于看清targeting要改什么。g先由各sex组的实际处理比例估计；pX由实际人数估计。饱和Q和初始Q是两套函数，台面分别列出，后文不会混用。

## 代码工作簿：输入、运算与输出

<div class="lesson-language-control"><label>本章代码语言 <select data-lesson-language><option value="julia">Julia运算</option><option value="r">R运算</option></select></label><span>使用同一份RHC数据与相同的数学目标</span></div>

<div class="lesson-code-panel" data-lesson-panel="julia">

运行前输入是[同一份RHC原始CSV](../shared/data/public/rhc/source.csv)。读取与拟合定义见[RHCCase.jl](../shared/julia/RHCCase.jl)，完整[本讲脚本](julia/rhc_lessons/ch03.jl)可编辑；所有脚本可从其他工作目录运行，只须保留zh/与shared/相对位置。

```sh
julia --startup-file=no --history-file=no zh/julia/rhc_lessons/ch03.jl
```

```julia
# 公开 RHC 队列：X=性别，A=是否 RHC，Y=30 日死亡；全部量由原始记录计算。
# 读取与四组汇总的完整定义见EIFCase.jl的BEGIN_CH03段。
# q[a+1,x+1]：行是处理a，列是基线x；所有拟合只用传入计数。
include(joinpath(@__DIR__, "..", "..", "..", "shared", "julia", "RHCCase.jl"))
using .RHCCase
using Printf

data = rhc_data()
for group in data.groups
    @printf("x=%d,a=%d: 人数=%d,事件=%d,风险=%.6f,初始Q=%.6f\n", group.x, group.a, group.n, group.events, group.q_observed, group.initial_q)
end
println("经验人群比例 px = ", data.empirical_model.px)
println("按X估计的处理概率 g = ", data.empirical_model.g)
@printf("只按A拟合后的初始风险差=%.6f\n", data.initial_estimate)

println("此处仅按性别标准化，未建立充分混杂控制；结果不作为 RHC 临床因果效应。")
```


<details><summary>查看本讲数学函数的源码</summary>

下列函数由RHCCase复用，计数来自真实原文件；它们没有内置真实总体答案。

```julia
# 标签x/a/y保持0/1；数组索引由标签加1。q的行是a，列是x。
# 本模块只读取调用者传入的计数，不读取JavaScript教学模型。
function read_counts(path::AbstractString)
    lines = readlines(path)
    isempty(lines) && throw(ArgumentError("Empty counts CSV"))
    strip(lines[1]) == "x,a,y,n" || throw(ArgumentError("Expected CSV header x,a,y,n"))
    rows = NamedTuple{(:x, :a, :y, :n), Tuple{Int,Int,Int,Int}}[]
    for line in lines[2:end]
        isempty(strip(line)) && continue
        fields = split(strip(line), ',')
        length(fields) == 4 || throw(ArgumentError("Expected four integer CSV fields"))
        x, a, y, n = parse.(Int, strip.(fields))
        push!(rows, (; x, a, y, n))
    end
    checked_counts(rows)
end

function checked_counts(rows)
    length(rows) == 8 || throw(ArgumentError("The teaching model requires eight positive cells"))
    checked = NamedTuple{(:x, :a, :y, :n), Tuple{Int,Int,Int,Int}}[]
    for c in rows
        all(k -> hasproperty(c, k), (:x, :a, :y, :n)) ||
            throw(ArgumentError("Each cell needs x,a,y,n"))
        all(v -> v isa Integer && !(v isa Bool) && v in (0, 1), (c.x, c.a, c.y)) ||
            throw(ArgumentError("Cell labels must be binary integers"))
        c.n isa Integer && !(c.n isa Bool) && 0 < c.n <= typemax(Int) ||
            throw(ArgumentError("Each observed count must be a positive integer"))
        push!(checked, (x=Int(c.x), a=Int(c.a), y=Int(c.y), n=Int(c.n)))
    end
    length(Set((c.x, c.a, c.y) for c in checked)) == 8 ||
        throw(ArgumentError("Duplicate cell labels"))
    sort(checked; by=c -> (c.x, c.a, c.y))
end

function case_data(rows::AbstractVector)
    counts = checked_counts(rows)
    n = foldl((s, c) -> Base.Checked.checked_add(s, c.n), counts; init=0)
    cells = [merge(c, (p=c.n / n,)) for c in counts]
    px = [sum(c.n for c in counts if c.x == x) / n for x in 0:1]
    g = [sum(c.n for c in counts if c.x == x && c.a == 1) /
         sum(c.n for c in counts if c.x == x) for x in 0:1]
    q = [sum(c.n * c.y for c in counts if c.a == a && c.x == x) /
         sum(c.n for c in counts if c.a == a && c.x == x) for a in 0:1, x in 0:1]
    arm_risks = [sum(c.n * c.y for c in counts if c.a == a) /
                 sum(c.n for c in counts if c.a == a) for a in 0:1]
    empirical_model = (px=copy(px), g=copy(g), q=copy(q))
    initial_fit = (px=copy(px), g=copy(g), q=[arm_risks[a+1] for a in 0:1, x in 0:1])
    groups = [(x=x, a=a,
               n=sum(c.n for c in counts if c.x == x && c.a == a),
               events=sum(c.n * c.y for c in counts if c.x == x && c.a == a),
               q_observed=q[a+1,x+1], p_x=px[x+1], g_hat=g[x+1],
               initial_q=initial_fit.q[a+1,x+1]) for x in 0:1 for a in 0:1]
    (; n, cells, groups, empirical_model, initial_fit,
       marginal_risk=sum(c.p * c.y for c in cells),
       initial_estimate=ate(initial_fit), observed_difference=arm_risks[2] - arm_risks[1])
end
case_data(path::AbstractString) = case_data(read_counts(path))

ate(model) = sum(model.px[x+1] * (model.q[2,x+1] - model.q[1,x+1]) for x in 0:1)
```

</details>

</div>

<div class="lesson-code-panel" data-lesson-panel="r" hidden>

输入是[同一公开RHC原CSV](../shared/data/public/rhc/source.csv)。共享定义：[RHCCase.R](../shared/R/RHCCase.R)与[EIFCase.R](../shared/R/EIFCase.R)。[完整R脚本](R/ch03.R)使用base R，保留项目目录结构即可从任意工作目录运行。

```sh
Rscript --vanilla zh/R/ch03.R
```

```r
# 第3讲：三机制的经验对象
# 输入：冻结的公开RHC原CSV；输出：本讲对象与终端核对值；仅使用base R。
# commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
# sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
# if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch03.R")
# length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。
stopifnot(length(script_path) == 1L, !is.na(script_path))
# dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
# source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。
source(file.path(project_root, "shared", "R", "RHCCase.R"))
# 从同一官方CSV计算各观测组合的概率及经验模型，输出list；后续所有数值由输入记录决定。
data <- rhc_data()
# 显示4×多列分组表，每行对应一个(x,a)；n、events、q_observed、initial_q均由原CSV聚合。
print(data$groups)
# 提取长度2经验X概率向量，依次对应x=0、1。
px <- data$empirical_model$px
# 提取长度2条件RHC概率向量，位置x+1对应基线类别x。
g <- data$empirical_model$g
# 提取2×2条件死亡风险矩阵：行a+1、列x+1；q[1,2]是a=0,x=1。
q <- data$empirical_model$q
# 显示经验人群比例、处理概率及仅按A拟合初始Q后的标准化风险差。
cat("px =", px, "; g =", g, "; initial risk difference =", data$initial_estimate, "\n")
# print保留矩阵行列形状显示2×2风险，不把矩阵行误读为患者。
print(q)
# 这里只按性别标准化，充分混杂控制未得到证明；结果不是已识别的临床因果效应。
```

<details><summary>逐行解释：输入、输出、维度与数学式</summary>

<div class="r-line-card" data-r-line="4">

#### R第4行

```r
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
```

<p>输入：本行定义的常量或程序环境。输出：<code>script_argument</code> · character vector · 路径或参数字符串。</p>

commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。

</div>

<div class="r-line-card" data-r-line="6">

#### R第6行

```r
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
```

<p>输入：本行定义的常量或程序环境。输出：<code>source_files</code> · character vector · 路径或参数字符串。</p>

sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。

</div>

<div class="r-line-card" data-r-line="8">

#### R第8行

```r
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch03.R")
```

<p>输入：<code>source_files</code> · character vector · 路径或参数字符串；<code>script_argument</code> · character vector · 路径或参数字符串。输出：<code>script_path</code> · character vector · 路径或参数字符串。</p>

if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。

</div>

<div class="r-line-card" data-r-line="10">

#### R第10行

```r
stopifnot(length(script_path) == 1L, !is.na(script_path))
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。

</div>

<div class="r-line-card" data-r-line="12">

#### R第12行

```r
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：<code>project_root</code> · character vector · 路径或参数字符串。</p>

dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。

</div>

<div class="r-line-card" data-r-line="14">

#### R第14行

```r
source(file.path(project_root, "shared", "R", "RHCCase.R"))
```

<p>输入：<code>project_root</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。

</div>

<div class="r-line-card" data-r-line="16">

#### R第16行

```r
data <- rhc_data()
```

<p>输入：本行定义的常量或程序环境。输出：<code>data</code> · list · 命名容器；各成员按自身维度。</p>

从同一官方CSV计算各观测组合的概率及经验模型，输出list；后续所有数值由输入记录决定。

</div>

<div class="r-line-card" data-r-line="18">

#### R第18行

```r
print(data$groups)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

显示4×多列分组表，每行对应一个(x,a)；n、events、q_observed、initial_q均由原CSV聚合。

</div>

<div class="r-line-card" data-r-line="20">

#### R第20行

```r
px <- data$empirical_model$px
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度。输出：<code>px</code> · numeric vector · 长度2；按x=0、1对齐。</p>

提取长度2经验X概率向量，依次对应x=0、1。

$$
p_x=P_n(X=x)
$$


</div>

<div class="r-line-card" data-r-line="22">

#### R第22行

```r
g <- data$empirical_model$g
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度。输出：<code>g</code> · numeric vector · 长度2；按x=0、1对齐。</p>

提取长度2条件RHC概率向量，位置x+1对应基线类别x。

$$
g(x)=P_n(A=1\mid X=x)
$$


</div>

<div class="r-line-card" data-r-line="24">

#### R第24行

```r
q <- data$empirical_model$q
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度。输出：<code>q</code> · numeric matrix · 2行（a+1）×2列（x+1）。</p>

提取2×2条件死亡风险矩阵：行a+1、列x+1；q[1,2]是a=0,x=1。

$$
Q(a,x)=E_{P_n}(Y\mid A=a,X=x)
$$


</div>

<div class="r-line-card" data-r-line="26">

#### R第26行

```r
cat("px =", px, "; g =", g, "; initial risk difference =", data$initial_estimate, "\n")
```

<p>输入：<code>px</code> · numeric vector · 长度2；按x=0、1对齐；<code>g</code> · numeric vector · 长度2；按x=0、1对齐；<code>data</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

显示经验人群比例、处理概率及仅按A拟合初始Q后的标准化风险差。

</div>

<div class="r-line-card" data-r-line="28">

#### R第28行

```r
print(q)
```

<p>输入：<code>q</code> · numeric matrix · 2行（a+1）×2列（x+1）。输出：执行检查、显示或控制流程。</p>

print保留矩阵行列形状显示2×2风险，不把矩阵行误读为患者。

</div>

</details>

</div>



<details><summary>扩展基线变量后，标准化目标怎样变化？</summary>

这里用sex得到性别标准化关联。第8讲扩展W时，外层平均改为对每条患者的基线向量计算；Q、g仍分别表示条件死亡风险和处理概率。调整集合决定统计泛函的定义，临床因果解释还需论证第0章的混杂控制与选择条件。本课使用已确认的完整30日结局。

</details>

## 接下来推导标准化风险差的梯度

已得到同一真实队列的三个机制、标准化目标及初始Q。下一讲寻找代表该目标变化率的函数，从条件均值的分子/分母求导开始，逐项构造EIF。


---

# 第 4 章：从条件均值的商式逐项构造EIF

同一RHC队列的分组频数已经给出经验参考分布。本章研究：**若向一种观测组合增加概率，标准化风险差怎样变？** 我们会从分母的变化中找出逆概率权重。

## 1. 将条件风险写成分子除以分母

固定处理臂a和基线层x，令$b=\mathbb E_P[Y\mathbf1\{A=a,X=x\}]$，$v=P(A=a,X=x)>0$，则$Q(a,x)=b/v$。朝观测$o_*=(x_*,a_*,y_*)$的点替换，若它属于这组：

$$
b_t=(1-t)b+ty_*,\qquad v_t=(1-t)v+t.
$$

> **符号回看：** b为这一组对总体事件概率的贡献，v为组的总体概率；它们均以总体概率为单位。t为概率路径参数，$y_*$是选中记录类型的结局编码。

## 2. 先通分相减，再求导

不先背商式法则（quotient rule）：

$$
\begin{aligned}
Q_t-Q&=\frac{b+t(y_*-b)}{v+t(1-v)}-\frac bv\\
&=\frac{v[b+t(y_*-b)]-b[v+t(1-v)]}{v[v+t(1-v)]}\\
&=\frac{vb+vt(y_*-b)-bv-bt(1-v)}{v[v+t(1-v)]}\\
&=\frac{t[vy_*-vb-b+bv]}{v[v+t(1-v)]}\\
&=\frac{t(vy_*-b)}{v[v+t(1-v)]}\\
&=\frac{t(y_*-Q)}{v+t(1-v)}.
\end{aligned}
$$

> **符号回看：** Q=b/v为固定原风险；$vb-bv$、$-vb+bv$依次消项。最后分子分母约去v。除以t再令t趋于0，得到$(y_*-Q)/v$；正的v保证可约且有局部导数。

若所选点不属于这组，分子和分母都乘$1-t$，比值完全不变。因此：

$$
\dot Q(a,x)=\frac{\mathbf1\{a_*=a,x_*=x\}}{p_X(x)\pi_a(x)}[y_*-Q(a,x)],
\quad\pi_1=g,\ \pi_0=1-g.
$$

> **符号回看：** $\pi_a$是实际接受a的条件概率；残差$y_*-Q$来自商式的分子变化减分母变化。

## 3. 外层平均也在变

记$\tau(x)=Q(1,x)-Q(0,x)$，目标$\psi=\sum_xp_X(x)\tau(x)$。先写精确差：$p_t\tau_t-p\tau=(p_t-p)\tau+p(\tau_t-\tau)+(p_t-p)(\tau_t-\tau)$。除以t后，前两项分别趋于$\dot p\tau$和$p\dot\tau$；最后一项可写成$[(p_t-p)/t](\tau_t-\tau)$，前因子有有限极限，后因子趋于0，故乘积趋于0。因此这里取的是起点的一阶导数。

外层权重沿点替换的变化为$\dot p_X(x)=\mathbf1\{x=x_*\}-p_X(x)$，于是外层项为$\tau(x_*)-\psi$。内层的$p_X(x)$与上一节分母相消，只剩$\pi_a$的倒数；对照风险前有减号，故残差项为：

$$
\frac{a_*}{g(x_*)}[y_*-Q(1,x_*)]
-\frac{1-a_*}{1-g(x_*)}[y_*-Q(0,x_*)].
$$

> **符号回看：** $a_*$只可能0或1，起到选择实际处理臂的开关作用；负号来自目标定义Q1减Q0；这一项的最终符号还取决于残差。

## 4. 合并残差项与中心化项，检查梯度候选的均值

将上述两项作为对输入$o=(x,a,y)$的函数：

$$
\begin{aligned}
D_P(o)&=H_g(a,x)[y-Q(a,x)]+\tau(x)-\psi,\\
H_g(a,x)&=\frac a{g(x)}-\frac{1-a}{1-g(x)}.
\end{aligned}
$$

> **符号回看：** H是带符号的实际处理逆概率权重；D为本目标的梯度候选，单位是风险差/单位路径步长。下标P表明Q、g、ψ都取自同一个参考分布。

给定A、X，残差条件期望为0，因此加权残差也平均为0；外层项平均为$\mathbb E\tau-\psi=0$。这证明中心化，但还没单凭均值零证明全部方向导数正确，第5讲继续验证。

## 改变处理臂，残差项的符号怎样变？

选一格Y=1但A=0：残差项的方向一定正吗？如果删掉逆概率分母，是否仍能通过直接差分？

<div class="lab" data-lab="4"></div>
<div class="case-workbench" data-case-study="4"></div>

<details><summary>答案与理由</summary>

当y=1、Q小于1时，残差为正，A=0的H为负，所以结局项为负；完整D还加外层项，须计算才知总符号。删除分母一般会失败，因为组内均值的商式确实有v；外层只能消掉pX，不能把处理概率也消去。网页从扰动后的各观测组合概率重新算目标，独立于D公式。

</details>

## 用代码计算初始拟合的加权残差

<div class="lesson-language-control"><label>本章代码语言 <select data-lesson-language><option value="julia">Julia运算</option><option value="r">R运算</option></select></label><span>使用同一份RHC数据与相同的数学目标</span></div>

<div class="lesson-code-panel" data-lesson-panel="julia">


初始Q只按A拟合，与本章用于数学导数的饱和Q不同。脚本将同一个H应用到初始模型残差，输出H和汇总的初始score；网页台面另外列出各处理—性别分组的贡献，以及各观测组合上的拟合影响值。这个样本平均通常非零，正是第8讲要针对的方向；它衡量初始预测在这份样本中留下的加权残差。

运行前输入是[同一份RHC原始CSV](../shared/data/public/rhc/source.csv)。读取与拟合定义见[RHCCase.jl](../shared/julia/RHCCase.jl)，完整[本讲脚本](julia/rhc_lessons/ch04.jl)可编辑；所有脚本可从其他工作目录运行，只须保留zh/与shared/相对位置。

```sh
julia --startup-file=no --history-file=no zh/julia/rhc_lessons/ch04.jl
```

```julia
# 公开 RHC 队列：X=性别，A=是否 RHC，Y=30 日死亡；全部量由原始记录计算。
# H及梯度定义见EIFCase.jl的BEGIN_CH04段；此处尚不更新Q。
include(joinpath(@__DIR__, "..", "..", "..", "shared", "julia", "RHCCase.jl"))
using .RHCCase
using Printf

data = rhc_data()
initial_d = eif_values(data.initial_fit, data.cells)
for group in data.groups
    h = clever_h(data.initial_fit, group.a, group.x)
    @printf("x=%d,a=%d: H=%+.6f\n", group.x, group.a, h)
end
correction = sum(c.p * initial_d[i] for (i,c) in enumerate(data.cells))
@printf("初始目标=%+.6f，初始拟合梯度的样本平均=%+.6f\n", data.initial_estimate, correction)
println("本讲只保存初始目标和经验梯度平均，怎样据此修正估计或更新Q在第8讲构建。")

println("此处仅按性别标准化，未建立充分混杂控制；结果不作为 RHC 临床因果效应。")
```


<details><summary>查看本讲数学函数的源码</summary>

下列函数由RHCCase复用，计数来自真实原文件；它们没有内置真实总体答案。

```julia
function clever_h(model, a, x)
    a in (0, 1) && x in (0, 1) || throw(ArgumentError("Binary group labels required"))
    g = model.g[x+1]
    0 < g < 1 || throw(ArgumentError("Treatment probabilities must be strictly interior"))
    a == 1 ? 1 / g : -1 / (1 - g)
end

function eif_values(model, cells; estimate=ate(model))
    [model.q[2,c.x+1] - model.q[1,c.x+1] - estimate +
     clever_h(model, c.a, c.x) * (c.y - model.q[c.a+1,c.x+1]) for c in cells]
end
```

</details>

<details><summary>基线有多个变量时，这个推导还成立吗？</summary>

条件均值商式、处理开关和外层中心化均不要求X只能二元。一般W下用条件期望与积分表达同一分解；但连续W中的点替换不能自动当正则子模型。因此用所有允许的平滑score方向验证，才是下一讲要完成的数学工作。

</details>



</div>

<div class="lesson-code-panel" data-lesson-panel="r" hidden>

输入是[同一公开RHC原CSV](../shared/data/public/rhc/source.csv)。共享定义：[RHCCase.R](../shared/R/RHCCase.R)与[EIFCase.R](../shared/R/EIFCase.R)。[完整R脚本](R/ch04.R)使用base R，保留项目目录结构即可从任意工作目录运行。

```sh
Rscript --vanilla zh/R/ch04.R
```

```r
# 第4讲：EIF的逐格组成
# 输入：冻结的公开RHC原CSV；输出：本讲对象与终端核对值；仅使用base R。
# commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
# sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
# if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch04.R")
# length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。
stopifnot(length(script_path) == 1L, !is.na(script_path))
# dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
# source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。
source(file.path(project_root, "shared", "R", "RHCCase.R"))
# 从同一官方CSV计算各观测组合的概率及经验模型，输出list；后续所有数值由输入记录决定。
data <- rhc_data()
# 给定初始Q/g和8种观测组合，输出8项拟合EIF函数值；此处不更新Q。
initial_d <- eif_values(data$initial_fit, data$cells)
# mapply逐行同时取组表的a与x，clever_h返回一个权重，输出长度4向量。
h <- mapply(function(a, x) clever_h(data$initial_fit, a, x), data$groups$a, data$groups$x)
# 拼接组身份与H，显示4行；每个H可以为正或负。
print(data.frame(data$groups[c("x", "a")], h = h))
# 各观测组合的经验概率逐项乘初始EIF，再求和为一个经验平均；还没有执行任何修正。
correction <- sum(data$cells$p * initial_d)
# 分开显示初始标准化风险差及经验EIF平均，避免把均值非零误当各人残差不合法。
cat("initial estimate =", data$initial_estimate, "; empirical EIF mean =", correction, "\n")
# 这里的调整变量仅为性别；AIPW修正和Q更新到第8讲才构建。
```

<details><summary>逐行解释：输入、输出、维度与数学式</summary>

<div class="r-line-card" data-r-line="4">

#### R第4行

```r
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
```

<p>输入：本行定义的常量或程序环境。输出：<code>script_argument</code> · character vector · 路径或参数字符串。</p>

commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。

</div>

<div class="r-line-card" data-r-line="6">

#### R第6行

```r
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
```

<p>输入：本行定义的常量或程序环境。输出：<code>source_files</code> · character vector · 路径或参数字符串。</p>

sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。

</div>

<div class="r-line-card" data-r-line="8">

#### R第8行

```r
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch04.R")
```

<p>输入：<code>source_files</code> · character vector · 路径或参数字符串；<code>script_argument</code> · character vector · 路径或参数字符串。输出：<code>script_path</code> · character vector · 路径或参数字符串。</p>

if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。

</div>

<div class="r-line-card" data-r-line="10">

#### R第10行

```r
stopifnot(length(script_path) == 1L, !is.na(script_path))
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。

</div>

<div class="r-line-card" data-r-line="12">

#### R第12行

```r
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：<code>project_root</code> · character vector · 路径或参数字符串。</p>

dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。

</div>

<div class="r-line-card" data-r-line="14">

#### R第14行

```r
source(file.path(project_root, "shared", "R", "RHCCase.R"))
```

<p>输入：<code>project_root</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。

</div>

<div class="r-line-card" data-r-line="16">

#### R第16行

```r
data <- rhc_data()
```

<p>输入：本行定义的常量或程序环境。输出：<code>data</code> · list · 命名容器；各成员按自身维度。</p>

从同一官方CSV计算各观测组合的概率及经验模型，输出list；后续所有数值由输入记录决定。

</div>

<div class="r-line-card" data-r-line="18">

#### R第18行

```r
initial_d <- eif_values(data$initial_fit, data$cells)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度。输出：<code>initial_d</code> · numeric vector · 长度8；按(x,a,y)格对齐。</p>

给定初始Q/g和8种观测组合，输出8项拟合EIF函数值；此处不更新Q。

$$
D_j=H_j(y_j-Q_j)+\tau(x_j)-\psi
$$


</div>

<div class="r-line-card" data-r-line="20">

#### R第20行

```r
h <- mapply(function(a, x) clever_h(data$initial_fit, a, x), data$groups$a, data$groups$x)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度。输出：<code>h</code> · numeric vector · 长度4；按(x,a)组对齐。</p>

mapply逐行同时取组表的a与x，clever_h返回一个权重，输出长度4向量。

$$
H(a,x)=a/g(x)-(1-a)/(1-g(x))
$$


</div>

<div class="r-line-card" data-r-line="22">

#### R第22行

```r
print(data.frame(data$groups[c("x", "a")], h = h))
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度；<code>h</code> · numeric vector · 长度4；按(x,a)组对齐。输出：执行检查、显示或控制流程。</p>

拼接组身份与H，显示4行；每个H可以为正或负。

</div>

<div class="r-line-card" data-r-line="24">

#### R第24行

```r
correction <- sum(data$cells$p * initial_d)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度；<code>initial_d</code> · numeric vector · 长度8；按(x,a,y)格对齐。输出：<code>correction</code> · numeric scalar (double) · 长度1。</p>

各观测组合的经验概率逐项乘初始EIF，再求和为一个经验平均；还没有执行任何修正。

$$
P_n\widehat D=\sum_jp_j\widehat D_j
$$


</div>

<div class="r-line-card" data-r-line="26">

#### R第26行

```r
cat("initial estimate =", data$initial_estimate, "; empirical EIF mean =", correction, "\n")
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度；<code>correction</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

分开显示初始标准化风险差及经验EIF平均，避免把均值非零误当各人残差不合法。

</div>

</details>

</div>

## 接下来验证候选函数在所有允许方向上给出正确导数

已解释残差、逆概率权重、正负号及中心化项各自的来源，并用真实分组计数做数值核对。下一讲将候选函数与全部允许方向配对，完成梯度验证。


---

# 第 5 章：为什么必须验证所有允许的方向？

第4讲从点替换构建了D。一条路径吻合还不够：另一个函数可能碰巧给出同一个数，却在别的扰动方向上错。本讲先在RHC联合频数表覆盖全部独立方向，再解释一般平滑模型的路径可微性（pathwise differentiability）。

## 1. 八个概率有多少个独立变化方向？

八个概率和为1，因此合法概率变化h满足$\sum_{j=1}^8h_j=0$，有七个自由度。原分布中各观测组合的概率均为正，可用线性路径$p_j(t)=p_j+th_j$；只要t足够小，各组合的概率仍为正。score为$S_j=h_j/p_j$，满足$\mathbb E_PS=0$。

任选前7种组合之一，在其概率变化量中加1、在第8种组合的变化量中减1，得到七个独立h。任意和为0的h都是它们的线性组合。这比只核对一个点方向多了关键一步：**覆盖了有限模型内所有合法方向。**

## 2. 从路径到方向导数

一条正则子模型（regular submodel）$P_t$在t=0经过P，具有平方可积（square-integrable）score$S=\partial_t\log p_t|_0$。方向导数记：

$$
\dot\Psi_P(S)=\left.\frac d{dt}\Psi(P_t)\right|_0.
$$

> **符号回看：** P为基点，S说明路径的起点相对变化方向；$\dot\Psi$输出沿该方向的一个标量变化率。

如果对所有允许的S都有：

$$
\dot\Psi_P(S)=\mathbb E_P[D_PS],
$$

则D是一个梯度代表（gradient representer）。右边是概率加权的内积：梯度固定，方向变动，输出不同配对。它像熟悉的多元函数“梯度乘移动方向”，只是此处坐标是概率或函数，权重由P决定。

## 3. 将任意score分解为三个机制的分量

联合密度的乘积取对数后变成和。可将S分成：

$$
\begin{aligned}
S_X&=\mathbb E[S\mid X],\\
S_A&=\mathbb E[S\mid A,X]-\mathbb E[S\mid X],\\
S_Y&=S-\mathbb E[S\mid A,X],\\
S&=S_X+S_A+S_Y.
\end{aligned}
$$

> **符号回看：** 条件期望是先在指定组内平均；相减使$\mathbb E[S_A\mid X]=0$、$\mathbb E[S_Y\mid A,X]=0$。因此三项分别对应人群、处理与条件结局变化，并在P内积下两两正交。

条件概率的导数满足$p_Y'=p_YS_Y$，所以逐项求导得到$\dot Q=\sum_y y p_Y S_Y=\mathbb E[Y S_Y\mid a,x]$。由于Q在组内固定且$\mathbb E[S_Y\mid a,x]=0$，可以减去Q而不改变结果。于是条件均值沿Y机制的导数是$\dot Q(a,x)=\mathbb E[(Y-Q(a,x))S_Y\mid a,x]$。外层人群导数为$\mathbb E[(\tau-\psi)S_X]$。

所以目标导数为两臂条件导数的同人群平均，加外层项。把给定(a,x)的期望乘回$p_X(x)\pi_a(x)$，再除以$\pi_a(x)$，可还原为：

$$
\dot\Psi_P(S)=\mathbb E_P[H_g(Y-Q)S_Y]+\mathbb E_P[(\tau-\psi)S_X].
$$

> **符号回看：** H仍为第4讲的带符号逆处理概率。没有S_A项，因为固定Q和pX、仅改g时目标不变。

## 4. 为什么可以用完整score计算同一个导数？

设$D_Y=H_g(Y-Q)$、$D_X=\tau-\psi$。给定A、X，$D_Y$均值0，所以它与只看A、X的S_X、S_A配对均为0。D_X只看X，而S_A、S_Y给定X均值0，所以其交叉配对也为0。展开所有六项后只剩上节两项：

$$
\mathbb E[(D_X+D_Y)(S_X+S_A+S_Y)]
=\mathbb E[D_XS_X]+\mathbb E[D_YS_Y]=\dot\Psi_P(S).
$$

> **符号回看：** 条件均值零使交叉内积消失，只留下$D_X$与$S_X$、$D_Y$与$S_Y$的配对。由此验证第4讲D对任意允许S都给正确导数。

## 加上一个均值零函数，还能给出正确导数吗？

纯处理路径S_A的导数应为0。若在D上随意加一个均值零函数$U=A-g(X)$，对这条方向会怎样？

<div class="lab" data-lab="5"></div>
<div class="case-workbench" data-case-study="5"></div>

<details><summary>答案与理由</summary>

原D与处理方向配对0；新函数D+bU与U配对为$b\mathbb E U^2$。只要b非零、处理概率在0和1之间，就一般不为0，不能在允许处理变化的模型中代表正确导数。均值零不是充分条件。第6讲会解释为何固定g的另一个模型允许这种额外分量。

</details>

## 用代码比较有限差分与梯度配对

<div class="lesson-language-control"><label>本章代码语言 <select data-lesson-language><option value="julia">Julia运算</option><option value="r">R运算</option></select></label><span>使用同一份RHC数据与相同的数学目标</span></div>

<div class="lesson-code-panel" data-lesson-panel="julia">


网页核查全部八个点替换；脚本列一个点方向、七个独立对比方向及机制/混合方向。在同一经验表上，先从新联合概率重新计算标准化差，再作中心有限差分（central finite difference）。它和D配对是两条独立计算。代数论证覆盖有限模型内的全部七维方向；数值核对检验程序的计算，并比较不同步长下的差分误差。

运行前输入是[同一份RHC原始CSV](../shared/data/public/rhc/source.csv)。读取与拟合定义见[RHCCase.jl](../shared/julia/RHCCase.jl)，完整[本讲脚本](julia/rhc_lessons/ch05.jl)可编辑；所有脚本可从其他工作目录运行，只须保留zh/与shared/相对位置。

```sh
julia --startup-file=no --history-file=no zh/julia/rhc_lessons/ch05.jl
```

```julia
# 公开 RHC 队列：X=性别，A=是否 RHC，Y=30 日死亡；全部量由原始记录计算。
# 一般方向数值检查见EIFCase.jl的BEGIN_CH05段。
# 这里在完整经验分布计算梯度；不是拿错设的初始Q当真模型。
include(joinpath(@__DIR__, "..", "..", "..", "shared", "julia", "RHCCase.jl"))
using .RHCCase
using Printf

data = rhc_data()
model = data.empirical_model
score = [(c.x-model.px[2]) + (c.a-model.g[c.x+1]) +
         (c.y-model.q[c.a+1,c.x+1]) for c in data.cells]
check = direction_check(data, score)
@printf("混合方向：差商=%.9f，梯度配对=%.9f\n", check.finite_difference, check.pairing)
outcome_score = [c.y-model.q[c.a+1,c.x+1] for c in data.cells]
outcome_check = direction_check(data, outcome_score)
@printf("结局方向：差商=%.9f，梯度配对=%.9f\n", outcome_check.finite_difference, outcome_check.pairing)
point = point_direction(data, 4) # 与第2讲相同的(0,1,1)点方向。
point_check = direction_check(data, point.score)
@printf("同一点方向：均值导数=%.6f，性别标准化风险差导数配对=%.6f\n", point.derivative, point_check.pairing)

p = [c.p for c in data.cells]
for j in 1:7
    h = zeros(8)
    h[j] = 1.0
    h[8] = -1.0
    contrast = direction_check(data, h ./ p)
    @printf("对比方向%d：直接差分=%.9f，梯度配对=%.9f\n", j, contrast.finite_difference, contrast.pairing)
end
println("有限方向检查帮助发现错误；全方向结论仍依靠正文证明。")
```


<details><summary>查看本讲数学函数的源码</summary>

下列函数由RHCCase复用，计数来自真实原文件；它们没有内置真实总体答案。

```julia
function model_from_probabilities(cells, p)
    checked_probabilities(p); length(cells) == length(p) || throw(ArgumentError("Length mismatch"))
    px = [sum(p[i] for (i,c) in enumerate(cells) if c.x == x) for x in 0:1]
    mass = [sum(p[i] for (i,c) in enumerate(cells) if c.a == a && c.x == x) for a in 0:1, x in 0:1]
    q = [sum(p[i] * c.y for (i,c) in enumerate(cells) if c.a == a && c.x == x) /
         mass[a+1,x+1] for a in 0:1, x in 0:1]
    (; px, g=[mass[2,x+1] / px[x+1] for x in 0:1], q)
end

# 第5讲：在经验全模型的起点验证ATE方向，不用初始错设Q伪装真梯度。
function direction_check(data, score; step::Real=1e-6)
    isfinite(step) && step > 0 || throw(ArgumentError("Positive finite difference step required"))
    p = [c.p for c in data.cells]
    plus = model_from_probabilities(data.cells, linear_path(p, score, step))
    minus = model_from_probabilities(data.cells, linear_path(p, score, -step))
    finite_difference = (ate(plus) - ate(minus)) / (2step)
    pairing = weighted_inner(p, eif_values(data.empirical_model, data.cells), score)
    (; finite_difference, pairing, difference=finite_difference - pairing)
end
```

</details>

<details><summary>一般模型为什么还要求方向导数连续？</summary>

一般L²模型还要求方向导数为score的连续线性泛函；若D平方可积，Cauchy–Schwarz不等式给出$|\mathbb E DS|\le\sqrt{\mathbb E D^2}\sqrt{\mathbb E S^2}$，说明小方向不会产生无限放大的配对。连续分布的点质量不必是允许方向；本章定义要求验证模型中的正则路径，而不是所有任意“分布改动”。某些目标在模型下不存在这样的有限方差D，就不具有本课所用的路径可微性。

</details>



</div>

<div class="lesson-code-panel" data-lesson-panel="r" hidden>

输入是[同一公开RHC原CSV](../shared/data/public/rhc/source.csv)。共享定义：[RHCCase.R](../shared/R/RHCCase.R)与[EIFCase.R](../shared/R/EIFCase.R)。[完整R脚本](R/ch05.R)使用base R，保留项目目录结构即可从任意工作目录运行。

```sh
Rscript --vanilla zh/R/ch05.R
```

```r
# 第5讲：多方向核对
# 输入：冻结的公开RHC原CSV；输出：本讲对象与终端核对值；仅使用base R。
# commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
# sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
# if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch05.R")
# length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。
stopifnot(length(script_path) == 1L, !is.na(script_path))
# dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
# source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。
source(file.path(project_root, "shared", "R", "RHCCase.R"))
# 从同一官方CSV计算各观测组合的概率及经验模型，输出list；后续所有数值由输入记录决定。
data <- rhc_data()
# 采用完整经验分布的饱和模型list，作为梯度验证的数学基点。
model <- data$empirical_model
# 取8行格表，按x,a,y顺序排列；保持后续向量对齐。
cells <- data$cells
# R矩阵用双列索引矩阵逐格取元素；cbind第一列是行a+1，第二列是列x+1，输出8项。
q_at_cell <- model$q[cbind(cells$a + 1L, cells$x + 1L)]
# 三种中心化机制方向逐项相加，输出8项混合score；g按x+1索引。
score <- (cells$x - model$px[2]) + (cells$a - model$g[cells$x + 1L]) + (cells$y - q_at_cell)
# 对合法概率路径计算中心差商及梯度配对，返回list。
check <- direction_check(data, score)
# 只取结局机制中心化残差，输出8项；另外两机制固定。
outcome_score <- cells$y - q_at_cell
# 用同一经验基点检查纯结局方向。
outcome_check <- direction_check(data, outcome_score)
# 重用第2讲同一(0,1,1)点方向，输出包含score和均值导数的list。
point <- point_direction(data, 4L)
# 相同score此时对性别标准化风险差求导；目标已不同于均值。
point_check <- direction_check(data, point$score)
# list按名称保留三套检查，print分别显示，避免混合不同目标导数。
print(list(mixed = check, outcome = outcome_check, point = point_check))
# 读取8项经验格概率，作为h转score的逐项除数。
p <- cells$p
# for循环让j依次取1至7；大括号开始本次循环体，构造七个独立质量转移方向。
for (j in 1:7) {
# numeric(8)创建长度8全零数值向量；每次循环重新创建。
  h <- numeric(8) 
# []按1起始位置把第j格质量增量设为1。
  h[j] <- 1
# 第8种组合设−1，与第j格+1相抵，确保h和为0。
  h[8] <- -1
# /逐项除法把质量方向h变成score；共享函数在全正概率路径上使用预设中心差分步长。
  contrast_check <- direction_check(data, h / p)
# 显示本次独立方向的直接差商与梯度配对。
  cat("direction", j, "; finite difference =", contrast_check$finite_difference, "; pairing =", contrast_check$pairing, "\n")
# 结束循环体；七个数值检查辅助发现错误，全方向结论仍依靠正文证明。
}
```

<details><summary>逐行解释：输入、输出、维度与数学式</summary>

<div class="r-line-card" data-r-line="4">

#### R第4行

```r
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
```

<p>输入：本行定义的常量或程序环境。输出：<code>script_argument</code> · character vector · 路径或参数字符串。</p>

commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。

</div>

<div class="r-line-card" data-r-line="6">

#### R第6行

```r
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
```

<p>输入：本行定义的常量或程序环境。输出：<code>source_files</code> · character vector · 路径或参数字符串。</p>

sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。

</div>

<div class="r-line-card" data-r-line="8">

#### R第8行

```r
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch05.R")
```

<p>输入：<code>source_files</code> · character vector · 路径或参数字符串；<code>script_argument</code> · character vector · 路径或参数字符串。输出：<code>script_path</code> · character vector · 路径或参数字符串。</p>

if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。

</div>

<div class="r-line-card" data-r-line="10">

#### R第10行

```r
stopifnot(length(script_path) == 1L, !is.na(script_path))
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。

</div>

<div class="r-line-card" data-r-line="12">

#### R第12行

```r
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：<code>project_root</code> · character vector · 路径或参数字符串。</p>

dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。

</div>

<div class="r-line-card" data-r-line="14">

#### R第14行

```r
source(file.path(project_root, "shared", "R", "RHCCase.R"))
```

<p>输入：<code>project_root</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。

</div>

<div class="r-line-card" data-r-line="16">

#### R第16行

```r
data <- rhc_data()
```

<p>输入：本行定义的常量或程序环境。输出：<code>data</code> · list · 命名容器；各成员按自身维度。</p>

从同一官方CSV计算各观测组合的概率及经验模型，输出list；后续所有数值由输入记录决定。

</div>

<div class="r-line-card" data-r-line="18">

#### R第18行

```r
model <- data$empirical_model
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度。输出：<code>model</code> · list · 命名容器；各成员按自身维度。</p>

采用完整经验分布的饱和模型list，作为梯度验证的数学基点。

</div>

<div class="r-line-card" data-r-line="20">

#### R第20行

```r
cells <- data$cells
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度。输出：<code>cells</code> · data.frame · 8行×5列（x,a,y,n,p）。</p>

取8行格表，按x,a,y顺序排列；保持后续向量对齐。

</div>

<div class="r-line-card" data-r-line="22">

#### R第22行

```r
q_at_cell <- model$q[cbind(cells$a + 1L, cells$x + 1L)]
```

<p>输入：<code>model</code> · list · 命名容器；各成员按自身维度；<code>cells</code> · data.frame · 8行×5列（x,a,y,n,p）。输出：<code>q_at_cell</code> · numeric vector · 长度8；按(x,a,y)格对齐。</p>

R矩阵用双列索引矩阵逐格取元素；cbind第一列是行a+1，第二列是列x+1，输出8项。

$$
q_j=Q(a_j,x_j)
$$


</div>

<div class="r-line-card" data-r-line="24">

#### R第24行

```r
score <- (cells$x - model$px[2]) + (cells$a - model$g[cells$x + 1L]) + (cells$y - q_at_cell)
```

<p>输入：<code>cells</code> · data.frame · 8行×5列（x,a,y,n,p）；<code>model</code> · list · 命名容器；各成员按自身维度；<code>q_at_cell</code> · numeric vector · 长度8；按(x,a,y)格对齐。输出：<code>score</code> · numeric vector · 长度8；按(x,a,y)格对齐。</p>

三种中心化机制方向逐项相加，输出8项混合score；g按x+1索引。

$$
S=(X-p_1)+(A-g(X))+(Y-Q(A,X))
$$


</div>

<div class="r-line-card" data-r-line="26">

#### R第26行

```r
check <- direction_check(data, score)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度；<code>score</code> · numeric vector · 长度8；按(x,a,y)格对齐。输出：<code>check</code> · list · 命名容器；各成员按自身维度。</p>

对合法概率路径计算中心差商及梯度配对，返回list。

$$
\dot\Psi\approx[\Psi(P_h)-\Psi(P_{-h})]/(2h)
$$


</div>

<div class="r-line-card" data-r-line="28">

#### R第28行

```r
outcome_score <- cells$y - q_at_cell
```

<p>输入：<code>cells</code> · data.frame · 8行×5列（x,a,y,n,p）；<code>q_at_cell</code> · numeric vector · 长度8；按(x,a,y)格对齐。输出：<code>outcome_score</code> · numeric vector · 长度8；按(x,a,y)格对齐。</p>

只取结局机制中心化残差，输出8项；另外两机制固定。

$$
S_Y=Y-Q(A,X)
$$


</div>

<div class="r-line-card" data-r-line="30">

#### R第30行

```r
outcome_check <- direction_check(data, outcome_score)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度；<code>outcome_score</code> · numeric vector · 长度8；按(x,a,y)格对齐。输出：<code>outcome_check</code> · list · 命名容器；各成员按自身维度。</p>

用同一经验基点检查纯结局方向。

</div>

<div class="r-line-card" data-r-line="32">

#### R第32行

```r
point <- point_direction(data, 4L)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度。输出：<code>point</code> · list · 点方向命名容器。</p>

重用第2讲同一(0,1,1)点方向，输出包含score和均值导数的list。

</div>

<div class="r-line-card" data-r-line="34">

#### R第34行

```r
point_check <- direction_check(data, point$score)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度；<code>point</code> · list · 点方向命名容器。输出：<code>point_check</code> · list · 命名容器；各成员按自身维度。</p>

相同score此时对性别标准化风险差求导；目标已不同于均值。

</div>

<div class="r-line-card" data-r-line="36">

#### R第36行

```r
print(list(mixed = check, outcome = outcome_check, point = point_check))
```

<p>输入：<code>check</code> · list · 命名容器；各成员按自身维度；<code>outcome_check</code> · list · 命名容器；各成员按自身维度；<code>point_check</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

list按名称保留三套检查，print分别显示，避免混合不同目标导数。

</div>

<div class="r-line-card" data-r-line="38">

#### R第38行

```r
p <- cells$p
```

<p>输入：<code>cells</code> · data.frame · 8行×5列（x,a,y,n,p）。输出：<code>p</code> · numeric vector · 长度8；按(x,a,y)格对齐。</p>

读取8项经验格概率，作为h转score的逐项除数。

</div>

<div class="r-line-card" data-r-line="40">

#### R第40行

```r
for (j in 1:7) {
```

<p>输入：本行定义的常量或程序环境。输出：<code>j</code> · integer scalar · 长度1。</p>

for循环让j依次取1至7；大括号开始本次循环体，构造七个独立质量转移方向。

</div>

<div class="r-line-card" data-r-line="42">

#### R第42行

```r
  h <- numeric(8) 
```

<p>输入：本行定义的常量或程序环境。输出：<code>h</code> · numeric vector · 长度8；按(x,a,y)格对齐。</p>

numeric(8)创建长度8全零数值向量；每次循环重新创建。

</div>

<div class="r-line-card" data-r-line="44">

#### R第44行

```r
  h[j] <- 1
```

<p>输入：<code>h</code> · numeric vector · 长度8；按(x,a,y)格对齐；<code>j</code> · integer scalar · 长度1。输出：<code>h</code> · numeric vector · 长度8；按(x,a,y)格对齐。</p>

[]按1起始位置把第j格质量增量设为1。

</div>

<div class="r-line-card" data-r-line="46">

#### R第46行

```r
  h[8] <- -1
```

<p>输入：<code>h</code> · numeric vector · 长度8；按(x,a,y)格对齐。输出：<code>h</code> · numeric vector · 长度8；按(x,a,y)格对齐。</p>

第8种组合设−1，与第j格+1相抵，确保h和为0。

$$
\sum_jh_j=0
$$


</div>

<div class="r-line-card" data-r-line="48">

#### R第48行

```r
  contrast_check <- direction_check(data, h / p)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度；<code>h</code> · numeric vector · 长度8；按(x,a,y)格对齐；<code>p</code> · numeric vector · 长度8；按(x,a,y)格对齐。输出：<code>contrast_check</code> · list · 命名容器；各成员按自身维度。</p>

/逐项除法把质量方向h变成score；共享函数在全正概率路径上使用预设中心差分步长。

$$
S_j=h_j/p_j
$$


</div>

<div class="r-line-card" data-r-line="50">

#### R第50行

```r
  cat("direction", j, "; finite difference =", contrast_check$finite_difference, "; pairing =", contrast_check$pairing, "\n")
```

<p>输入：<code>j</code> · integer scalar · 长度1；<code>contrast_check</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

显示本次独立方向的直接差商与梯度配对。

</div>

<div class="r-line-card" data-r-line="52">

#### R第52行

```r
}
```

<p>输入：本行定义的常量或程序环境。输出：执行检查、显示或控制流程。</p>

结束循环体；七个数值检查辅助发现错误，全方向结论仍依靠正文证明。

</div>

</details>

</div>

## 接下来用模型约束和投影确定EIF

已验证有限非参数模型所有方向的梯度恒等式，并说明一般定义。下一讲让模型约束进入空间和投影计算，选出有效代表；第7讲再建立估计误差的展开。


---

# 第 6 章：用切空间和投影确定有效影响函数

第5讲要求D与所有合法score给出正确配对。现在问：合法方向由谁决定？如果模型限制了某机制，多个函数都能通过配对时，哪个才是efficient？本讲沿用同一RHC联合频数表，以各观测组合的函数值及概率权重计算投影。

## 1. 按概率加权计算函数的内积与长度

这8种观测组合上的函数f可写成$f=(f_1,\ldots,f_8)$，第j项是对第j种观测组合的输出。按真实队列经验参考概率$p_j=n_j/5735$定义：

$$
\langle f,h\rangle_P=\sum_{j=1}^8p_jf_jh_j,
\qquad \|f\|_P^2=\sum_jp_jf_j^2.
$$

> **符号回看：** 内积（inner product）是逐行相乘再按P加权；范数（norm）的平方是对自身的内积。各观测组合的权重为$p_j=n_j/5735$。所有p正，使非零列有正平方长度。

均值零的平方可积函数空间记$L^2_0(P)$。本例的函数由8个值组成，构成8维向量；均值零是一条线性约束，因此这个空间为7维。一般函数空间（function space）沿用同一加权平均和长度的想法，容许无限多取值。

## 2. 模型约束怎样决定切空间？

切空间（tangent space）是合法score及其线性组合的闭包；闭包（closure）包含可用合法方向任意逼近的极限方向。有限维中无需另添极限即可计算。

- **观察性全模型**允许pX、g、Q改变，$T=L^2_0(P)$，七维。
- **本章假设练习**将g固定为当前经验值，只许pX与Q改变，T有五维。它用于比较模型约束；本书的RHC观察性分析和第8讲使用g未知的模型。

五个基方向（basis directions）为：

$$
B_X=X-p_X(1),\qquad
B_{xa}=\mathbf1\{X=x,A=a\}[Y-Q(a,x)]\quad(x,a\in\{0,1\}).
$$

> **符号回看：** 第一列改变人群构成，后四列分别改变一组条件结局。各列均值零且两两正交；不同(a,x)列不会同时非零，而条件残差均值零使其与BX正交。

## 3. 为什么会有多个梯度？

令$U=A-g(X)$。它给定X平均为0，又与每个B正交：对BX先按X平均U，对Bxa先按A、X平均残差即可得到0。所以$D_b=D^*+bU$与所有允许S配对，都与$D^*$相同。b是任意实数，U不是该固定g模型的合法处理方向。

能添加哪些分量取决于模型。若g未知，U也合法，而目标沿纯处理路径的导数0；新候选却给$b\mathbb E U^2$，非零b会失败。

## 4. 投影怎样选出范数最小的梯度？

正交投影（orthogonal projection）在T中寻找最接近候选F的函数。先看单列B：

$$
\begin{aligned}
\|F-cB\|^2&=\|F\|^2-2c\langle F,B\rangle+c^2\|B\|^2\\
&=\|F\|^2-\frac{\langle F,B\rangle^2}{\|B\|^2}
+\|B\|^2\left(c-\frac{\langle F,B\rangle}{\|B\|^2}\right)^2.
\end{aligned}
$$

> **符号回看：** c在本节表示待选的投影系数；B为非零基列。最后平方项非负，令括号为0即得到最小值。

先确认$D^*\in T$：二元X下$D_X=[\tau(1)-\tau(0)]B_X$，而$D_Y=\sum_{x,a}H_g(a,x)B_{xa}$。这里BX与Bxa是上节五列，系数在每一基列所属组固定，所以D*确为它们的线性组合。结合U与各列正交，才能断言投影会保留D*并移除bU。

五列相互正交时，分别计算$\langle F,B_k\rangle/\|B_k\|^2$，再乘对应B相加。程序也可逐列扣除已有投影，处理一般独立基。对F=D*+bU，投影恰为D*，残差bU与T正交，因此：

$$
\|D^*+bU\|^2=\|D^*\|^2+2b\langle D^*,U\rangle+b^2\|U\|^2
=\|D^*\|^2+b^2\|U\|^2.
$$

> **符号回看：** 交叉项因正交为0；剩余项非负。位于T内且代表目标导数的唯一函数叫典范梯度（canonical gradient），也就是有效影响函数（efficient influence function，EIF）。其“最短”使用P加权长度，与第7讲方差有关。

## 增大正交分量，投影和范数怎样变？

把b从1改成2：投影会变吗？移除部分的平方长度会怎样变？

<div class="lab" data-lab="6"></div>
<div class="case-workbench" data-case-study="6"></div>

<details><summary>答案与理由</summary>

投影仍为D*，因为增加的仍只在正交方向；残差从U变成2U，平方长度增为四倍。表中真的计算五基投影、正交内积及范数分解。图若画成两轴只能是示意，本实验的数值对象始终是八行列向量。

</details>

## 代码工作簿：输入、运算与输出

<div class="lesson-language-control"><label>本章代码语言 <select data-lesson-language><option value="julia">Julia运算</option><option value="r">R运算</option></select></label><span>使用同一份RHC数据与相同的数学目标</span></div>

<div class="lesson-code-panel" data-lesson-panel="julia">

运行前输入是[同一份RHC原始CSV](../shared/data/public/rhc/source.csv)。读取与拟合定义见[RHCCase.jl](../shared/julia/RHCCase.jl)，完整[本讲脚本](julia/rhc_lessons/ch06.jl)可编辑；所有脚本可从其他工作目录运行，只须保留zh/与shared/相对位置。

```sh
julia --startup-file=no --history-file=no zh/julia/rhc_lessons/ch06.jl
```

```julia
# 公开 RHC 队列：X=性别，A=是否 RHC，Y=30 日死亡；全部量由原始记录计算。
# 投影的完整实现见EIFCase.jl的BEGIN_CH06段，不调用投影软件包。
# 仅本练习假定估计出的g已知固定；最终TMLE仍按输入计数学习g。
include(joinpath(@__DIR__, "..", "..", "..", "shared", "julia", "RHCCase.jl"))
using .RHCCase
using Printf

data = rhc_data()
demo = projection_demo(data; b=1.0)
@printf("候选平方范数=%.6f，投影平方范数=%.6f，残差平方范数=%.6f\n", demo.candidate_second_moment, demo.projection_second_moment, demo.residual_second_moment)
@printf("投影与典范梯度的最大差=%.3g\n", maximum(abs.(demo.projection-demo.canonical)))
```


<details><summary>查看本讲数学函数的源码</summary>

下列函数由RHCCase复用，计数来自真实原文件；它们没有内置真实总体答案。

```julia
function weighted_projection(p, f, basis)
    checked_probabilities(p); checked_vector(f, length(p))
    orthonormal = Vector{Float64}[]
    for b in basis
        checked_vector(b, length(p))
        original_norm = sqrt(weighted_inner(p, b, b))
        original_norm > 0 || throw(ArgumentError("Basis must have full column rank"))
        v = Float64.(b) / original_norm
        for pass in 1:2, u in orthonormal
            v -= weighted_inner(p, v, u) * u
        end
        vnorm = sqrt(weighted_inner(p, v, v))
        vnorm > 1e-12 || throw(ArgumentError("Basis is rank deficient at numerical precision"))
        push!(orthonormal, v / vnorm)
    end
    result = zeros(length(p))
    for u in orthonormal
        result += weighted_inner(p, f, u) * u
    end
    result
end

# 第6讲：仅此练习将计数估计的g当已知固定；最终TMLE仍由输入计数学习g。
function projection_demo(data; b::Real=1.0)
    isfinite(b) || throw(ArgumentError("Finite candidate coefficient required"))
    model = data.empirical_model
    p = [c.p for c in data.cells]
    canonical = eif_values(model, data.cells)
    u = [c.a - model.g[c.x+1] for c in data.cells]
    basis = [[c.x - model.px[2] for c in data.cells]]
    append!(basis, [[c.x == x && c.a == a ? c.y - model.q[a+1,x+1] : 0.0
                     for c in data.cells] for x in 0:1 for a in 0:1])
    candidate = canonical + b * u
    projection = weighted_projection(p, candidate, basis)
    residual = candidate - projection
    (; basis, canonical, u, candidate, projection, residual,
       candidate_second_moment=weighted_inner(p, candidate, candidate),
       projection_second_moment=weighted_inner(p, projection, projection),
       residual_second_moment=weighted_inner(p, residual, residual))
end
```

</details>

</div>

<div class="lesson-code-panel" data-lesson-panel="r" hidden>

输入是[同一公开RHC原CSV](../shared/data/public/rhc/source.csv)。共享定义：[RHCCase.R](../shared/R/RHCCase.R)与[EIFCase.R](../shared/R/EIFCase.R)。[完整R脚本](R/ch06.R)使用base R，保留项目目录结构即可从任意工作目录运行。

```sh
Rscript --vanilla zh/R/ch06.R
```

```r
# 第6讲：已知g练习的投影
# 输入：冻结的公开RHC原CSV；输出：本讲对象与终端核对值；仅使用base R。
# commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
# sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
# if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch06.R")
# length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。
stopifnot(length(script_path) == 1L, !is.na(script_path))
# dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
# source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。
source(file.path(project_root, "shared", "R", "RHCCase.R"))
# 从同一官方CSV计算各观测组合的概率及经验模型，输出list；后续所有数值由输入记录决定。
data <- rhc_data()
# 在本练习固定经验g，b设候选附加分量系数；手工加权线性代数投影返回list。
demo <- projection_demo(data, b = 1)
# 显示三个加权平方范数标量，检查勾股分解；单位是概率差平方。
cat("candidate norm squared =", demo$candidate_second_moment, "; projection =", demo$projection_second_moment, "; residual =", demo$residual_second_moment, "\n")
# 逐格相减后abs取绝对值，max把8项收缩为一个最大误差。
projection_error <- max(abs(demo$projection - demo$canonical))
# 显示投影与典范梯度的最大数值差；该练习使用固定g的模型。
cat("maximum projection error =", projection_error, "\n")
# 本练习的已知g五维模型与观察g未知七维模型不同；最终TMLE仍从数据学习g。
```

<details><summary>逐行解释：输入、输出、维度与数学式</summary>

<div class="r-line-card" data-r-line="4">

#### R第4行

```r
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
```

<p>输入：本行定义的常量或程序环境。输出：<code>script_argument</code> · character vector · 路径或参数字符串。</p>

commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。

</div>

<div class="r-line-card" data-r-line="6">

#### R第6行

```r
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
```

<p>输入：本行定义的常量或程序环境。输出：<code>source_files</code> · character vector · 路径或参数字符串。</p>

sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。

</div>

<div class="r-line-card" data-r-line="8">

#### R第8行

```r
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch06.R")
```

<p>输入：<code>source_files</code> · character vector · 路径或参数字符串；<code>script_argument</code> · character vector · 路径或参数字符串。输出：<code>script_path</code> · character vector · 路径或参数字符串。</p>

if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。

</div>

<div class="r-line-card" data-r-line="10">

#### R第10行

```r
stopifnot(length(script_path) == 1L, !is.na(script_path))
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。

</div>

<div class="r-line-card" data-r-line="12">

#### R第12行

```r
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：<code>project_root</code> · character vector · 路径或参数字符串。</p>

dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。

</div>

<div class="r-line-card" data-r-line="14">

#### R第14行

```r
source(file.path(project_root, "shared", "R", "RHCCase.R"))
```

<p>输入：<code>project_root</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。

</div>

<div class="r-line-card" data-r-line="16">

#### R第16行

```r
data <- rhc_data()
```

<p>输入：本行定义的常量或程序环境。输出：<code>data</code> · list · 命名容器；各成员按自身维度。</p>

从同一官方CSV计算各观测组合的概率及经验模型，输出list；后续所有数值由输入记录决定。

</div>

<div class="r-line-card" data-r-line="18">

#### R第18行

```r
demo <- projection_demo(data, b = 1)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度。输出：<code>demo</code> · list · 命名容器；各成员按自身维度。</p>

在本练习固定经验g，b设候选附加分量系数；手工加权线性代数投影返回list。

$$
f=D+b(A-g(X))
$$


</div>

<div class="r-line-card" data-r-line="20">

#### R第20行

```r
cat("candidate norm squared =", demo$candidate_second_moment, "; projection =", demo$projection_second_moment, "; residual =", demo$residual_second_moment, "\n")
```

<p>输入：<code>demo</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

显示三个加权平方范数标量，检查勾股分解；单位是概率差平方。

$$
\lVert f\rVert^2=\lVert\Pi f\rVert^2+\lVert f-\Pi f\rVert^2
$$


</div>

<div class="r-line-card" data-r-line="22">

#### R第22行

```r
projection_error <- max(abs(demo$projection - demo$canonical))
```

<p>输入：<code>demo</code> · list · 命名容器；各成员按自身维度。输出：<code>projection_error</code> · numeric scalar (double) · 长度1。</p>

逐格相减后abs取绝对值，max把8项收缩为一个最大误差。

</div>

<div class="r-line-card" data-r-line="24">

#### R第24行

```r
cat("maximum projection error =", projection_error, "\n")
```

<p>输入：<code>projection_error</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

显示投影与典范梯度的最大数值差；该练习使用固定g的模型。

</div>

</details>

</div>



<details><summary>允许g变化后，EIF会改变吗？</summary>

全模型的七维均值零空间内，梯度代表唯一；固定g后可添加T正交补中的分量，但EIF仍是投影。对本ATE形式，D*本来没有处理score分量，所以这两个模型中该ATE的EIF及其方差相同。若固定Q而只允许pX和g变化，典范梯度则只剩$\tau(X)-\psi$；模型约束通过合法方向影响典范梯度。

</details>

## 接下来将EIF连接到估计误差与方差

已用真实经验权重完成模型约束、投影与最小范数论证。下一讲从熟悉的样本均值出发，建立梯度与估计误差的联系，并说明它所需的条件。


---

# 第 7 章：EIF怎样进入估计误差和效率界？

前六讲研究“分布改变时目标怎样变”。研究者用一份样本估计固定的真实目标。本讲把分布梯度连接到估计误差，并说明何时EIF方差才可称效率下界。

## 1. 将均值估计误差精确写成IF的平均

假设$Y_1,\ldots,Y_n$独立同分布（independent and identically distributed，iid），真实风险$\mu_0=\mathbb E_0Y$。逐项减去同一个均值：

$$
\begin{aligned}
\widehat\mu-\mu_0&=\frac1n\sum_iY_i-\frac1n\sum_i\mu_0\\
&=\frac1n\sum_i(Y_i-\mu_0).
\end{aligned}
$$

> **符号回看：** n次相同μ0的平均仍是μ0；括号正是第一讲得到的均值IF。这里以未知真均值为中心，右边表示估计值与真值之差；改以样本均值为中心时，另有$n^{-1}\sum_i(Y_i-\widehat\mu)=0$。

这是精确展开；一般目标通常还多一个剩余项（remainder）。RHC的5735人给出当前样本风险1918/5735，真实总体风险仍未知，因此真实估计误差保留未知项。

## 2. 何时能用IF的平均近似一般估计量的误差？

渐近线性（asymptotic linearity）表示某一估计量满足：

$$
\widehat\psi-\psi_0=\frac1n\sum_i\phi_0(O_i)+r_n,
\quad\mathbb E_0\phi_0=0,\quad
r_n=o_P(n^{-1/2}).
$$

> **符号回看：** $\phi_0$是估计量的影响函数，$\psi_0$是总体目标；$o_P(n^{-1/2})$意味着乘$\sqrt n$后依概率趋于0。仅仅$r_n\to0$还不够，必须比主要抽样误差的$1/\sqrt n$尺度更小。

例如$1/n$乘$\sqrt n$后趋0，而$1/\sqrt n$乘后恒为1；两者虽都趋0，只有前者可在一阶误差中忽略。对具体估计量，需要证明上述余项要求成立。第8讲会展示二阶余项如何要求Q、g的拟合误差共同足够小。

## 3. 为什么方差除以n？

独立观测的零均值贡献相加，交叉协方差为0，因此：

$$
\operatorname{Var}_0\left(\frac1n\sum_i\phi_0(O_i)\right)
=\frac1{n^2}\sum_i\operatorname{Var}_0(\phi_0)
=\frac{\operatorname{Var}_0(\phi_0)}n.
$$

> **符号回看：** 方差（variance）先按权重平方缩放；n项各有相同方差，得到n/n²。标准误（standard error，SE）是方差开方，所以样本量四倍时一阶SE减半。

有限二阶矩与适当条件下，中心极限定理（central limit theorem，CLT）使$\sqrt n(\widehat\psi-\psi_0)$趋于均值0、方差$\mathbb E_0\phi_0^2$的正态分布。医院聚类等抽样依赖则需要使用相应的方差理论。

## 4. 效率下界适用于哪类估计量？

正则（regular）估计量要求在局部平滑扰动下有稳定的一阶行为，排除只在某个孤立分布表现异常好的规则。对正则渐近线性估计量，影响函数φ必须代表目标的所有路径导数。于是第6讲的投影给出：

$$
\phi=D^*+u,\quad u\perp T,\qquad
\mathbb E\phi^2=\mathbb E(D^*)^2+\mathbb E u^2\ge\mathbb E(D^*)^2.
$$

> **符号回看：** D*为给定统计模型的典范梯度，u为与全部合法方向正交的剩余分量。范数分解转成方差，是因为相关函数都中心化。效率界（efficiency bound）衡量这类正则估计量的一阶方差；有限样本的均方误差还受偏差和高阶项影响。

所以$\operatorname{Var}_0(D^*)/n$进入估计误差，前提是φ能达到D*且余项够小。实际资料中D*未知，要用一致拟合的函数估计。

## 5. 分解风险差EIF的方差

第4讲$D^*=D_X+D_Y$；条件残差均值零使交叉项消失。二元Y的条件方差为Q(1−Q)。先按实际处理概率分两臂平均，平方权重中有一个概率会约去：

$$
\begin{aligned}
\mathbb E[D_Y^2\mid X]&=g\frac{Q_1(1-Q_1)}{g^2}+(1-g)\frac{Q_0(1-Q_0)}{(1-g)^2}\\
&=\frac{Q_1(1-Q_1)}g+\frac{Q_0(1-Q_0)}{1-g}.
\end{aligned}
$$

> **符号回看：** 此处$Q_a=Q(a,X)$，g=g(X)；前面的g及1−g是实际两臂出现概率，平方分母来自H²。最后再对X平均，得到：

$$
V(P)=\operatorname{Var}_P\{Q(1,X)-Q(0,X)\}
+\mathbb E_P\left[\frac{Q(1,X)[1-Q(1,X)]}{g(X)}
+\frac{Q(0,X)[1-Q(0,X)]}{1-g(X)}\right].
$$

> **符号回看：** V是单个梯度贡献的方差系数，单位为概率差平方；再除以n得到估计量的一阶方差尺度。g越接近边界，少见处理下的信息越少，倒数项可能增大；目标本身可以保持不变。

<div class="lab" data-lab="7"></div>

先预测：只把n增为四倍，V、目标和SE各怎样变？

<details><summary>答案与理由</summary>

参考分布不变，V和目标不变；V/n为原来的四分之一，SE为一半。实验中的曲线固定真实经验表的pX、Q，虚拟改变g，用于比较给定参考模型下的理论信息量。

</details>

## 6. 为初始拟合的影响值计算经验方差

第4讲初始Q仅按A拟合，其拟合影响值F样本平均不必为0。沿用第0章的经验方差定义：先减去样本平均，再平方并对$n=5735$人平均，分母仍为$n$，写成：

$$
P_n(F-P_nF)^2=P_nF^2-(P_nF)^2.
$$

> **符号回看：** $P_nf$表示对同一5735人的f值平均，$P_nF^2$先平方再平均；这与先平均再平方是两种运算。若换为饱和经验表处的D*，Q及目标值随之改变，因而得到另一条函数；本例的g仍沿用sex层内经验比例。

<div class="case-workbench" data-case-study="7"></div>
## 代码工作簿：输入、运算与输出

<div class="lesson-language-control"><label>本章代码语言 <select data-lesson-language><option value="julia">Julia运算</option><option value="r">R运算</option></select></label><span>使用同一份RHC数据与相同的数学目标</span></div>

<div class="lesson-code-panel" data-lesson-panel="julia">

运行前输入是[同一份RHC原始CSV](../shared/data/public/rhc/source.csv)。读取与拟合定义见[RHCCase.jl](../shared/julia/RHCCase.jl)，完整[本讲脚本](julia/rhc_lessons/ch07.jl)可编辑；所有脚本可从其他工作目录运行，只须保留zh/与shared/相对位置。

```sh
julia --startup-file=no --history-file=no zh/julia/rhc_lessons/ch07.jl
```

```julia
# 公开 RHC 队列：X=性别，A=是否 RHC，Y=30 日死亡；全部量由原始记录计算。
# 方差与SE的加权计算见EIFCase.jl的BEGIN_CH07段。
# 两套函数都按当前频数表平均，不能当作已知真实分布的效率界。
include(joinpath(@__DIR__, "..", "..", "..", "shared", "julia", "RHCCase.jl"))
using .RHCCase
using Printf

data = rhc_data()
initial_values = eif_values(data.initial_fit, data.cells)
initial_moments = if_variance(data, initial_values)
@printf("初始拟合函数：mean=%.8f，second_moment=%.8f，variance=%.8f，se=%.8f（%.4f个百分点）\n", initial_moments.mean, initial_moments.second_moment, initial_moments.variance, initial_moments.se, 100initial_moments.se)

saturated_values = eif_values(data.empirical_model, data.cells)
saturated_moments = if_variance(data, saturated_values)
@printf("饱和经验分布函数：mean=%.8f，second_moment=%.8f，variance=%.8f，se=%.8f（%.4f个百分点）\n", saturated_moments.mean, saturated_moments.second_moment, saturated_moments.variance, saturated_moments.se, 100saturated_moments.se)
println("两套都是当前表的经验量，不是已知真实分布的效率界，也不是一次样本的实际估计误差。")
println("第8讲更新Q后还要重新计算；这两套SE都不是更新后的SE。")
```


<details><summary>查看本讲数学函数的源码</summary>

下列函数由RHCCase复用，计数来自真实原文件；它们没有内置真实总体答案。

```julia
function if_variance(data, values=eif_values(data.empirical_model, data.cells))
    checked_vector(values, length(data.cells))
    mean = sum(c.p * values[i] for (i,c) in enumerate(data.cells))
    second_moment = sum(c.p * values[i]^2 for (i,c) in enumerate(data.cells))
    variance = sum(c.p * (values[i] - mean)^2 for (i,c) in enumerate(data.cells))
    (; mean, second_moment, variance, se=sqrt(variance / data.n))
end
```

</details>

</div>

<div class="lesson-code-panel" data-lesson-panel="r" hidden>

输入是[同一公开RHC原CSV](../shared/data/public/rhc/source.csv)。共享定义：[RHCCase.R](../shared/R/RHCCase.R)与[EIFCase.R](../shared/R/EIFCase.R)。[完整R脚本](R/ch07.R)使用base R，保留项目目录结构即可从任意工作目录运行。

```sh
Rscript --vanilla zh/R/ch07.R
```

```r
# 第7讲：经验IF方差与SE
# 输入：冻结的公开RHC原CSV；输出：本讲对象与终端核对值；仅使用base R。
# commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
# sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
# if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch07.R")
# length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。
stopifnot(length(script_path) == 1L, !is.na(script_path))
# dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
# source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。
source(file.path(project_root, "shared", "R", "RHCCase.R"))
# 从同一官方CSV计算各观测组合的概率及经验模型，输出list；后续所有数值由输入记录决定。
data <- rhc_data()
# 初始拟合Q/g在8种观测组合上的EIF值，输出8项向量。
initial_values <- eif_values(data$initial_fit, data$cells)
# 按当前格概率计算平均、二阶矩、中心方差及SE，返回list。
initial_moments <- if_variance(data, initial_values)
# 在完整经验分布饱和模型上计算8项EIF，区别于初始仅按A的Q。
saturated_values <- eif_values(data$empirical_model, data$cells)
# 同样概率加权得到第二套经验矩list。
saturated_moments <- if_variance(data, saturated_values)
# 按名称显示两套经验平均、二阶矩、方差、SE；不能当作已知P0效率界。
print(list(initial = initial_moments, saturated = saturated_moments))
# 两个概率差SE分别乘100换成百分点；方差换成百分点平方时乘10000。
cat("initial SE in percentage points =", 100 * initial_moments$se, "; saturated =", 100 * saturated_moments$se, "\n")
# 这些量不等于一次样本的实际估计误差；第8讲更新Q后须重新计算SE。
```

<details><summary>逐行解释：输入、输出、维度与数学式</summary>

<div class="r-line-card" data-r-line="4">

#### R第4行

```r
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
```

<p>输入：本行定义的常量或程序环境。输出：<code>script_argument</code> · character vector · 路径或参数字符串。</p>

commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。

</div>

<div class="r-line-card" data-r-line="6">

#### R第6行

```r
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
```

<p>输入：本行定义的常量或程序环境。输出：<code>source_files</code> · character vector · 路径或参数字符串。</p>

sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。

</div>

<div class="r-line-card" data-r-line="8">

#### R第8行

```r
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch07.R")
```

<p>输入：<code>source_files</code> · character vector · 路径或参数字符串；<code>script_argument</code> · character vector · 路径或参数字符串。输出：<code>script_path</code> · character vector · 路径或参数字符串。</p>

if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。

</div>

<div class="r-line-card" data-r-line="10">

#### R第10行

```r
stopifnot(length(script_path) == 1L, !is.na(script_path))
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。

</div>

<div class="r-line-card" data-r-line="12">

#### R第12行

```r
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：<code>project_root</code> · character vector · 路径或参数字符串。</p>

dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。

</div>

<div class="r-line-card" data-r-line="14">

#### R第14行

```r
source(file.path(project_root, "shared", "R", "RHCCase.R"))
```

<p>输入：<code>project_root</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。

</div>

<div class="r-line-card" data-r-line="16">

#### R第16行

```r
data <- rhc_data()
```

<p>输入：本行定义的常量或程序环境。输出：<code>data</code> · list · 命名容器；各成员按自身维度。</p>

从同一官方CSV计算各观测组合的概率及经验模型，输出list；后续所有数值由输入记录决定。

</div>

<div class="r-line-card" data-r-line="18">

#### R第18行

```r
initial_values <- eif_values(data$initial_fit, data$cells)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度。输出：<code>initial_values</code> · numeric vector · 长度8；按(x,a,y)格对齐。</p>

初始拟合Q/g在8种观测组合上的EIF值，输出8项向量。

</div>

<div class="r-line-card" data-r-line="20">

#### R第20行

```r
initial_moments <- if_variance(data, initial_values)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度；<code>initial_values</code> · numeric vector · 长度8；按(x,a,y)格对齐。输出：<code>initial_moments</code> · list · 命名容器；各成员按自身维度。</p>

按当前格概率计算平均、二阶矩、中心方差及SE，返回list。

$$
\widehat{\operatorname{var}}(D)=\sum_jp_j(D_j-\overline D)^2,\quad\widehat{SE}=\sqrt{\widehat{\operatorname{var}}(D)/n}
$$


</div>

<div class="r-line-card" data-r-line="22">

#### R第22行

```r
saturated_values <- eif_values(data$empirical_model, data$cells)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度。输出：<code>saturated_values</code> · numeric vector · 长度8；按(x,a,y)格对齐。</p>

在完整经验分布饱和模型上计算8项EIF，区别于初始仅按A的Q。

</div>

<div class="r-line-card" data-r-line="24">

#### R第24行

```r
saturated_moments <- if_variance(data, saturated_values)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度；<code>saturated_values</code> · numeric vector · 长度8；按(x,a,y)格对齐。输出：<code>saturated_moments</code> · list · 命名容器；各成员按自身维度。</p>

同样概率加权得到第二套经验矩list。

</div>

<div class="r-line-card" data-r-line="26">

#### R第26行

```r
print(list(initial = initial_moments, saturated = saturated_moments))
```

<p>输入：<code>initial_moments</code> · list · 命名容器；各成员按自身维度；<code>saturated_moments</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

按名称显示两套经验平均、二阶矩、方差、SE；不能当作已知P0效率界。

</div>

<div class="r-line-card" data-r-line="28">

#### R第28行

```r
cat("initial SE in percentage points =", 100 * initial_moments$se, "; saturated =", 100 * saturated_moments$se, "\n")
```

<p>输入：<code>initial_moments</code> · list · 命名容器；各成员按自身维度；<code>saturated_moments</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

两个概率差SE分别乘100换成百分点；方差换成百分点平方时乘10000。

</div>

</details>

</div>



<details><summary>何时能用经验标准误进行有效推断？</summary>

当前台面可复算给定函数的平均、二阶矩和中心方差。第8讲更新Q后，也要重新计算D。将这些经验计算用于有效推断，还需检查拟合函数收敛、余项速率、抽样依赖和临床识别条件；本课保留SE的计算练习，临床置信区间的覆盖率仍待验证。

</details>

## 接下来用AIPW和TMLE控制估计误差

已说明从均值精确展开到一般渐近线性条件，再到V/n、CLT和效率下界；代码可计算给定函数的经验矩。下一讲把这些条件连接到AIPW修正与TMLE更新，检查数值方程与剩余误差。


---

# 第 8 章：用同一真实队列手动完成AIPW与TMLE

现在从原始CSV出发，完成一次真实估计。前七讲已得到目标、EIF、方向验证、模型约束与误差桥梁；本章依次构造初始拟合、偏差校正和风险更新。先按sex分层手算，再对同一5735人扩展指定基线变量。本章沿着同一套统计目标完成计算；结果的因果解释使用第0章的识别条件。

## 1. 一阶展开为什么提示偏差校正？

令$P_0$为未知真实观测分布，$\psi_0=\Psi(P_0)$；帽子表示用样本拟合，$P_nf=n^{-1}\sum_i f(O_i)$为经验平均。初始代入估计为：

$$
\widehat\psi_{\rm plug}=\frac1n\sum_i[\widehat Q(1,W_i)-\widehat Q(0,W_i)].
$$

> **符号回看：** 每人W固定，分别预测A=1和0，两种预测各按同一n人平均，从而保持相同的基线构成。Q是拟合死亡概率，当前尚未更新。

分布梯度提示：初始拟合若留下目标方向残差，可以用拟合EIF的样本平均做一阶修正。因为中心化项按同一经验W平均恰好抵消，剩下：

$$
\widehat\psi_{\rm AIPW}=\widehat\psi_{\rm plug}
+\frac1n\sum_i\widehat H_i[Y_i-\widehat Q(A_i,W_i)],
\quad \widehat H_i=\frac{A_i}{\widehat g(W_i)}-\frac{1-A_i}{1-\widehat g(W_i)}.
$$

> **符号回看：** AIPW为增广逆概率加权（augmented inverse probability weighting），又称one-step修正。H来自第四讲商式，Y减Q为实际处理下残差。它修正最终数值，初始Q保留不变。

## 2. 从双重稳健性到有效推断，需要哪些条件？

先把拟合函数视为给定。设$e_a=\widehat Q_a-Q_{0a}$、$\delta g=\widehat g-g_0$。给定W，观测残差的平均为$-g_0e_1/\widehat g+(1-g_0)e_0/(1-\widehat g)$。初始条件差比真差多$e_1-e_0$。相加并合并系数：

$$
\begin{aligned}
B&=\mathbb E_0\left[e_1-e_0-\frac{g_0}{\widehat g}e_1+\frac{1-g_0}{1-\widehat g}e_0\right]\\
&=\mathbb E_0\left[\left(1-\frac{g_0}{\widehat g}\right)e_1+
\left(\frac{1-g_0}{1-\widehat g}-1\right)e_0\right]\\
&=\mathbb E_0\left[(\widehat g-g_0)
\left\{\frac{e_1}{\widehat g}+\frac{e_0}{1-\widehat g}\right\}\right].
\end{aligned}
$$

> **符号回看：** B定义为总体平均的AIPW表达式减真目标，涉及未知的P₀。当两臂的Q都正确，或g正确时，乘积为0。

双重稳健性（double robustness）来自这个全局乘积恒等式。Neyman正交性（Neyman orthogonality）描述真函数附近的局部导数：小的干扰函数（nuisance function）误差，其一阶效应为0。有效统计推断进一步要求余项比$n^{-1/2}$更小、拟合影响函数接近真EIF，并满足合适的抽样与经验过程条件。

例如两类误差长度都只按$n^{-1/4}$缩小，乘积是$n^{-1/2}$，还不能忽略；一类快一些才可能满足要求。交叉拟合（cross-fitting）用于控制训练依赖带来的经验过程项；临床混杂与原队列选择则由研究设计和识别假设处理。本章主效应回归展示完整计算，渐近条件需针对所选拟合方法论证。

## 3. TMLE为何改Q，而不直接加一个数？

TMLE保留同一目标规则，沿EIF指出的方向更新初始风险。定义logit（对数优势）及其反函数expit：

$$
\operatorname{logit}(q)=\log\frac q{1-q},\quad
\operatorname{expit}(u)=\frac1{1+e^{-u}},\quad
Q_\epsilon(a,w)=\operatorname{expit}\left[\operatorname{logit}\widehat Q(a,w)+\epsilon H_{\widehat g}(a,w)\right].
$$

> **符号回看：** 初始logit是固定偏置项（offset），系数固定为1；H为巧妙协变量（clever covariate），由EIF的残差权重确定；ε是本次更新唯一待估的新参数。a=0的H为负，a=1为正；两个预测都要更新。

更新中固定g、经验W分布和原始患者记录，只改变预测风险。expit将有限实数映射到0与1之间；实际运算若越过可表示的数值范围，程序会报告数值边界错误。

## 4. 用链式法则推导logistic更新的score

实际观察臂的线性预测为$\eta_i=\operatorname{logit}\widehat Q(A_i,W_i)+\epsilon\widehat H_i$，写$q_i=\operatorname{expit}(\eta_i)$。二元结局的平均对数似然（log likelihood）为：

$$
\ell_n(\epsilon)=\frac1n\sum_i[Y_i\log q_i+(1-Y_i)\log(1-q_i)].
$$

> **符号回看：** q_i只取每人实际A那一列，Y=1使用logq，Y=0使用log(1−q)。ε通过η再改变q。

先有$dq_i/d\eta_i=q_i(1-q_i)$及$d\eta_i/d\epsilon=H_i$，再逐层相乘：

$$
\begin{aligned}
\frac{d\ell_n}{d\epsilon}
&=\frac1n\sum_i\left[\frac{Y_i}{q_i}-\frac{1-Y_i}{1-q_i}\right]q_i(1-q_i)H_i\\
&=\frac1n\sum_i[Y_i(1-q_i)-(1-Y_i)q_i]H_i\\
&=\frac1n\sum_i[Y_i-Y_iq_i-q_i+Y_iq_i]H_i\\
&=\frac1n\sum_iH_i(Y_i-q_i)=s_n(\epsilon),\\
\frac{ds_n}{d\epsilon}&=-\frac1n\sum_iH_i^2q_i(1-q_i)<0.
\end{aligned}
$$

> **符号回看：** $s_n$是似然得分方程（score equation）中的函数，表示似然随ε变化的斜率。中间$-Y_iq_i+Y_iq_i$消掉，留下残差。负斜率说明存在有限根时唯一；根也是这条一维路径的似然最大点。

若$s_n(0)>0$，要增加ε使score下降。二分法（bisection）先找异号端点，试中点，正score时保留中点右侧、负时保留左侧。按sex分层的实验和多变量实验都允许逐次手动操作；自动求根只在你点击后执行。

## 5. 先用真实分组计数手算TMLE

四组offset是各实际处理臂初始死亡比例的logit；g由sex组人数估计。每组用人数nxa和死亡人数mxa汇总score：

$$
s_n(\epsilon)=\frac1{5735}\sum_{x,a}H(a,x)[m_{xa}-n_{xa}Q_\epsilon(a,x)].
$$

> **符号回看：** m为观察死亡人数，nxa乘Q为预测死亡人数，二者相减再乘H；除5735得到每记录平均。

先预测score的符号，再填ε，至少手动二分五次后才展开答案。根求出后重新标准化：$\widehat\psi_T=\sum_x\widehat p_X(x)[Q^*(1,x)-Q^*(0,x)]$，这里的$Q^*=Q_{\widehat\epsilon}$。

<div class="case-workbench" data-case-study="8"></div>

<details><summary>为何按sex分层计算的AIPW与TMLE结果相同？</summary>

按sex分层计算的结果约7.369212pp。因为g在两个sex层内用实际处理比例饱和估计，对任意Q，加权残差平均恰等于“饱和sex标准化差减当前plug-in差”。解score=0便使更新plug-in等于饱和标准化差；AIPW一步加校正也等于它。两种方法在此相同，来自饱和g的计数恒等式，适用于这里按sex分层的构造。sex标准化结果的临床解释仍使用第0章的识别条件。

</details>

## 6. 为同一批患者扩展基线变量并拟合模型

现在将sex单变量X扩展成基线向量W，继续使用同一数据与结局。使用原始age、sex、race和12项既往病史；这些列完整，无需删人或插补。年龄标准化，race以white作参考、另设black/other指示列；race沿用原数据记录的社会分类。总共17列含截距。初始g用这些列拟合RHC；Q再加实际A一列拟合死亡。

这里选择主效应logistic模型作初始拟合。迭代使用似然、梯度和信息矩阵，检查收敛、设计矩阵秩与概率范围。所选基线的临床依据及急性严重度的测量时序，按第0章研究方案另行评估。

### 逐列计算风险更新、加权残差与风险差

下方实验始终保留相同的原始行i和实际A/Y。先读当前步骤并预测，再点击“下一步”向右添加列；旧列保留。顺序是：三种初始预测 → g与H → 实际臂offset → εH与新logit → 更新概率 → 残差及score贡献 → 全A=0与全A=1各自的更新 → 同一人群平均 → 完整EIF。表格只截取6行便于核对，所有拟合、求根和平均都使用完整5735人。

每一步的可联动公式中，符号按钮都对应**相应的代码变量**和**同一数据列**。例如，$\epsilon H_{A,i}$对应`shift`列，初始logit对应`offset`，更新概率对应`qstar_a`。标量$\epsilon$、$n$和风险差各用一张参数或汇总卡表示。

> **符号回看：** offset固定为初始预测的logit；H由初始g和指定处理水平给出；ε是全体共用的新参数。实际臂更新用于估计ε，两臂更新用于最终标准化。代码变量`qstar_a`在试探阶段表示当前$Q_\epsilon$；求根完成后，相应更新才记为$Q^*$。

<div class="rhc-full" data-rhc-full></div>

先走到“残差与score贡献”，观察初始score；手填0.003和0.004，记录符号，再二分。Q更新后，为**每位患者**分别计算两种处理下的更新预测，得到5735个差值，再对整列平均。

<details><summary>核对扩展基线变量后的估计结果</summary>

指定模型下，初始plug-in约8.649886pp，AIPW约8.996800pp；ε约0.003576966663，TMLE约8.997972pp，平均score约−3.4×10⁻¹³。g范围约0.078698—0.681905，未作截断。网页计算与Julia、R独立实现对未舍入结果作交叉核对。

这些数值估计的是指定统计泛函。与按sex分层计算的结果的差异，反映调整集合及初始模型的改变。临床因果解释还需论证调整充分性及第0章的研究设计假设。

</details>

## 7. 为什么经验EIF方程归零？还有哪些误差？

重新代入的定义让$P_n[Q^*(1,W)-Q^*(0,W)-\widehat\psi_T]=0$；targeting让$P_n[H(Y-Q^*)]\approx0$。两项相加，所以完整拟合EIF的样本平均接近0；各条记录仍保留自己的残差。

在拟合函数相应的偏差恒等式下：

$$
\widehat\psi_T-\psi_0=(P_n-P_0)\widehat D^*+B(Q^*,\widehat g)-P_n\widehat D^*.
$$

> **符号回看：** 第一项是经验平均减总体平均，第二项仍是上节误差乘积、只是Q已更新。精确解的最后一项为0，才可省略；数值解须保留其求根容差。第二项的大小由Q与g的拟合误差共同决定。进一步将第一项换成$(P_n-P_0)D_0^*$，还需控制两个函数之差的经验过程。

更新后的经验方差和SE按第7讲重新计算。有效临床置信区间还需满足上述渐近条件与第0章的识别条件；TMLE与AIPW的有限样本误差也需另作比较。首日RHC窗、48小时选择及处理版本按第0章协议解释。

## 用代码复算初始拟合、风险更新与二分求根

<div class="lesson-language-control"><label>本章代码语言 <select data-lesson-language><option value="julia">Julia运算</option><option value="r">R运算</option></select></label><span>使用同一份RHC数据与相同的数学目标</span></div>

<div class="lesson-code-panel" data-lesson-panel="julia">


[逐列工作簿](julia/tmle_trace.jl)对应上面同一张表：从原CSV读取开始，逐行构建所有中间列。默认ε=0；可从环境变量传入试探幅度，脚本不会替你自动求根。图下的“本步Julia”和“完整逐列工作簿”均读取实际源码，逐行解释输入、输出、维度、广播（broadcast）与数学式。

```sh
julia --startup-file=no --history-file=no zh/julia/tmle_trace.jl
TMLE_EPSILON=0.003 julia --startup-file=no --history-file=no zh/julia/tmle_trace.jl
```

`TMLE_EPSILON`先作为字符串传入，`parse(Float64, ...)`把它转为一个数；没有设置时用0。`.*`、`./`、`.-`分别逐项乘、除、减；例如`offset .+ shift`仍输出n项向量，`sum(contrast) / n`才收缩成一个风险差标量。`expit.(eta)`逐项把更新后的logit转回概率；前面的`offset`来自预测概率`qa`的logit。屏幕中的小数会舍入，工作簿和断言使用未舍入值。

原第8讲脚本仍先按sex分层计算，再跑同一原CSV的多变量版本；脚本输出输入维数、g范围、初始score、前五次二分的中点/score及最终ε、更新风险差；网页另列offset、H和保留区间，完整模块保存相应计算。最终自动核对使用同一方程，不调用TMLE软件包。[完整模块](../shared/julia/RHCCase.jl)中`BEGIN_FULL_BASELINE`与`BEGIN_FULL_TARGET`保留实际拟合及更新源码。

运行前输入是[同一份RHC原始CSV](../shared/data/public/rhc/source.csv)。读取与拟合定义见[RHCCase.jl](../shared/julia/RHCCase.jl)，完整[本讲脚本](julia/rhc_lessons/ch08.jl)可编辑；所有脚本可从其他工作目录运行，只须保留zh/与shared/相对位置。

```sh
julia --startup-file=no --history-file=no zh/julia/rhc_lessons/ch08.jl
```

```julia
# 公开 RHC 队列：X=性别，A=是否 RHC，Y=30 日死亡；全部量由原始记录计算。
# BEGIN_CH08核心段给出expit、score、四组更新、二分与失败检查的全部定义。
# 本脚本显式手动试epsilon，再逐次缩小括号；没有调用TMLE软件包。
include(joinpath(@__DIR__, "..", "..", "..", "shared", "julia", "RHCCase.jl"))
using .RHCCase
using Printf

function manual_tmle(data; lo=-1.0, hi=1.0, tolerance=1e-12, maxiter=200)
    # 每次score都是Σ组 H×(观察事件−预测事件)/总人数。
    for epsilon in (0.0, 0.1, 0.2)
        @printf("手动epsilon=%.3f: score=%+.9f\n", epsilon, fluctuation_score(data, epsilon).score)
    end
    fluctuation_score(data, lo).score >= 0 && fluctuation_score(data, hi).score <= 0 ||
        error("起始括号没有夹住score根")
    for iteration in 1:maxiter
        step = bisection_step(data, lo, hi)
        if iteration <= 5
            @printf("二分%d: epsilon=%.9f, score=%+.9f\n", iteration, step.midpoint, step.score)
        end
        if abs(step.score) <= tolerance
            # case_at逐组计算expit(offset+epsilon×H)，再按经验X比例平均。
            result = case_at(data, step.midpoint)
            for group in result.groups
                @printf("x=%d,a=%d: Qstar=%.12f, score贡献=%+.12f\n", group.x, group.a, group.q_updated, group.score_contribution)
            end
            @printf("epsilon=%.12f，性别标准化风险差=%.12f，经验EIF平均=%.3g，SE=%.9f\n", result.epsilon, result.estimate, result.eif_mean, result.se)
            return result
        end
        step.midpoint != lo && step.midpoint != hi || error("二分因浮点精度停止")
        lo, hi = step.lo, step.hi
    end
    error("达到最大迭代数，尚未得到满足容差的score根")
end

data = rhc_data()
manual_tmle(data)

println("此处仅按性别标准化，未建立充分混杂控制；结果不作为 RHC 临床因果效应。")

# 同一批5735位患者，最后把X从性别扩展为事先列出的17列基线设计。
# 逻辑回归的Newton步骤、似然回溯见RHCCase.jl的BEGIN_FULL_BASELINE。
# 逐人更新及score见BEGIN_FULL_TARGET；仍然没有使用TMLE或回归软件包。
function manual_baseline_tmle(fit; lo=-0.25, hi=0.25, tolerance=1e-12, maxiter=200)
    println("扩展基线列 = ", fit.feature_names)
    println("年龄标准化：均值=", fit.age_mean, "，总体标准差=", fit.age_sd)
    println("g最小/最大=", extrema(fit.g), "；没有截断或填补")
    initial = full_at(fit, 0.0)
    @printf("扩展基线初始风险差=%+.9f；AIPW=%+.9f；score=%+.9f\n", initial.estimate, initial.aipw, initial.score)
    for epsilon in (0.0, 0.002, 0.004)
        state = full_at(fit, epsilon)
        @printf("逐人试epsilon=%.3f：score=%+.9f，平均对数似然=%.9f\n", epsilon, state.score, state.log_likelihood)
    end
    for iteration in 1:maxiter
        step = full_bisection_step(fit, lo, hi)
        if iteration <= 5
            @printf("扩展基线二分%d：epsilon=%.9f，score=%+.9f\n", iteration, step.midpoint, step.score)
        end
        if abs(step.score) <= tolerance
            state = full_at(fit, step.midpoint)
            @printf("扩展基线epsilon=%.12f：risk0=%.9f，risk1=%.9f\n", state.epsilon, state.risk0, state.risk1)
            @printf("TMLE风险差=%+.9f；score=%.3g；经验EIF均值=%.3g；经验SE=%.9f\n", state.estimate, state.score, state.eif_mean, state.se)
            return state
        end
        step.midpoint != lo && step.midpoint != hi || error("扩展基线二分因浮点精度停止")
        lo, hi = step.lo, step.hi
    end
    error("扩展基线二分未在最大迭代数内收敛")
end

full_fit = prepare_full(read_rhc_rows())
manual_baseline_tmle(full_fit)
println("扩展基线模型仍省略急性病情严重程度；充分混杂控制与选择机制假设未被数据证明。")
println("经验SE只描述当前模型的渐近推导，不保证置信区间覆盖或临床因果识别。")
```


<details><summary>查看本讲数学函数的源码</summary>

下列函数由RHCCase复用，计数来自真实原文件；它们没有内置真实总体答案。

```julia
function expit(z::Real)
    isfinite(z) || throw(ArgumentError("Finite log odds required"))
    z >= 0 ? 1 / (1 + exp(-z)) : exp(z) / (1 + exp(z))
end
function logit(q::Real)
    isfinite(q) && 0 < q < 1 || throw(ArgumentError("Probability must be strictly interior"))
    log(q) - log1p(-q)
end
softplus(z) = max(z, zero(z)) + log1p(exp(-abs(z)))

# 组结果的H与offset在更新阶段才补充，第3讲计数汇总不依赖它们。
function fluctuation_groups(data)
    [merge(group, (h=clever_h(data.initial_fit, group.a, group.x),
                   offset=logit(group.initial_q))) for group in data.groups]
end

# 平均条件对数似然、score及其导数，均只依赖观察组计数。
function fluctuation_score(data, epsilon::Real)
    isfinite(epsilon) || throw(ArgumentError("Finite fluctuation parameter required"))
    score = 0.0; slope = 0.0; log_likelihood = 0.0
    for group in fluctuation_groups(data)
        eta = group.offset + epsilon * group.h
        isfinite(eta) || throw(ArgumentError("Updated log odds are not representable"))
        q = expit(eta)
        score += group.h * (group.events - group.n * q) / data.n
        slope -= group.n * group.h^2 * q * (1 - q) / data.n
        log_likelihood -= (group.events * softplus(-eta) +
                           (group.n - group.events) * softplus(eta)) / data.n
    end
    all(isfinite, (score, slope, log_likelihood)) ||
        throw(ArgumentError("Fluctuation summary is not representable"))
    (; score, slope, log_likelihood)
end

function case_at(data, epsilon::Real=0.0)
    state = fluctuation_score(data, epsilon)
    q = similar(data.initial_fit.q)
    groups = map(fluctuation_groups(data)) do group
        updated_q = expit(group.offset + epsilon * group.h)
        0 < updated_q < 1 || throw(ArgumentError("Updated Q reached a floating-point endpoint"))
        q[group.a+1,group.x+1] = updated_q
        predicted_events = group.n * updated_q
        residual_total = group.events - predicted_events
        weighted_residual = group.h * residual_total
        merge(group, (; q_updated=updated_q, predicted_events, residual_total,
                       weighted_residual, score_contribution=weighted_residual / data.n))
    end
    updated_fit = (px=copy(data.initial_fit.px), g=copy(data.initial_fit.g), q=q)
    estimate = ate(updated_fit)
    values = eif_values(updated_fit, data.cells; estimate)
    moments = if_variance(data, values)
    eif_rows = [merge(c, (d=values[i],)) for (i,c) in enumerate(data.cells)]
    (; data, epsilon=Float64(epsilon), groups, state.score, state.slope, state.log_likelihood,
       updated_fit, estimate, aipw=estimate + state.score, eif_rows,
       eif_mean=moments.mean, eif_second_moment=moments.second_moment,
       eif_variance=moments.variance, se=moments.se)
end

function checked_bracket(data, lo, hi)
    isfinite(lo) && isfinite(hi) && lo < hi || throw(ArgumentError("Finite increasing bracket required"))
    slo = fluctuation_score(data, lo).score
    shi = fluctuation_score(data, hi).score
    slo >= 0 && shi <= 0 || throw(ArgumentError("Bracket must contain the decreasing score root"))
    (; lo=Float64(lo), hi=Float64(hi), slo, shi)
end

function bisection_step(data, lo::Real, hi::Real)
    bracket = checked_bracket(data, lo, hi)
    midpoint = bracket.lo / 2 + bracket.hi / 2
    score = fluctuation_score(data, midpoint).score
    new_lo = score > 0 ? midpoint : bracket.lo
    new_hi = score < 0 ? midpoint : bracket.hi
    score == 0 && (new_lo = new_hi = midpoint)
    (; midpoint, score, lo=new_lo, hi=new_hi)
end

function solve_case(data; lo::Real=-1.0, hi::Real=1.0, score_tol::Real=1e-12, maxiter::Integer=200)
    isfinite(score_tol) && 0 < score_tol <= 1e-6 || throw(ArgumentError("Use a positive score tolerance at most 1e-6"))
    maxiter > 0 || throw(ArgumentError("Positive maximum iteration count required"))
    bracket = checked_bracket(data, lo, hi)
    lo, hi = bracket.lo, bracket.hi
    for (epsilon, score) in ((lo, bracket.slo), (hi, bracket.shi))
        if abs(score) <= score_tol
            return merge(case_at(data, epsilon), (converged=true, iterations=0, reason="score_tolerance"))
        end
    end
    for iterations in 1:maxiter
        step = bisection_step(data, lo, hi)
        if abs(step.score) <= score_tol
            return merge(case_at(data, step.midpoint), (; converged=true, iterations, reason="score_tolerance"))
        end
        if step.midpoint == lo || step.midpoint == hi
            return merge(case_at(data, step.midpoint), (; converged=false, iterations, reason="floating_point_stagnation"))
        end
        lo, hi = step.lo, step.hi
    end
    merge(case_at(data, lo / 2 + hi / 2), (converged=false, iterations=Int(maxiter), reason="maximum_iterations"))
end
```

</details>



</div>

<div class="lesson-code-panel" data-lesson-panel="r" hidden>

输入是[同一公开RHC原CSV](../shared/data/public/rhc/source.csv)。共享定义：[RHCCase.R](../shared/R/RHCCase.R)与[EIFCase.R](../shared/R/EIFCase.R)。[完整R脚本](R/ch08.R)使用base R，保留项目目录结构即可从任意工作目录运行。

```sh
Rscript --vanilla zh/R/ch08.R
```

```r
# 第8讲：AIPW与显式手动二分TMLE
# 输入：冻结的公开RHC原CSV；输出：本讲对象与终端核对值；仅使用base R。
# commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
# sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
# if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch08.R")
# length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。
stopifnot(length(script_path) == 1L, !is.na(script_path))
# dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
# source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。
source(file.path(project_root, "shared", "R", "RHCCase.R"))
# 从同一官方CSV计算各观测组合的概率及经验模型，输出list；后续所有数值由输入记录决定。
data <- rhc_data()
# 依次手动试探三个epsilon标量，for仅查看score，不自动求根。
for (epsilon in c(0, 0.1, 0.2)) {
# 用固定初始offset和H计算每个试探幅度的经验score标量。
  cat("trial epsilon =", epsilon, "; score =", fluctuation_score(data, epsilon)$score, "\n")
# 结束手动试探循环；初始数据和模型不变。
}
# 设定按sex分层计算的求根区间的下端点标量。
lo <- -1
# 设定按sex分层计算的求根区间的上端点标量。
hi <- 1
# 设置score绝对值容差，不把近似零写成精确零。
tolerance <- 1e-12
# 先核对非增score在区间两端夹住根；不满足则停止。
stopifnot(fluctuation_score(data, lo)$score >= 0, fluctuation_score(data, hi)$score <= 0)
# NULL标记求根结果尚待计算；成功后保存更新对象。
targeted <- NULL
# 最多200次显式二分，每次计算一个区间中点。
for (iteration in 1:200) {
# 共享纯函数返回midpoint、score以及缩小后的lo/hi。
  step <- bisection_step(data, lo, hi)
# 显示前5次二分以便核对，全部迭代仍按相同规则计算。
  if (iteration <= 5) cat("bisection", iteration, "; epsilon =", step$midpoint, "; score =", step$score, "\n")
# abs取score绝对值；达到预定容差才进入成功分支。
  if (abs(step$score) <= tolerance) {
# 用已求出的中点更新四组Q，按经验X比例标准化，并计算完整经验EIF与SE。
    targeted <- case_at(data, step$midpoint)
# break退出最近一层for循环，保留合格targeted对象。
    break
# 结束收敛判断分支。
  }
# 防止浮点中点等于端点时继续假装缩小区间。
  stopifnot(step$midpoint != lo, step$midpoint != hi)
# 以score符号确定的新下界替换旧下界。
  lo <- step$lo
# 以score符号确定的新上界替换旧上界。
  hi <- step$hi
# 结束二分循环；未收敛时targeted仍为NULL。
}
# 达到迭代上限仍无合格结果时显式失败，不输出伪收敛。
if (is.null(targeted)) stop("Eight-cell bisection did not converge")
# 显示4组更新Q与score贡献，同一x的两臂按原经验X权重标准化。
print(targeted$groups)
# 显示按sex分层的TMLE风险差、容差内经验EIF平均与SE；只按性别标准化。
cat("eight-cell epsilon =", targeted$epsilon, "; estimate =", targeted$estimate, "; EIF mean =", targeted$eif_mean, "; SE =", targeted$se, "\n")
# 重新读取同一5735人原记录，扩展调整变量时不换队列。
rows <- read_rhc_rows(DEFAULT_SOURCE)
# 构建固定顺序的n×17基线design，拟合g及n×18的Q；年龄分母n、white参考、无正则或隐式截断。
fit <- prepare_full(rows)
# epsilon=0保留初始预测，返回初始标准化风险差、AIPW与经验score。
initial <- full_at(fit, 0)
# 显示设计列和年龄标准化参数，读者可以核对固定调整集。
cat("baseline columns =", fit$feature_names, "; age mean =", fit$age_mean, "; age SD =", fit$age_sd, "\n")
# range显示全部n项g的最小和最大；区分初始plug-in、AIPW及score。
cat("g range =", range(fit$g), "; initial =", initial$estimate, "; AIPW =", initial$aipw, "; score =", initial$score, "\n")
# 对完整基线模型手动试探三个幅度，随后通过二分寻找根。
for (epsilon in c(0, 0.002, 0.004)) {
# 逐人计算固定offset加epsilon×H的更新、score和平均对数似然。
  trial <- full_at(fit, epsilon)
# 显示同一完整5735人平均score和对数似然，分母为全部人数。
  cat("full trial epsilon =", epsilon, "; score =", trial$score, "; log likelihood =", trial$log_likelihood, "\n")
# 结束完整基线手动试探。
}
# 设置完整基线score二分下界。
lo <- -0.25
# 设置完整基线score二分上界。
hi <- 0.25
# 确认完整基线非增score夹住根，失败明确停止。
stopifnot(full_at(fit, lo)$score >= 0, full_at(fit, hi)$score <= 0)
# 以NULL表示还没有达到容差的完整基线结果。
full_targeted <- NULL
# 开始最多200次完整基线手动二分。
for (iteration in 1:200) {
# 在同一fit上计算中点score及更新区间，保留全部初始Q/g。
  step <- full_bisection_step(fit, lo, hi)
# 显示前5次逐人二分的中点与score，便于手工核对。
  if (iteration <= 5) cat("full bisection", iteration, "; epsilon =", step$midpoint, "; score =", step$score, "\n")
# 同一个预设1e−12容差检查完整n人score。
  if (abs(step$score) <= tolerance) {
# 仅在求根后命名为targeted；两臂更新共用同一epsilon并对同一n人标准化。
    full_targeted <- full_at(fit, step$midpoint)
# 退出完整基线二分循环。
    break
# 结束完整基线收敛分支。
  }
# 浮点中点无法继续缩小时立即停止，避免假收敛。
  stopifnot(step$midpoint != lo, step$midpoint != hi)
# 保留含根的新下界标量。
  lo <- step$lo
# 保留含根的新上界标量。
  hi <- step$hi
# 结束完整基线二分循环。
}
# 迭代耗尽时明确报错；合格结果以score容差为准。
if (is.null(full_targeted)) stop("Full baseline bisection did not converge")
# 分别显示求根幅度、两臂全部n人平均风险和标准化风险差。
cat("full epsilon =", full_targeted$epsilon, "; risk0 =", full_targeted$risk0, "; risk1 =", full_targeted$risk1, "; TMLE =", full_targeted$estimate, "\n")
# 分别显示似然score、完整EIF平均和经验SE；有限样本和推断条件见本章技术说明。
cat("full score =", full_targeted$score, "; EIF mean =", full_targeted$eif_mean, "; empirical SE =", full_targeted$se, "\n")
# 完整基线仍省略急性病情严重程度；充分混杂控制与选择机制假设未由数据证明。
```

<details><summary>逐行解释：输入、输出、维度与数学式</summary>

<div class="r-line-card" data-r-line="4">

#### R第4行

```r
script_argument <- grep("^--file=", commandArgs(FALSE), value = TRUE)
```

<p>输入：本行定义的常量或程序环境。输出：<code>script_argument</code> · character vector · 路径或参数字符串。</p>

commandArgs(FALSE)读取启动参数，grep按^匹配开头，value=TRUE保留字符串。输出零项或一项字符向量，定位Rscript当前文件。

</div>

<div class="r-line-card" data-r-line="6">

#### R第6行

```r
source_files <- vapply(sys.frames(), function(frame) if (is.null(frame$ofile)) "" else frame$ofile, character(1))
```

<p>输入：本行定义的常量或程序环境。输出：<code>source_files</code> · character vector · 路径或参数字符串。</p>

sys.frames()读取调用环境；vapply逐个返回长度1字符。被source()调用时ofile记录当前脚本路径；没有路径的环境返回空串。

</div>

<div class="r-line-card" data-r-line="8">

#### R第8行

```r
script_path <- if (any(nzchar(source_files))) tail(source_files[nzchar(source_files)], 1) else if (length(script_argument)) sub("^--file=", "", script_argument[1]) else file.path("zh", "R", "ch08.R")
```

<p>输入：<code>source_files</code> · character vector · 路径或参数字符串；<code>script_argument</code> · character vector · 路径或参数字符串。输出：<code>script_path</code> · character vector · 路径或参数字符串。</p>

if选择来源：source()时取最后一个非空ofile，否则去掉--file=前缀。在项目根R控制台直接运行时，默认使用本讲脚本位置；输出一个路径字符串，[]索引从1开始。

</div>

<div class="r-line-card" data-r-line="10">

#### R第10行

```r
stopifnot(length(script_path) == 1L, !is.na(script_path))
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

length检查路径只有一项；1L是整数1，!is.na排除缺失。stopifnot要求所有条件为TRUE，否则停止。

</div>

<div class="r-line-card" data-r-line="12">

#### R第12行

```r
project_root <- normalizePath(file.path(dirname(script_path), "..", ".."), mustWork = TRUE)
```

<p>输入：<code>script_path</code> · character vector · 路径或参数字符串。输出：<code>project_root</code> · character vector · 路径或参数字符串。</p>

dirname取脚本目录；file.path向上两层拼接项目根，normalizePath要求目录存在。路径不依赖当前工作目录。

</div>

<div class="r-line-card" data-r-line="14">

#### R第14行

```r
source(file.path(project_root, "shared", "R", "RHCCase.R"))
```

<p>输入：<code>project_root</code> · character vector · 路径或参数字符串。输出：执行检查、显示或控制流程。</p>

source读取并执行共享R定义，提供实际CSV读取、纯数学函数与手动拟合器。仅使用base R，无需安装TMLE软件包。

</div>

<div class="r-line-card" data-r-line="16">

#### R第16行

```r
data <- rhc_data()
```

<p>输入：本行定义的常量或程序环境。输出：<code>data</code> · list · 命名容器；各成员按自身维度。</p>

从同一官方CSV计算各观测组合的概率及经验模型，输出list；后续所有数值由输入记录决定。

</div>

<div class="r-line-card" data-r-line="18">

#### R第18行

```r
for (epsilon in c(0, 0.1, 0.2)) {
```

<p>输入：本行定义的常量或程序环境。输出：<code>epsilon</code> · numeric scalar (double) · 长度1。</p>

依次手动试探三个epsilon标量，for仅查看score，不自动求根。

</div>

<div class="r-line-card" data-r-line="20">

#### R第20行

```r
  cat("trial epsilon =", epsilon, "; score =", fluctuation_score(data, epsilon)$score, "\n")
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度；<code>epsilon</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

用固定初始offset和H计算每个试探幅度的经验score标量。

$$
s_n(\epsilon)=\sum_jp_jH_j(y_j-Q_{\epsilon,j})
$$


</div>

<div class="r-line-card" data-r-line="22">

#### R第22行

```r
}
```

<p>输入：本行定义的常量或程序环境。输出：执行检查、显示或控制流程。</p>

结束手动试探循环；初始数据和模型不变。

</div>

<div class="r-line-card" data-r-line="24">

#### R第24行

```r
lo <- -1
```

<p>输入：本行定义的常量或程序环境。输出：<code>lo</code> · numeric scalar (double) · 长度1。</p>

设定按sex分层计算的求根区间的下端点标量。

</div>

<div class="r-line-card" data-r-line="26">

#### R第26行

```r
hi <- 1
```

<p>输入：本行定义的常量或程序环境。输出：<code>hi</code> · numeric scalar (double) · 长度1。</p>

设定按sex分层计算的求根区间的上端点标量。

</div>

<div class="r-line-card" data-r-line="28">

#### R第28行

```r
tolerance <- 1e-12
```

<p>输入：本行定义的常量或程序环境。输出：<code>tolerance</code> · numeric scalar (double) · 长度1。</p>

设置score绝对值容差，不把近似零写成精确零。

</div>

<div class="r-line-card" data-r-line="30">

#### R第30行

```r
stopifnot(fluctuation_score(data, lo)$score >= 0, fluctuation_score(data, hi)$score <= 0)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度；<code>lo</code> · numeric scalar (double) · 长度1；<code>hi</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

先核对非增score在区间两端夹住根；不满足则停止。

</div>

<div class="r-line-card" data-r-line="32">

#### R第32行

```r
targeted <- NULL
```

<p>输入：本行定义的常量或程序环境。输出：<code>targeted</code> · list · 命名容器；各成员按自身维度。</p>

NULL标记求根结果尚待计算；成功后保存更新对象。

</div>

<div class="r-line-card" data-r-line="34">

#### R第34行

```r
for (iteration in 1:200) {
```

<p>输入：本行定义的常量或程序环境。输出：<code>iteration</code> · integer scalar · 长度1。</p>

最多200次显式二分，每次计算一个区间中点。

</div>

<div class="r-line-card" data-r-line="36">

#### R第36行

```r
  step <- bisection_step(data, lo, hi)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度；<code>lo</code> · numeric scalar (double) · 长度1；<code>hi</code> · numeric scalar (double) · 长度1。输出：<code>step</code> · list · 命名容器；各成员按自身维度。</p>

共享纯函数返回midpoint、score以及缩小后的lo/hi。

</div>

<div class="r-line-card" data-r-line="38">

#### R第38行

```r
  if (iteration <= 5) cat("bisection", iteration, "; epsilon =", step$midpoint, "; score =", step$score, "\n")
```

<p>输入：<code>iteration</code> · integer scalar · 长度1；<code>step</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

显示前5次二分以便核对，全部迭代仍按相同规则计算。

</div>

<div class="r-line-card" data-r-line="40">

#### R第40行

```r
  if (abs(step$score) <= tolerance) {
```

<p>输入：<code>step</code> · list · 命名容器；各成员按自身维度；<code>tolerance</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

abs取score绝对值；达到预定容差才进入成功分支。

</div>

<div class="r-line-card" data-r-line="42">

#### R第42行

```r
    targeted <- case_at(data, step$midpoint)
```

<p>输入：<code>data</code> · list · 命名容器；各成员按自身维度；<code>step</code> · list · 命名容器；各成员按自身维度。输出：<code>targeted</code> · list · 命名容器；各成员按自身维度。</p>

用已求出的中点更新四组Q，按经验X比例标准化，并计算完整经验EIF与SE。

$$
Q^*_{a,x}=\operatorname{expit}(\operatorname{logit}\widehat Q_{a,x}+\widehat\epsilon H_{a,x})
$$


</div>

<div class="r-line-card" data-r-line="44">

#### R第44行

```r
    break
```

<p>输入：本行定义的常量或程序环境。输出：执行检查、显示或控制流程。</p>

break退出最近一层for循环，保留合格targeted对象。

</div>

<div class="r-line-card" data-r-line="46">

#### R第46行

```r
  }
```

<p>输入：本行定义的常量或程序环境。输出：执行检查、显示或控制流程。</p>

结束收敛判断分支。

</div>

<div class="r-line-card" data-r-line="48">

#### R第48行

```r
  stopifnot(step$midpoint != lo, step$midpoint != hi)
```

<p>输入：<code>step</code> · list · 命名容器；各成员按自身维度；<code>lo</code> · numeric scalar (double) · 长度1；<code>hi</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

防止浮点中点等于端点时继续假装缩小区间。

</div>

<div class="r-line-card" data-r-line="50">

#### R第50行

```r
  lo <- step$lo
```

<p>输入：<code>step</code> · list · 命名容器；各成员按自身维度。输出：<code>lo</code> · numeric scalar (double) · 长度1。</p>

以score符号确定的新下界替换旧下界。

</div>

<div class="r-line-card" data-r-line="52">

#### R第52行

```r
  hi <- step$hi
```

<p>输入：<code>step</code> · list · 命名容器；各成员按自身维度。输出：<code>hi</code> · numeric scalar (double) · 长度1。</p>

以score符号确定的新上界替换旧上界。

</div>

<div class="r-line-card" data-r-line="54">

#### R第54行

```r
}
```

<p>输入：本行定义的常量或程序环境。输出：执行检查、显示或控制流程。</p>

结束二分循环；未收敛时targeted仍为NULL。

</div>

<div class="r-line-card" data-r-line="56">

#### R第56行

```r
if (is.null(targeted)) stop("Eight-cell bisection did not converge")
```

<p>输入：<code>targeted</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

达到迭代上限仍无合格结果时显式失败，不输出伪收敛。

</div>

<div class="r-line-card" data-r-line="58">

#### R第58行

```r
print(targeted$groups)
```

<p>输入：<code>targeted</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

显示4组更新Q与score贡献，同一x的两臂按原经验X权重标准化。

</div>

<div class="r-line-card" data-r-line="60">

#### R第60行

```r
cat("eight-cell epsilon =", targeted$epsilon, "; estimate =", targeted$estimate, "; EIF mean =", targeted$eif_mean, "; SE =", targeted$se, "\n")
```

<p>输入：<code>targeted</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

显示按sex分层的TMLE风险差、容差内经验EIF平均与SE；只按性别标准化。

</div>

<div class="r-line-card" data-r-line="62">

#### R第62行

```r
rows <- read_rhc_rows(DEFAULT_SOURCE)
```

<p>输入：本行定义的常量或程序环境。输出：<code>rows</code> · data.frame · 5735行×63列。</p>

重新读取同一5735人原记录，扩展调整变量时不换队列。

</div>

<div class="r-line-card" data-r-line="64">

#### R第64行

```r
fit <- prepare_full(rows)
```

<p>输入：<code>rows</code> · data.frame · 5735行×63列。输出：<code>fit</code> · list · 命名容器；各成员按自身维度。</p>

构建固定顺序的n×17基线design，拟合g及n×18的Q；年龄分母n、white参考、无正则或隐式截断。

</div>

<div class="r-line-card" data-r-line="66">

#### R第66行

```r
initial <- full_at(fit, 0)
```

<p>输入：<code>fit</code> · list · 命名容器；各成员按自身维度。输出：<code>initial</code> · list · 命名容器；各成员按自身维度。</p>

epsilon=0保留初始预测，返回初始标准化风险差、AIPW与经验score。

$$
\widehat\psi_{\rm AIPW}=\widehat\psi_{\rm init}+P_n\widehat D_{\rm init}
$$


</div>

<div class="r-line-card" data-r-line="68">

#### R第68行

```r
cat("baseline columns =", fit$feature_names, "; age mean =", fit$age_mean, "; age SD =", fit$age_sd, "\n")
```

<p>输入：<code>fit</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

显示设计列和年龄标准化参数，读者可以核对固定调整集。

</div>

<div class="r-line-card" data-r-line="70">

#### R第70行

```r
cat("g range =", range(fit$g), "; initial =", initial$estimate, "; AIPW =", initial$aipw, "; score =", initial$score, "\n")
```

<p>输入：<code>fit</code> · list · 命名容器；各成员按自身维度；<code>initial</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

range显示全部n项g的最小和最大；区分初始plug-in、AIPW及score。

</div>

<div class="r-line-card" data-r-line="72">

#### R第72行

```r
for (epsilon in c(0, 0.002, 0.004)) {
```

<p>输入：本行定义的常量或程序环境。输出：<code>epsilon</code> · numeric scalar (double) · 长度1。</p>

对完整基线模型手动试探三个幅度，随后通过二分寻找根。

</div>

<div class="r-line-card" data-r-line="74">

#### R第74行

```r
  trial <- full_at(fit, epsilon)
```

<p>输入：<code>fit</code> · list · 命名容器；各成员按自身维度；<code>epsilon</code> · numeric scalar (double) · 长度1。输出：<code>trial</code> · list · 命名容器；各成员按自身维度。</p>

逐人计算固定offset加epsilon×H的更新、score和平均对数似然。

</div>

<div class="r-line-card" data-r-line="76">

#### R第76行

```r
  cat("full trial epsilon =", epsilon, "; score =", trial$score, "; log likelihood =", trial$log_likelihood, "\n")
```

<p>输入：<code>epsilon</code> · numeric scalar (double) · 长度1；<code>trial</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

显示同一完整5735人平均score和对数似然，分母为全部人数。

</div>

<div class="r-line-card" data-r-line="78">

#### R第78行

```r
}
```

<p>输入：本行定义的常量或程序环境。输出：执行检查、显示或控制流程。</p>

结束完整基线手动试探。

</div>

<div class="r-line-card" data-r-line="80">

#### R第80行

```r
lo <- -0.25
```

<p>输入：本行定义的常量或程序环境。输出：<code>lo</code> · numeric scalar (double) · 长度1。</p>

设置完整基线score二分下界。

</div>

<div class="r-line-card" data-r-line="82">

#### R第82行

```r
hi <- 0.25
```

<p>输入：本行定义的常量或程序环境。输出：<code>hi</code> · numeric scalar (double) · 长度1。</p>

设置完整基线score二分上界。

</div>

<div class="r-line-card" data-r-line="84">

#### R第84行

```r
stopifnot(full_at(fit, lo)$score >= 0, full_at(fit, hi)$score <= 0)
```

<p>输入：<code>fit</code> · list · 命名容器；各成员按自身维度；<code>lo</code> · numeric scalar (double) · 长度1；<code>hi</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

确认完整基线非增score夹住根，失败明确停止。

</div>

<div class="r-line-card" data-r-line="86">

#### R第86行

```r
full_targeted <- NULL
```

<p>输入：本行定义的常量或程序环境。输出：<code>full_targeted</code> · list · 命名容器；各成员按自身维度。</p>

以NULL表示还没有达到容差的完整基线结果。

</div>

<div class="r-line-card" data-r-line="88">

#### R第88行

```r
for (iteration in 1:200) {
```

<p>输入：本行定义的常量或程序环境。输出：<code>iteration</code> · integer scalar · 长度1。</p>

开始最多200次完整基线手动二分。

</div>

<div class="r-line-card" data-r-line="90">

#### R第90行

```r
  step <- full_bisection_step(fit, lo, hi)
```

<p>输入：<code>fit</code> · list · 命名容器；各成员按自身维度；<code>lo</code> · numeric scalar (double) · 长度1；<code>hi</code> · numeric scalar (double) · 长度1。输出：<code>step</code> · list · 命名容器；各成员按自身维度。</p>

在同一fit上计算中点score及更新区间，保留全部初始Q/g。

</div>

<div class="r-line-card" data-r-line="92">

#### R第92行

```r
  if (iteration <= 5) cat("full bisection", iteration, "; epsilon =", step$midpoint, "; score =", step$score, "\n")
```

<p>输入：<code>iteration</code> · integer scalar · 长度1；<code>step</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

显示前5次逐人二分的中点与score，便于手工核对。

</div>

<div class="r-line-card" data-r-line="94">

#### R第94行

```r
  if (abs(step$score) <= tolerance) {
```

<p>输入：<code>step</code> · list · 命名容器；各成员按自身维度；<code>tolerance</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

同一个预设1e−12容差检查完整n人score。

</div>

<div class="r-line-card" data-r-line="96">

#### R第96行

```r
    full_targeted <- full_at(fit, step$midpoint)
```

<p>输入：<code>fit</code> · list · 命名容器；各成员按自身维度；<code>step</code> · list · 命名容器；各成员按自身维度。输出：<code>full_targeted</code> · list · 命名容器；各成员按自身维度。</p>

仅在求根后命名为targeted；两臂更新共用同一epsilon并对同一n人标准化。

$$
\widehat\psi_{\rm TMLE}=n^{-1}\sum_i(Q^*_{1,i}-Q^*_{0,i})
$$


</div>

<div class="r-line-card" data-r-line="98">

#### R第98行

```r
    break
```

<p>输入：本行定义的常量或程序环境。输出：执行检查、显示或控制流程。</p>

退出完整基线二分循环。

</div>

<div class="r-line-card" data-r-line="100">

#### R第100行

```r
  }
```

<p>输入：本行定义的常量或程序环境。输出：执行检查、显示或控制流程。</p>

结束完整基线收敛分支。

</div>

<div class="r-line-card" data-r-line="102">

#### R第102行

```r
  stopifnot(step$midpoint != lo, step$midpoint != hi)
```

<p>输入：<code>step</code> · list · 命名容器；各成员按自身维度；<code>lo</code> · numeric scalar (double) · 长度1；<code>hi</code> · numeric scalar (double) · 长度1。输出：执行检查、显示或控制流程。</p>

浮点中点无法继续缩小时立即停止，避免假收敛。

</div>

<div class="r-line-card" data-r-line="104">

#### R第104行

```r
  lo <- step$lo
```

<p>输入：<code>step</code> · list · 命名容器；各成员按自身维度。输出：<code>lo</code> · numeric scalar (double) · 长度1。</p>

保留含根的新下界标量。

</div>

<div class="r-line-card" data-r-line="106">

#### R第106行

```r
  hi <- step$hi
```

<p>输入：<code>step</code> · list · 命名容器；各成员按自身维度。输出：<code>hi</code> · numeric scalar (double) · 长度1。</p>

保留含根的新上界标量。

</div>

<div class="r-line-card" data-r-line="108">

#### R第108行

```r
}
```

<p>输入：本行定义的常量或程序环境。输出：执行检查、显示或控制流程。</p>

结束完整基线二分循环。

</div>

<div class="r-line-card" data-r-line="110">

#### R第110行

```r
if (is.null(full_targeted)) stop("Full baseline bisection did not converge")
```

<p>输入：<code>full_targeted</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

迭代耗尽时明确报错；合格结果以score容差为准。

</div>

<div class="r-line-card" data-r-line="112">

#### R第112行

```r
cat("full epsilon =", full_targeted$epsilon, "; risk0 =", full_targeted$risk0, "; risk1 =", full_targeted$risk1, "; TMLE =", full_targeted$estimate, "\n")
```

<p>输入：<code>full_targeted</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

分别显示求根幅度、两臂全部n人平均风险和标准化风险差。

</div>

<div class="r-line-card" data-r-line="114">

#### R第114行

```r
cat("full score =", full_targeted$score, "; EIF mean =", full_targeted$eif_mean, "; empirical SE =", full_targeted$se, "\n")
```

<p>输入：<code>full_targeted</code> · list · 命名容器；各成员按自身维度。输出：执行检查、显示或控制流程。</p>

分别显示似然score、完整EIF平均和经验SE；有限样本和推断条件见本章技术说明。

</div>

</details>

</div>

## 改变Q与g，检验双重稳健性

<div class="lab" data-lab="8"></div>

这是把真实联合频数表对应的经验分布固定为参考分布，受控改变Q与g的假设实验，用来检查double robustness的总体恒等式。先预测：仅g正确是否必须逐点恢复Q？两者都错时，score归零能否保证目标正确？

<details><summary>答案与理由</summary>

仅g正确时，偏差乘积为0，目标可以正确而Q仍逐点错误。两者都错时，求根只完成路径上的残差方程；更新后的乘积偏差仍可非零。实验并排比较新Q代入、残差校正和偏差恒等式三条独立计算。

</details>

<details><summary>如何将计算练习扩展为完整的临床研究分析？</summary>

完善临床设计、处理窗口和目标人群，核实急性严重度的处理前测量，检查非线性/交互、权重和重叠，考虑多中心依赖及未测混杂敏感性；若引入失访或时变处理，须扩展观察模型及EIF。更灵活的学习器和cross-fitting还需各自速率条件。这些步骤将本章的计算练习推进为完整的临床研究分析。

</details>

## 回顾从原始数据到AIPW与TMLE的完整计算

你现在能从同一真实原文件得到死亡均值、pX/g/Q、目标梯度、所有有限方向核对、投影、经验方差，再构建offset与H、手动解ε、更新两种策略预测并重新代入。这条流程完成了统计计算与数学验证；将其用于临床因果推断，还要进一步验证识别假设、学习器速率和区间覆盖率。
