神经网络与激活函数

"""全连接层：手写矩阵版与 nn.Linear 版算出来必须一模一样。

一层全连接做的事只有一句：把上一层送来的一排数字，
用一个权重矩阵乘过去，再加一排偏置。
这份代码把 nn.Linear 内部那一行摊开写，两边结果对账。
"""
import torch
import torch.nn as nn


def main():
    torch.manual_seed(0)

    batch, in_features, out_features = 4, 3, 2

    # 一批数据：4 条样本，每条 3 个特征。第 0 维永远是 batch
    x = torch.randn(batch, in_features)

    layer = nn.Linear(in_features, out_features)

    # ---------------------------------------------------------- 权重的形状
    # 这里最容易记反：weight 的形状是 (out_features, in_features)，
    # 也就是「每一行是一个神经元的全部权重」，有几个神经元就有几行。
    print('weight 形状', tuple(layer.weight.shape))   # (2, 3)
    print('bias   形状', tuple(layer.bias.shape))     # (2,)

    # ---------------------------------------------------------- 官方版
    out_official = layer(x)

    # ---------------------------------------------------------- 手写版
    # 因为 weight 是 (out, in)，要和 (batch, in) 相乘就得先转置成 (in, out)
    out_manual = x @ layer.weight.t() + layer.bias

    print('输出形状', tuple(out_official.shape))      # (4, 2)
    print('两种算法最大误差 = %.10f'
          % (out_official - out_manual).abs().max().item())

    # ---------------------------------------------------------- 逐个神经元拆开
    # 第 0 号神经元对第 0 条样本的内部状态值，就是一次点积加偏置
    z00 = torch.dot(layer.weight[0], x[0]) + layer.bias[0]
    print('第 0 条样本在第 0 号神经元上的 z：拆开算 = %.6f，整层算 = %.6f'
          % (z00.item(), out_official[0, 0].item()))

    # ---------------------------------------------------------- 全连接的含义
    # 第 N 层的每个神经元都连到第 N-1 层的全部神经元上，
    # 所以连线条数 = in_features × out_features，再加上每个神经元一个偏置。
    print('本层连线条数 =', in_features * out_features)
    print('本层参数总量 =', in_features * out_features + out_features,
          '实测 =', sum(p.numel() for p in layer.parameters()))

    # ---------------------------------------------------------- 不带偏置的层
    no_bias = nn.Linear(in_features, out_features, bias=False)
    print('去掉偏置后的参数量 =', sum(p.numel() for p in no_bias.parameters()))
    print('去掉偏置后 bias 属性 =', no_bias.bias)      # None

    # ---------------------------------------------------------- 输入必须是二维
    # 全连接网络吃的是 (batch_size, in_features)。单条样本要先补出 batch 维，
    # 否则矩阵乘法的维度对不上。
    single = torch.randn(in_features)
    print('单条样本补维前', tuple(single.shape),
          '补维后', tuple(single.unsqueeze(0).shape))
    print('单条样本的输出', tuple(layer(single.unsqueeze(0)).shape))


if __name__ == '__main__':
    main()

"""没有激活函数，堆多少层都等于一层——这份代码把它算给你看。

两层线性层串起来：
    z1 = x @ W1ᵀ + b1
    z2 = z1 @ W2ᵀ + b2
       = x @ (W2 @ W1)ᵀ + (b1 @ W2ᵀ + b2)
等号右边仍然是「x 乘一个矩阵再加一个向量」，也就是一层线性层。
所以不加激活函数时，深度带来的表达能力是零。
"""
import torch
import torch.nn as nn


