输入输出都计价 输入的价格和输出的价格不一样

两个结果的原因是 net 有两个线性层

[(name, param.shape) for name, param in m.named_parameters()][0] 首先作为一个整体，获取列表的第一个元素，即第一个 (name, param.shape) 元组

然后对这个元祖进行解包！

net 是 net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 1))

nn.Linear 是一个全连接层（也称为线性层或密集层）。如果代码中有 if type(m) == nn.Linear: 这样的语句，它的意思是检查变量 m 是否是一个全连接层。

这是python的一个语法糖，net()实际上调用net.call()，而__call__()调用了forward

nn.ReLU()是构造了一个ReLU对象，并不是函数调用，而F.ReLU()是函数调用

这里也可以写成 return self.out(nn.ReLU()(self.hidden(X)) ，但是没有必要

In the provided code, the ReLU layer is applied as a function within the forward method, using F.relu(self.hidden(X)). This means that the ReLU activation is not explicitly recorded as a separate layer in the model's structure. Instead, it is applied directly to the output of the hidden layer during the forward pass.

If you want to explicitly include the ReLU layer in the model's structure, you can define it as a separate layer in the __init__ method and then use it in the forward method. Here's an example:

```python class MLP(nn.Module): def init(self): super().init() self.hidden = nn.Linear(20, 256) # 隐藏层 self.relu = nn.ReLU() # ReLU 层 self.out = nn.Linear(256, 10) # 输出层

def forward(self, X):
    return self.out(self.relu(self.hidden(X)))

```

In this version, the ReLU layer is explicitly defined and included in the model's structure.

模型开启评估模式，在这里其实这行代码可以删掉

torch.matmul可以用在更多维度的矩阵运算，mm只能在两纬

pytorch 代码请参见 https://d2l.ai/chapter_builders-guide/lazy-init.html

The following method passes in dummy inputs through the network for a dry run to infer all parameter shapes and subsequently initializes the parameters. It will be used later when default random initializations are not desired.

python @d2l.add_to_class(d2l.Module) #@save def apply_init(self, inputs, init=None): self.forward(*inputs) if init is not None: self.net.apply(init)

torch.rand(2, 20) 是 PyTorch 中的一个函数，用于生成一个填充了从均匀分布（在区间 [0, 1)）中随机抽取的数字的张量1。这里的 (2, 20) 是张量的形状，表示生成的张量有 2 行和 20 列。

返回一个 元素为0或者1的向量，表示该位置的元素的绝对值是否大于5

matrix multiplication

The torch.mm function in PyTorch performs a matrix multiplication of two matrices¹. Here's a more detailed explanation:

• torch.mm(input, mat2, *, out=None) → Tensor¹
• It performs a matrix multiplication of the matrices input and mat2¹.
• If input is a (n × m) tensor and mat2 is a (m × p) tensor, out will be a (n × p) tensor¹.
• This function does not support broadcasting. For broadcasting matrix products, you should use torch.matmul()¹.
• It supports strided and sparse 2-D tensors as inputs, and autograd with respect to strided inputs¹.

Here's an example of how to use it: python mat1 = torch.randn(2, 3) mat2 = torch.randn(3, 3) result = torch.mm(mat1, mat2) print(result) This will output a 2x3 tensor which is the result of the matrix multiplication of mat1 and mat2¹. Please note that the number of columns in the first matrix must be equal to the number of rows in the second matrix for the multiplication to be valid.

It's important to note that torch.mm differs from other similar functions like torch.matmul and torch.mul. While torch.mm performs a matrix multiplication without broadcasting and expects two 2D tensors, torch.matmul performs a matrix product with broadcasting and can handle tensors with different shapes². On the other hand, torch.mul performs element-wise multiplication².

\(1-\frac{\hat y}{y}\) 要小，等价为 \(\frac{y}{\hat y}\) 要小，然后取对数，除法变减法

nn.MSEloss() 返回的是 batch_size 的（label-output）2

缺失值也作为一个类别

这里为了方便起见，在train set 和 test set 上整体标准化，我们在做的时候应该是在 train set 上标准化并获得其均值和方差，然后拿这个均值和方差来标准化 test set.

exist_ok=True is an optional argument. When set to True, the function does not raise an exception if the directory already exists. If exist_ok is False (the default), an exception is raised if the target directory already exists.

这里的 \(\partial o / \partial h\) 的结果是符合矩阵求导的，得到的也是 \(W^{(2)\prime}\)

为什么是 \({\mathbf{W}^{(2)}}^\top \frac{\partial J}{\partial \mathbf{o}}\) 而不是 \(\frac{\partial J}{\partial \mathbf{o}}{\mathbf{W}^{(2)}}^\top\) 这个主要是因为前面也提到，prod运算符是指执行必要的操作，也就是说会自动根据需要进行换位和交换输入位置等，然后再进行相乘。然而这里的 \(\frac{\partial J}{\partial \mathbf{o}}\) 是h维向量，\(W^{(1)}\) 是 h❌d 维，所以（转置后）必须写到前面

下面这个求导法则在数学上是有点问题的

$$ W^{(2)}h = \begin{pmatrix} w^{(2)\prime}{1}\ w^{(2)\prime}{2} \ \vdots& \ w^{(2)\prime}{q} \ \end{pmatrix} \begin{pmatrix}h{1} \ h_{2} \\vdots\ h_{h}\end{pmatrix} = \begin{pmatrix} w^{(2)\prime}{1} h\ w^{(2)\prime}{2} h\ \vdots& \ w^{(2)\prime}_{q} h\ \end{pmatrix} $$

• \(w^{(2)}_{1}\) 为 \(W^{(2)}\) 每个输出单元对应的仿射变换的权重 h维 列向量，上面转置以适应矩阵乘法 \(o=W^{(2)}h\)

\(\frac{\partial (W^{(2)}h)}{\partial W^{(2)}}\) 这种矩阵求导不存在的，实际上是做什么呢？其每个分量对每个分量求导，即 \(\frac{\partial (w^{(2)\prime}{1}h)}{\partial w^{(2)}{1}}=h\) ，其他分量也得到 \(h\) 。

为了 \(W^{(2)}\) 能够与这个结果直接进行加减运算、更新梯度， 求导的结果可记为（注意这种求导依然是不存在的）

$$ \frac{\partial (W^{(2)}h)}{\partial W^{(2)}} = \begin{pmatrix}h^T \ h^T \ \vdots \ h^T\end{pmatrix} $$

W2-=eta * G ，其中eta为学习率，G为 \(h^{T}\) ，这样写没问题，因为有广播原则！

• loss 的每个分量都增加了一个 lambd*l2_penalty
• 总Loss增加了 batch_size*lambd*l2_penalty ↔ \(\lambda/2 \lVert\mathbf{w}\rVert^2\)

最有意思的是，这也是 pytroch torch.optim.SGD() 里面设置的 weight_decay 的运行方式，即weight_decay 作用于每个维度的参数，最终加和反映到该批次总的目标函数上

自定义实现，这里确实得运用广播机制，每个分量都得加 penalty，而不是 python l = loss(net(X), y) (l.sum()+lambd * l2_penalty(w)).backward()

d2l.sgd() 在反向传播的时候都是除以 bacth_size，所以这里要加，就是每个分量都要加

所以李沐的手动实现代码和简洁实现代码中的 lambd 的效果完全等价，训练的可视化图形的差异是别的原因

无权重衰减的写法，查看 https://zh.d2l.ai/chapter_linear-networks/linear-regression-concise.html

python trainer = torch.optim.SGD(net.parameters(), lr=0.03)

这个 lambda 函数非常有意思，返回的是两个函数 ❌

等价为 python net = lambda X: d2l.linreg(X, w, b) loss = d2l.squared_loss

```python

Defined in file: ./chapter_linear-networks/linear-regression-concise.md

def load_array(data_arrays, batch_size, is_train=True): """Construct a PyTorch data iterator.""" dataset = data.TensorDataset(*data_arrays) return data.DataLoader(dataset, batch_size, shuffle=is_train) ```

```python

Defined in file: ./chapter_linear-networks/linear-regression-scratch.md

def synthetic_data(w, b, num_examples): """Generate y = Xw + b + noise.""" X = d2l.normal(0, 1, (num_examples, len(w))) y = d2l.matmul(X, w) + b y += d2l.normal(0, 0.01, y.shape) return X, d2l.reshape(y, (-1, 1)) ``` d2l.reshape 就是调用 reshape(tensor, [shape]) 就地修改

python reshape = lambda x, *args, **kwargs: x.reshape(*args, **kwargs)

这个的数学计算没搞懂

Returns a tensor filled with random numbers from a uniform distribution on the interval :math:[0, 1)

这些代码和简洁实现的代码一样，所以

class Ne(nm.Module) 和 nn.Sequentia() 返回的东西是一样的

元素乘积

net 给的是 \(o_k\), 交叉熵损失由 nn.CrossEntropyLoss(reduction='None') 来解决

在PyTorch中，torch.mm(A, B)和A @ B都是用来进行矩阵乘法的。

torch.mm(A, B)是一个函数，它接受两个2D张量（即矩阵）作为输入，并返回它们的矩阵乘积。这个操作遵循矩阵乘法的规则，即A的列数必须等于B的行数。

A @ B是一个运算符，它也是用来进行矩阵乘法的。它的行为与torch.mm(A, B)基本相同，但是它还支持高维张量的乘法。对于高维张量，它会对最后两个维度进行矩阵乘法，其他维度必须匹配或者为1。

例如：

```python import torch

A = torch.tensor([[1, 2], [3, 4]]) B = torch.tensor([[5, 6], [7, 8]])

C = A @ B print(C) # 输出：tensor([[19, 22], [43, 50]]) ```

在这个例子中，A @ B和torch.mm(A, B)的结果是相同的。但是如果A和B是高维张量，那么A @ B可以进行高维矩阵乘法，而torch.mm(A, B)则会报错。

训练的抽样数据彼此间有相关性，但是训练数据和测试数据间相关性很弱，违反 iid

不是让模型记住 ID 和 outcome 之间的关系，而是具备预测能力

类似 Dataframe.apply 函数

nn.init.normal_(m.weight, std=0.01) 是 PyTorch 中的一个函数，用于将权重初始化为正态分布。这个函数会就地（in-place）改变 m.weight 的值。

在这个函数中，m.weight 是一个 nn.Linear 层的权重张量，std=0.01 是正态分布的标准差。函数将 m.weight 中的每个元素初始化为一个随机数，这个随机数来自均值为0、标准差为0.01的正态分布。

这种初始化方法常用于神经网络的权重初始化，因为它可以在训练开始时打破权重的对称性，有助于避免模型陷入不良的局部最优解。

⇔ X = X.reshape((-1, num_inputs))

这段代码是在进行一些断言检查，以确保训练和测试的结果满足一些预期的条件。

python assert train_loss < 0.5, train_loss 这行代码是检查训练损失（train_loss）是否小于0.5。如果train_loss大于或等于0.5，那么断言就会失败，程序会抛出一个AssertionError异常，并打印出train_loss的值。

python assert train_acc <= 1 and train_acc > 0.7, train_acc 这行代码是检查训练准确率（train_acc）是否在0.7到1之间。如果train_acc小于0.7或大于1，那么断言就会失败，程序会抛出一个AssertionError异常，并打印出train_acc的值。

python assert test_acc <= 1 and test_acc > 0.7, test_acc 这行代码是检查测试准确率（test_acc）是否在0.7到1之间。如果test_acc小于0.7或大于1，那么断言就会失败，程序会抛出一个AssertionError异常，并打印出test_acc的值。

这些断言检查通常用于确保程序的运行结果满足预期。如果某个断言检查失败，那么说明可能存在一些问题，例如模型可能没有正确地训练，或者数据可能存在一些问题。

这段代码定义了一个名为Animator的类，该类用于在动画中绘制数据。下面是对这个类的主要方法和属性的解释：

• __init__：这是类的构造函数，用于初始化对象。它接受多个参数，包括标签、坐标轴限制、坐标轴比例、线型、子图数量、图形大小等。这些参数用于配置图形的各种属性。

• add：这个方法用于向图表中添加数据点。它接受两个参数x和y，分别表示数据点的x坐标和y坐标。如果x或y不是列表，那么它会被转换为列表。然后，这些数据点被添加到self.X和self.Y中，这两个属性分别存储所有数据点的x坐标和y坐标。最后，这个方法会清除当前的图形，然后根据新的数据点重新绘制图形。

• self.fig和self.axes：这两个属性分别表示图形和子图的对象。self.fig是一个Figure对象，表示整个图形。self.axes是一个Axes对象的列表，表示图形中的子图。

• self.config_axes：这是一个函数，用于配置子图的各种属性，如标签、坐标轴限制、坐标轴比例等。

• self.X和self.Y：这两个属性分别存储所有数据点的x坐标和y坐标。

• self.fmts：这个属性存储了线型的列表，用于在绘制数据点时指定线型。

这个类的主要作用是提供一个方便的接口，用于在动画中绘制数据点。你可以创建一个Animator对象，然后通过调用add方法向图表中添加数据点。每次调用add方法时，图表都会被清除并重新绘制，因此你可以看到数据点的动态变化。

batch_size

l.mean().backward()：当使用PyTorch内置的优化器和损失函数时，损失l是一个批次的平均损失，因此我们需要对平均损失进行反向传播。这样做的好处是，平均损失对批次大小不敏感，无论批次大小如何，梯度的规模都保持不变。

``` list(zip([0,0], [1,2]))

[(0, 1), (0, 2)] ``` [0+1,0+2] 更新

sigmoid函数的导数为下面的公式：

$$\frac{d}{dx} \operatorname{sigmoid}(x) = \frac{\exp(-x)}{(1 + \exp(-x))^2} = \operatorname{sigmoid}(x)\left(1-\operatorname{sigmoid}(x)\right).$$

sigmoid函数的导数图像如下所示。 注意，当输入为0时，sigmoid函数的导数达到最大值0.25； 而输入在任一方向上越远离0点时，导数越接近0。

一个常见的需要保留计算图的例子是计算二阶导数（或者叫做Hessian向量积）。在某些优化算法，如牛顿法和共轭梯度法中，需要用到二阶导数。下面是一个简单的例子：

```python import torch

创建一个张量，并设置requires_grad=True使其可以计算梯度

x = torch.tensor([1.0], requires_grad=True)

定义一个函数

y = x ** 3

第一次反向传播，计算一阶导数

y.backward(retain_graph=True)

打印一阶导数

print(x.grad) # 输出：tensor([3.])

因为我们要进行第二次反向传播，所以需要先清零梯度

x.grad.zero_()

第二次反向传播，计算二阶导数

y.backward(retain_graph=True)

打印二阶导数

print(x.grad) # 输出：tensor([6.]) ```

在这个例子中，我们首先定义了一个函数y = x ** 3，然后我们两次调用.backward()方法，第一次计算一阶导数，第二次计算二阶导数。在两次反向传播之间，我们需要调用x.grad.zero_()来清零梯度，因为PyTorch默认会累积梯度，而不是替换梯度。同时，我们需要在调用.backward()方法时设置retain_graph=True，以保留计算图，否则在第二次反向传播时会报错，因为计算图已经被清空。

李沐 按照计算层的数量定义层数

nn.CrossEntropyLoss是PyTorch中的一个类，它实现了交叉熵损失函数。交叉熵损失函数常用于多分类问题，它可以度量模型的预测概率分布与真实概率分布之间的差异。

reduction='none'是一个参数，它指定了如何对每个样本的损失进行聚合。'none'表示不进行聚合，即返回一个损失值的向量，向量的每个元素对应一个样本的损失。其他可能的值包括'mean'（返回所有样本损失的平均值）和'sum'（返回所有样本损失的总和）。

在 train_ch3 → train_epoch_ch3 中内置优化器是 l.mean().backwar()

在这个例子中，我们选择'none'是因为我们想要在后续的计算中手动处理每个样本的损失，例如，我们可能想要计算每个样本损失的平均值，或者只关注损失最大的几个样本。

文章 《Uncovering ecological state dynamics with hidden Markov models》 的Appendix pd，已存档Zotero

什么样的模型要验证直到20阶以后的（偏）自相关系数呀都不用看。 所以这两个图都是拖尾

在此数据集上，Spanish错误率最低为2.8%，English的错误率为4.1%，中文Mandarin的错误率为7.7%。

不能设置为1或0这两个边界值，只能设置成非常接近边界值的值，例如1.e-100

ID step angle x y states 1 1 833.60385 NA 0.0000 0.0000 2

只是董事会成员，并不一定是董事长

赞助人的薪资声明，那就是要顾老师的薪资证明，是不可以的

点击这个查看学费估算

银行资产证明

但是这个tuition insurance 需不需要买呢？

我们不注册课程

指的是 plot.momentHMM ↔ plot(momentHMM)

这里只考虑了随机截距，没有随机斜率。但是可以有些变量也有随机效应的 \(z\)的列双倍，那意味着\(u\)的行也要双倍

\(\exp(-0.13)=0.878\)

下面的 u = -.158,-0.47,0.54,1.82 分别对应随机效应u的这四个分位数

病情缓解

genelarized linear mixed model 多了个mixed

第一次明白 probability mass function 和 probability density function的区别

不再使用开头的矩阵表达，转为 two level-style equation

注意：依然只有随机斜率，没有随即截距

开始讨论模型的最后一个元素，the variance-covariance matrix of the residuals

为什么假设随机效应服从的正态分布均值为0的理由

没有拟合单个HMM并行加速的方法

与momentuHMM包的 dnbinom_rcpp 函数不同，这里的size 指的是总的 trials

这个均值算错了，应该是 388.5

这个图有三种颜色的原因是：红色和绿色重合了，变成了另外一种颜色

这里写错了，应该是上标 $$(-i)$$

trail population $$S_i=1$$ covariates + binary treatment + response

target population $$S_i=0$$ 只有covariates

In the context of the article you mentioned, RCT stands for Randomized Controlled Trial. It refers to a subset of a population for which we have access to results from a randomized/observational trial/study 在你提到的文章中，RCT代表随机对照试验。它指的是我们可以从随机/观察性试验/研究中获得结果的人群的一个子集

忽略了处理组个体的 _weight 需要为1

可以对部分列进行操作，不需要对所有列都进行操作（填补缺失值）

这个 $(1+x_i)'$ 有点问题，应该是 $(1 x_i)'$ 这样的转置后的一个行向量

肯定的呀，你自己都知道因为多重共线性被 omitted 了

典型的 nested 固定效应

因为 -reghdfe- 根本不会汇报固定效应，而是直接在redundant 栏汇报

-xtreg, fe- 除了个体固定效应外，其他的都会汇报

这个挺好用的