def main():
    torch.manual_seed(7)

    x = torch.randn(5, 4)            # 5 条样本，4 个特征

    l1 = nn.Linear(4, 6)             # 第一层：4 -> 6
    l2 = nn.Linear(6, 3)             # 第二层：6 -> 3

    # ---------------------------------------------------------- 不加激活函数
    two_layers = l2(l1(x))

    # 把两层合并成等效的单层：W = W2 @ W1，b = b1 @ W2ᵀ + b2
    W = l2.weight @ l1.weight                       # (3,6) @ (6,4) -> (3,4)
    b = l1.bias @ l2.weight.t() + l2.bias           # (6,) @ (6,3) -> (3,)
    one_layer = x @ W.t() + b

    print('两层线性 与 等效单层 的最大误差 = %.8f'
          % (two_layers - one_layer).abs().max().item())
    print('等效单层权重形状', tuple(W.shape), '—— 和直接写 nn.Linear(4, 3) 一样')

    # ---------------------------------------------------------- 加上激活函数
    # 中间插一个 ReLU 之后，就再也找不到一个矩阵能等效替代它了
    with_act = l2(torch.relu(l1(x)))
    print('插入 ReLU 后 与 等效单层 的最大差距 = %.6f'
          % (with_act - one_layer).abs().max().item())
    print('这个差距不为 0，说明非线性确实带来了单层做不到的表达能力')

    # ---------------------------------------------------------- 再直观一点
    # 线性函数的图像永远是直线/平面，无论叠多少层；
    # 要拟合一条弯曲的曲线，必须让每层的输出先被掰弯一次。
    t = torch.tensor([-2.0, -1.0, 0.0, 1.0, 2.0])
    print('原始输入          ', t.tolist())
    print('线性变换 3t+1     ', (3 * t + 1).tolist(), '  —— 等距点仍然等距')
    print('ReLU(3t+1)        ', torch.relu(3 * t + 1).tolist(),
          '  —— 负半边被压平，等距被打破')


if __name__ == '__main__':
    main()

"""四个激活函数的数值对照：函数值、导数值，以及导数连乘之后还剩多少。

不画图，只打数字。看数字比看曲线更能说清「为什么 sigmoid 会梯度消失」。
"""
import torch


def value_table():
    """同一批输入，四个函数各自压成什么样。"""
    x = torch.tensor([-20.0, -6.0, -3.0, -1.0, 0.0, 1.0, 3.0, 6.0, 20.0])

    print('%8s %10s %10s %10s' % ('x', 'sigmoid', 'tanh', 'relu'))
    for i in range(len(x)):
        print('%8.1f %10.6f %10.6f %10.3f'
              % (x[i].item(),
                 torch.sigmoid(x[i]).item(),
                 torch.tanh(x[i]).item(),
                 torch.relu(x[i]).item()))

    # 看首尾两行：输入从 -20 变到 -6，sigmoid 的输出几乎没变化，
    # 输入差 14 的信息在这一步被抹平了，这就是「饱和区丢信息」。


def grad_table():
    """导数才是反向传播真正要连乘的东西。"""
    x = torch.linspace(-10, 10, 2001, requires_grad=True)

    # 对一批点求和后反向，x.grad 里就是逐点导数
    torch.sigmoid(x).sum().backward()
    sig_grad = x.grad.clone()

    x.grad.zero_()
    torch.tanh(x).sum().backward()
    tanh_grad = x.grad.clone()

    x.grad.zero_()
    torch.relu(x).sum().backward()
    relu_grad = x.grad.clone()

    print('sigmoid 导数最大值 = %.4f（出现在 x=0 处）' % sig_grad.max().item())
    print('tanh    导数最大值 = %.4f（出现在 x=0 处）' % tanh_grad.max().item())
    print('relu    导数最大值 = %.4f（正半轴恒为 1）' % relu_grad.max().item())
    print('relu    导数为 0 的点占比 = %.2f%%'
          % (100.0 * (relu_grad == 0).float().mean().item()))


def chain_product():
    """把导数连乘 n 次，看还剩多少——这就是层数一深就学不动的原因。"""
    print('%6s %16s %16s' % ('层数', 'sigmoid 最好情形', 'relu 正半轴'))
    for n in (1, 3, 5, 10, 20):
        # sigmoid 导数的上限是 0.25，取最好的情形连乘都是这个数
        print('%6d %16.10f %16.1f' % (n, 0.25 ** n, 1.0 ** n))
    # 0.25 的 5 次方不到千分之一，10 次方约百万分之一：
    # 传到前几层的梯度基本等于 0，参数根本不动。


def softmax_demo():
    """softmax 不是逐点函数，它把一组分数整体压成概率。"""
    scores = torch.tensor([0.2, 0.02, 0.15, 0.15, 1.3,
                           0.5, 0.06, 1.1, 0.05, 3.75])
    prob = torch.softmax(scores, dim=0)
    print('概率之和 = %.6f' % prob.sum().item())      # 恒等于 1
    print('最大概率的下标 =', torch.argmax(prob).item(),
          '，与分数最大的下标一致')

    # softmax 只关心分数之间的「差」，整体加减同一个常数结果不变
    shifted = torch.softmax(scores + 100.0, dim=0)
    print('全部加 100 之后的最大差异 = %.8f'
          % (prob - shifted).abs().max().item())
    # 这条性质也是各框架内部做数值稳定处理（减去最大值）的依据


if __name__ == '__main__':
    value_table()
    print('-' * 46)
    grad_table()
    print('-' * 46)
    chain_product()
    print('-' * 46)
    softmax_demo()

"""全 0 初始化为什么不行：同一层的神经元会拿到一模一样的梯度。

结论不靠背，靠跑：把一层的权重全设成 0，反向一次，
打印每个神经元拿到的梯度，会发现所有行完全相同——
它们从此永远是同一个神经元的复制品，隐藏层再宽也没用。
"""
import torch
import torch.nn as nn


def all_zero():
    torch.manual_seed(0)

    layer = nn.Linear(4, 3)
    nn.init.zeros_(layer.weight)
    nn.init.zeros_(layer.bias)

    out = nn.Linear(3, 1)
    nn.init.constant_(out.weight, 0.5)     # 输出层给个非 0 值，保证梯度能传回来
    nn.init.zeros_(out.bias)

    x = torch.randn(8, 4)
    y = torch.randn(8, 1)

    loss = ((out(torch.sigmoid(layer(x))) - y) ** 2).mean()
    loss.backward()

    print('全 0 初始化，隐藏层三个神经元各自拿到的梯度：')
    for i, row in enumerate(layer.weight.grad):
        print('  神经元 %d : %s' % (i, [round(v, 8) for v in row.tolist()]))

    first = layer.weight.grad[0]
    same = all(torch.allclose(first, r) for r in layer.weight.grad)
    print('三行是否完全相同 ->', same)
    print('相同意味着：更新之后它们的权重还是相同的，永远学不出差异')


def random_init():
    torch.manual_seed(0)

    layer = nn.Linear(4, 3)
    nn.init.normal_(layer.weight, mean=0.0, std=0.1)
    nn.init.zeros_(layer.bias)             # 偏置给 0 没问题，对称已被权重打破

    out = nn.Linear(3, 1)
    nn.init.constant_(out.weight, 0.5)
    nn.init.zeros_(out.bias)

    x = torch.randn(8, 4)
    y = torch.randn(8, 1)

    loss = ((out(torch.sigmoid(layer(x))) - y) ** 2).mean()
    loss.backward()

    print('随机初始化，隐藏层三个神经元各自拿到的梯度：')
    for i, row in enumerate(layer.weight.grad):
        print('  神经元 %d : %s' % (i, [round(v, 8) for v in row.tolist()]))

    first = layer.weight.grad[0]
    same = all(torch.allclose(first, r) for r in layer.weight.grad)
    print('三行是否完全相同 ->', same, '（各走各的，才谈得上分工）')


def scale_matters():
    """初始化的大小同样要紧：太大直接把 sigmoid 顶进饱和区。"""
    x = torch.randn(256, 128)

    for std in (0.01, 0.1, 1.0, 5.0):
        w = torch.randn(64, 128) * std
        z = x @ w.t()
        a = torch.sigmoid(z)
        # 激活值挤在 0 或 1 附近的比例越高，导数越接近 0，越学不动
        saturated = ((a < 0.01) | (a > 0.99)).float().mean().item()
        print('std=%-5s  z 的标准差 %7.3f   激活值落入饱和区的比例 %6.2f%%'
              % (std, z.std().item(), saturated * 100))

    print('这就是 xavier / kaiming 存在的理由：它们按扇入扇出算出一个')
    print('刚好让各层输出方差稳定的 std，不用手工试。')


if __name__ == '__main__':
    all_zero()
    print('-' * 56)
    random_init()
    print('-' * 56)
    scale_matters()

"""参数初始化：七种写法，以及该挑哪一种。"""
import torch.nn as nn

linear = nn.Linear(5, 3)     # 5 个输入、3 个输出，w 的形状是 (3, 5)

# 1) 均匀分布：默认从 (0, 1) 取值
nn.init.uniform_(linear.weight)

# 2) 固定值：调试时好用，正式训练别用，全一样等于只有一个神经元
nn.init.constant_(linear.weight, 5)

# 3) 全 0：同一层所有神经元收到的梯度完全相同，永远学不出差异
nn.init.zeros_(linear.weight)

# 4) 全 1：同样对称，同样学不动
nn.init.ones_(linear.weight)

# 5) 正态分布
nn.init.normal_(linear.weight, mean=0, std=1)

# 6) kaiming（HE）初始化：方差按 2/fan_in 算，配 ReLU 系
nn.init.kaiming_normal_(linear.weight, nonlinearity='relu')
nn.init.kaiming_uniform_(linear.weight, nonlinearity='relu')

# 7) xavier（Glorot）初始化：方差按 2/(fan_in+fan_out) 算，配 sigmoid / tanh
nn.init.xavier_normal_(linear.weight)
nn.init.xavier_uniform_(linear.weight)

print(linear.weight.data)

# 选法只有一句话：
#   隐藏层用 ReLU  -> kaiming
#   隐藏层用 sigmoid / tanh -> xavier
#   偏置 b 一律 zeros_，不需要打破对称

"""参数量：先手算，再让代码数一遍，两个数必须相同。

手算规则只有一条：
    某一层的参数量 = 该层神经元个数 × (上一层神经元个数 + 1)
括号里的 +1 是每个神经元自带的那一个偏置 b。
输入层不算参数——它只是数据入口，没有权重。
"""
import torch
import torch.nn as nn


def hand_count(sizes):
    """按 [输入, 隐藏1, 隐藏2, ..., 输出] 的神经元个数手算总参数量。"""
    total = 0
    for i in range(1, len(sizes)):
        fan_in, fan_out = sizes[i - 1], sizes[i]
        layer = fan_out * (fan_in + 1)
        print('  第 %d 层：%d 个神经元 × (%d + 1) = %d'
              % (i, fan_out, fan_in, layer))
        total += layer
    return total


def build(sizes):
    """按同一组神经元个数建出真实网络。"""
    layers = []
    for i in range(1, len(sizes)):
        layers.append(nn.Linear(sizes[i - 1], sizes[i]))
        if i < len(sizes) - 1:
            layers.append(nn.ReLU())
    return nn.Sequential(*layers)


def report(model):
    """逐层列出形状与参数量，相当于自己写的一份模型摘要。"""
    print('%-10s %-16s %10s' % ('参数名', '形状', '个数'))
    total, trainable = 0, 0
    for name, p in model.named_parameters():
        print('%-10s %-16s %10d' % (name, str(tuple(p.shape)), p.numel()))
        total += p.numel()
        if p.requires_grad:
            trainable += p.numel()
    print('合计 %d，其中可训练 %d' % (total, trainable))
    # 一个 float32 参数占 4 字节，换算成显存占用
    print('权重本身约占 %.2f KB（float32，每个参数 4 字节）' % (total * 4 / 1024))
    return total


if __name__ == '__main__':
    sizes = [3, 3, 2, 2]        # 输入 3，隐藏层 3 和 2，输出 2

    print('手算：')
    manual = hand_count(sizes)
    print('  手算合计 =', manual)

    print('\n实测：')
    model = build(sizes)
    real = report(model)

    print('\n手算 %d，实测 %d，一致 -> %s' % (manual, real, manual == real))

    # ---------------------------------------------------------- 常见误解
    # 输入数据的条数（batch_size）跟参数量毫无关系：
    # 一次喂 5 条还是 500 条，网络的权重个数一模一样。
    for batch in (5, 500):
        x = torch.randn(batch, sizes[0])
        print('batch=%3d  输出形状 %s  参数量 %d'
              % (batch, tuple(model(x).shape), sum(p.numel() for p in model.parameters())))

    # ---------------------------------------------------------- 冻结参数
    # 迁移学习里常把前面几层冻住：requires_grad=False 之后它们不再出现在
    # 可训练参数里，优化器也就不会更新它们。
    for p in model[0].parameters():
        p.requires_grad = False
    print('\n冻结第一层之后：')
    report(model)

"""一个神经元的两步计算：加权求和，再过激活函数。

不用 nn.Linear，全手写一遍，看清楚 w、b、z、a 到底是谁。
"""
import torch

# 一条样本，3 个特征
x = torch.tensor([1.0, 2.0, 3.0])

# 这个神经元自己的参数：每个输入一个权重，外加一个偏置
w = torch.tensor([0.2, -0.5, 0.1])
b = torch.tensor(0.4)

# 第一步：加权求和，得到内部状态值 z
z = (w * x).sum() + b          # 等价于 torch.dot(w, x) + b
print('内部状态值 z =', z.item())      # 0.2*1 + (-0.5)*2 + 0.1*3 + 0.4 = -0.1

# 第二步：非线性变换，得到激活值 a，这才是交给下一层的东西
a = torch.sigmoid(z)
print('激活值 a =', a.item())

# 一层有多个神经元时，就把每个神经元的 w 排成矩阵，一次算完
W = torch.tensor([[0.2, -0.5, 0.1],     # 神经元 1 的三个权重
                  [0.7, 0.3, -0.2]])    # 神经元 2 的三个权重
B = torch.tensor([0.4, -0.1])
Z = W @ x + B                  # (2,3) @ (3,) -> (2,)
print('整层的 z =', Z)
print('整层的 a =', torch.sigmoid(Z))

"""四个激活函数：既画函数值，也画导数，导数才是梯度消失的证据。"""
import torch
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False


def draw(name, fn):
    """左边画函数图像，右边画导数图像。"""
    _, axes = plt.subplots(1, 2, figsize=(8, 3))

    x = torch.linspace(-20, 20, 1000)
    axes[0].plot(x, fn(x))
    axes[0].grid()
    axes[0].set_title('%s 函数图像' % name)

    # 导数图像的取法：对同一批点求和后反向传播，x.grad 里就是逐点导数
    x = torch.linspace(-20, 20, 1000, requires_grad=True)
    fn(x).sum().backward()
    axes[1].plot(x.detach(), x.grad)      # x 带梯度，画图前要 detach
    axes[1].grid()
    axes[1].set_title('%s 导数图像' % name)
    plt.show()


if __name__ == '__main__':
    draw('Sigmoid', torch.sigmoid)   # 导数最大只有 0.25，层数一深就消失
    draw('Tanh', torch.tanh)         # 导数范围 (0,1)，以 0 为中心，比 sigmoid 快
    draw('ReLU', torch.relu)         # 正半轴导数恒为 1，负半轴恒为 0

    # Softmax 不是逐点函数，单独看：把一组分数压成和为 1 的概率
    scores = torch.tensor([0.2, 0.02, 0.15, 0.15, 1.3, 0.5, 0.06, 1.1, 0.05, 3.75])
    prob = torch.softmax(scores, dim=0)
    print(prob)
    print('概率之和 =', prob.sum().item())        # 1.0
    print('预测类别 =', torch.argmax(prob).item())  # 9，分数最高那一个

"""搭一个三层网络并数清参数量。

结构：3 -> 3（sigmoid）-> 2（relu）-> 2（softmax）
每层的初始化方法按激活函数配对：sigmoid 配 xavier，relu 配 kaiming。
"""
import torch
import torch.nn as nn


class Model(nn.Module):
    def __init__(self):
        super().__init__()

        # 第 1 个隐藏层：3 个输入特征 -> 3 个神经元
        self.linear1 = nn.Linear(3, 3)
        nn.init.xavier_normal_(self.linear1.weight)   # 后面接 sigmoid
        nn.init.zeros_(self.linear1.bias)

        # 第 2 个隐藏层：上一层的 3 个输出 -> 2 个神经元
        self.linear2 = nn.Linear(3, 2)
        nn.init.kaiming_normal_(self.linear2.weight, nonlinearity='relu')
        nn.init.zeros_(self.linear2.bias)

        # 输出层：2 -> 2
        self.out = nn.Linear(2, 2)

    def forward(self, x):
        # 实例化后直接 model(x) 就会走到这里，不要手动调 forward
        x = torch.sigmoid(self.linear1(x))
        x = torch.relu(self.linear2(x))
        x = torch.softmax(self.out(x), dim=-1)   # dim=-1：每一行加起来为 1
        return x


if __name__ == '__main__':
    model = Model()

    # 输入是二维的 (batch_size, in_features)，输出是 (batch_size, out_features)
    data = torch.randn(5, 3)
    output = model(data)
    print('输入形状', data.shape)      # torch.Size([5, 3])
    print('输出形状', output.shape)    # torch.Size([5, 2])

    # 参数量手算：每个神经元的参数 = 输入个数 + 1 个偏置
    #   linear1: 3 个神经元 × (3 + 1) = 12
    #   linear2: 2 个神经元 × (3 + 1) = 8
    #   out    : 2 个神经元 × (2 + 1) = 6
    #   合计 26
    total = sum(p.numel() for p in model.parameters())
    print('参数总量', total)           # 26

    for name, p in model.named_parameters():
        print(name, tuple(p.shape), p.numel())

"""一条数据穿过整个网络：每一层的 z 和 a 全部打出来。

网络：3 -> 3（sigmoid）-> 2（relu）-> 2（softmax）
把每一步的形状和数值摊在眼前，前向传播就不再是黑箱。
"""
import torch
import torch.nn as nn


class TracedNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear1 = nn.Linear(3, 3)
        nn.init.xavier_normal_(self.linear1.weight)   # 后接 sigmoid，配 xavier
        nn.init.zeros_(self.linear1.bias)

        self.linear2 = nn.Linear(3, 2)
        nn.init.kaiming_normal_(self.linear2.weight, nonlinearity='relu')
        nn.init.zeros_(self.linear2.bias)

        self.out = nn.Linear(2, 2)

    def forward(self, x, trace=False):
        z1 = self.linear1(x)          # 内部状态值
        a1 = torch.sigmoid(z1)        # 激活值
        z2 = self.linear2(a1)
        a2 = torch.relu(z2)
        z3 = self.out(a2)
        a3 = torch.softmax(z3, dim=-1)

        if trace:
            for name, t in (('输入 x', x), ('z1', z1), ('a1=sigmoid(z1)', a1),
                            ('z2', z2), ('a2=relu(z2)', a2),
                            ('z3 原始分数', z3), ('a3=softmax(z3)', a3)):
                print('%-16s 形状 %-10s %s'
                      % (name, str(tuple(t.shape)),
                         [round(v, 4) for v in t.detach().flatten().tolist()]))
        return a3


def main():
    torch.manual_seed(3)
    net = TracedNet()

    # 一条样本也要补出 batch 维：全连接网络只吃二维数据
    one = torch.randn(1, 3)
    print('== 单条样本穿过网络 ==')
    prob = net(one, trace=True)
    print('概率之和 = %.6f，预测类别 = %d'
          % (prob.sum().item(), prob.argmax(dim=-1).item()))

    print('\n== 一批 5 条样本 ==')
    batch = torch.randn(5, 3)
    out = net(batch)
    print('输入形状', tuple(batch.shape), '-> 输出形状', tuple(out.shape))
    print('每一行各自加起来为 1：',
          [round(v, 6) for v in out.sum(dim=-1).tolist()])

    # 同层神经元之间没有任何连线：把 a1 的某一维改掉，
    # 只会影响下一层，不会影响 a1 的其他维度。
    print('\n== 逐层看形状变化 ==')
    print('3 个输入特征 -> 隐藏层 1 的 3 个神经元 -> 隐藏层 2 的 2 个神经元 -> 2 个输出')
    print('参数量 =', sum(p.numel() for p in net.parameters()),
          '（手算 3×4 + 2×4 + 2×3 = 26）')


if __name__ == '__main__':
    main()

"""用 nn.Module 搭网络的三种写法，结构完全等价，挑顺手的用。

同一个结构：4 -> 8（relu）-> 8（relu）-> 3
三种写法建出来的参数量必须相同，最后一段验证这一点。
"""
from collections import OrderedDict

import torch
import torch.nn as nn


# ------------------------------------------------------------ 写法一：最常用
class NetA(nn.Module):
    """__init__ 里定义层，forward 里写数据怎么流。

    层数不多、但中间要做拼接/分支/取中间结果时，只能用这种写法。
    """

    def __init__(self):
        super().__init__()                  # 必须先调父类初始化，否则层注册不上
        self.fc1 = nn.Linear(4, 8)
        self.fc2 = nn.Linear(8, 8)
        self.out = nn.Linear(8, 3)

    def forward(self, x):
        # 实例化后写 model(x) 就会走到这里，不要手动写 model.forward(x)
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.out(x)                  # 多分类到此为止，softmax 交给损失函数


# ------------------------------------------------------------ 写法二：Sequential
class NetB(nn.Module):
    """纯粹一条直线堆下去时，用 Sequential 省掉整个 forward 的手写。"""

    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(4, 8), nn.ReLU(),
            nn.Linear(8, 8), nn.ReLU(),
            nn.Linear(8, 3),
        )

    def forward(self, x):
        return self.net(x)


# ------------------------------------------------------------ 写法三：带名字
class NetC(nn.Module):
    """给每层起名字，打印模型和按名字取层时都方便。"""

    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(OrderedDict([
            ('fc1', nn.Linear(4, 8)),
            ('act1', nn.ReLU()),
            ('fc2', nn.Linear(8, 8)),
            ('act2', nn.ReLU()),
            ('out', nn.Linear(8, 3)),
        ]))

    def forward(self, x):
        return self.net(x)


def count(model):
    return sum(p.numel() for p in model.parameters())


if __name__ == '__main__':
    a, b, c = NetA(), NetB(), NetC()

    x = torch.randn(6, 4)
    for name, m in (('NetA', a), ('NetB', b), ('NetC', c)):
        print('%s 输出形状 %s  参数量 %d'
              % (name, tuple(m(x).shape), count(m)))

    # 手算核对：8×(4+1) + 8×(8+1) + 3×(8+1) = 40 + 72 + 27 = 139
    print('手算参数量 =', 8 * (4 + 1) + 8 * (8 + 1) + 3 * (8 + 1))

    print('\n直接打印模型，能看到层的嵌套结构：')
    print(c)

    print('\n按名字取出某一层：', c.net.fc1)
    print('遍历全部可训练参数：')
    for name, p in a.named_parameters():
        print('  %-12s %-10s %d' % (name, tuple(p.shape), p.numel()))

"""神经元死亡：ReLU 的负半轴梯度为 0，一旦掉进去就再也出不来。

复现路径很简单——把某个神经元的偏置调得很负，
它对所有样本的内部状态值 z 都小于 0，
于是激活值恒为 0、梯度恒为 0、权重永远不更新，这个神经元就废了。
"""
import torch
import torch.nn as nn


def dead_neuron():
    torch.manual_seed(0)

    layer = nn.Linear(4, 3)
    with torch.no_grad():
        # 让 1 号神经元的偏置极负，制造一个必死的神经元
        layer.bias[1] = -50.0

    x = torch.randn(32, 4)
    z = layer(x)
    a = torch.relu(z)

    print('每个神经元的 z 最大值：', [round(v, 3) for v in z.max(dim=0).values.tolist()])
    print('每个神经元被激活的样本比例：',
          [round(v, 3) for v in (a > 0).float().mean(dim=0).tolist()])

    a.sum().backward()
    print('每个神经元收到的权重梯度绝对值之和：',
          [round(v, 8) for v in layer.weight.grad.abs().sum(dim=1).tolist()])
    print('1 号神经元的梯度是 0，它的权重从此纹丝不动——这就是神经元死亡')


def leaky_fix():
    """LeakyReLU 给负半轴留一个很小的斜率，梯度不再是 0。"""
    x = torch.tensor([-3.0, -1.0, 0.0, 1.0, 3.0], requires_grad=True)

    torch.relu(x).sum().backward()
    relu_grad = x.grad.clone().tolist()

    x.grad.zero_()
    nn.LeakyReLU(negative_slope=0.01)(x).sum().backward()
    leaky_grad = x.grad.clone().tolist()

    print('%8s %12s %12s' % ('x', 'ReLU 导数', 'LeakyReLU 导数'))
    for i, v in enumerate([-3.0, -1.0, 0.0, 1.0, 3.0]):
        print('%8.1f %12.2f %12.2f' % (v, relu_grad[i], leaky_grad[i]))
    print('负半轴 ReLU 是 0、LeakyReLU 是 0.01：小是小，但不为 0，还能爬回来')


def how_to_avoid():
    """真正的预防手段不是换激活函数，而是别让 z 一开始就跑偏。"""
    x = torch.randn(512, 128)

    for std in (0.01, 0.05, 0.2, 1.0):
        w = torch.randn(64, 128) * std
        b = torch.zeros(64)
        a = torch.relu(x @ w.t() + b)
        dead = (a.sum(dim=0) == 0).float().mean().item()
        print('权重 std=%-5s  整批样本都没激活过的神经元占比 %5.1f%%'
              % (std, dead * 100))

    print('把学习率压下来、用 kaiming 初始化，都是同一个目的：')
    print('别让某一步更新把 z 整体推到负半轴去。')


if __name__ == '__main__':
    dead_neuron()
    print('-' * 52)
    leaky_fix()
    print('-' * 52)
    how_to_avoid()

"""网络结构骨架模板：只管定义模型，训练循环见训练骨架。"""
import torch
import torch.nn as nn


class MyNet(nn.Module):
    """把 TODO 填掉即可。层与层之间的维度必须首尾相接。"""

    def __init__(self, in_features, out_features, hidden=(128, 256)):
        super().__init__()                       # 必须先调父类初始化

        # TODO: 按需要增减隐藏层；hidden 里写每层的神经元个数
        self.fc1 = nn.Linear(in_features, hidden[0])
        self.fc2 = nn.Linear(hidden[0], hidden[1])
        self.out = nn.Linear(hidden[1], out_features)

        # TODO: 隐藏层用 ReLU 就配 kaiming，用 sigmoid/tanh 就配 xavier
        for layer in (self.fc1, self.fc2):
            nn.init.kaiming_normal_(layer.weight, nonlinearity='relu')
            nn.init.zeros_(layer.bias)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        # TODO: 多分类到此为止，softmax 交给 CrossEntropyLoss；
        #       二分类才在这里补 torch.sigmoid；回归直接返回。
        return self.out(x)


if __name__ == '__main__':
    net = MyNet(in_features=20, out_features=4)
    print(net)
    print('参数量', sum(p.numel() for p in net.parameters()))
    print(net(torch.randn(8, 20)).shape)        # torch.Size([8, 4])