"Édition pratique de Deep Learning Pytorch" 4.5 Dégradation du poids

4.5.1 Norme et perte de poids

Pour toute la section théorique, voir le livre pour plus de détails.

4.5.2 Régression linéaire de grande dimension

%matplotlib inline
import torch
from torch import nn
from d2l import torch as d2l

# 生成一些数据，为了使过拟合效果更明显，将维数增加到 200 并使用一个只包含 20 个样本的小训练集。
n_train, n_test, num_inputs, batch_size = 20, 100, 200, 5
true_w, true_b = torch.ones((num_inputs, 1)) * 0.01, 0.05  # 设置真实参数
train_data = d2l.synthetic_data(true_w, true_b, n_train)
train_iter = d2l.load_array(train_data, batch_size)
test_data = d2l.synthetic_data(true_w, true_b, n_test)
test_iter = d2l.load_array(test_data, batch_size, is_train=False)

4.5.3 Implémentation à partir de zéro

1. Initialiser les paramètres du modèle

def init_params():
    w = torch.normal(0, 1, size=(num_inputs, 1), requires_grad=True)
    b = torch.zeros(1, requires_grad=True)
    return [w, b]

2. Définir $L_{}$pénalité de norme

def l2_penalty(w):
    return torch.sum(w.pow(2)) / 2

3. Définir la mise en œuvre du code de formation

   La fonction de perte est importée directement via le package d2l et la perte inclut le terme de pénalité.

def train(lambd):
    w, b = init_params()
    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss
    num_epochs, lr = 100, 0.003
    animator = d2l.Animator(xlabel='epochs', ylabel='loss', yscale='log',
                            xlim=[5, num_epochs], legend=['train', 'test'])
    for epoch in range(num_epochs):
        for X, y in train_iter:
            # 增加了L2范数惩罚项，
            # 广播机制使l2_penalty(w)成为一个长度为batch_size的向量
            l = loss(net(X), y) + lambd * l2_penalty(w)
            l.sum().backward()
            d2l.sgd([w, b], lr, batch_size)
        if (epoch + 1) % 5 == 0:
            animator.add(epoch + 1, (d2l.evaluate_loss(net, train_iter, loss),
                                     d2l.evaluate_loss(net, test_iter, loss)))
    print('w的L2范数是：', torch.norm(w).item())

4. Ignorer la régularisation et s'entraîner directement

train(lambd=0)

w的L2范数是： 14.042692184448242

5. Utiliser la perte de poids

train(lambd=3)

w的L2范数是： 0.35160931944847107

4.5.4 Mise en œuvre simple

def train_concise(wd):
    net = nn.Sequential(nn.Linear(num_inputs, 1))
    for param in net.parameters():
        param.data.normal_()
    loss = nn.MSELoss(reduction='none')
    num_epochs, lr = 100, 0.003
    trainer = torch.optim.SGD([
        {
    
    "params":net[0].weight,'weight_decay': wd},  # PyTorch默认同时衰减权重和偏置，此处使用 weight_decay指定仅权重衰减
        {
    
    "params":net[0].bias}], lr=lr)
    animator = d2l.Animator(xlabel='epochs', ylabel='loss', yscale='log',
                            xlim=[5, num_epochs], legend=['train', 'test'])
    for epoch in range(num_epochs):
        for X, y in train_iter:
            trainer.zero_grad()
            l = loss(net(X), y)
            l.mean().backward()
            trainer.step()
        if (epoch + 1) % 5 == 0:
            animator.add(epoch + 1,
                         (d2l.evaluate_loss(net, train_iter, loss),
                          d2l.evaluate_loss(net, test_iter, loss)))
    print('w的L2范数：', net[0].weight.norm().item())

train_concise(0)

w的L2范数： 12.836501121520996

train_concise(3)

w的L2范数： 0.3978956639766693

pratique

(1) Utilisez λ \lambda dans le problème d'estimation de cette sectionExpérimentez avec la valeur de$\lambda \; .$Tracer la précision de la formation et la précision des tests par rapport àλ \lambdaQue peut-on observer sur le graphique d'une fonction de$\lambda \; ?$

Avec $L’augmentation\; de\; \lambda$ peut améliorer le phénomène de surapprentissage, mais$Un\; \lambda$ trop grand

for i in (0, 2, 8, 32, 128, 256):
    train_concise(i)

w的L2范数： 0.008308843709528446

---

(2) Utilisez l'ensemble de vérification pour trouver la valeur optimale $\lambda$ . Est-ce vraiment la valeur optimale ?

On ne peut pas dire qu'elle soit optimale. Après tout, la distribution de l'ensemble de validation est légèrement différente de celle de l'ensemble d'apprentissage. On peut seulement dire qu'elle est relativement proche de la valeur optimale.

---

(3) Si on utilise ${\sum }_{}|w_{}|Comme$ pénalité, nous choisissons ($L_{}$régularisation), à quoi ressemblerait la formule mise à jour ?

Si vous utilisez $L_{}$La régularisation minimise la somme de la perte de prédiction et du terme de pénalité comme :

$$LR(w,b)=\frac{}{n}\sum _{je=1}\frac{}{2}(w^T{x}^{\left(je\right)}+b-{oui}^{\left(je\right)}{)}^2+je\sum _{je=1}|w_{}|$$

$L_{}$La norme a un problème de dérivation : ici, on stipule que le point non différentiable $X=$La dérivée de$0\; est\; 0,\; alors\; :$

$$w\leftarrow w-le\frac{\partial LR(w,b}{\partial w\_}=w-\frac{}{|B|}\underset{je\in B\_}{}{X}^{\left(je\right)}(w^T{x}^{\left(je\right)}+b-{oui}^{\left(je\right)})-\text{signe}\lambda \eta \left(w\right)$$

---

(4) Nous savons que $||w|{|}^2=w^{Tw.\_}\_$_ Pouvez-vous trouver une équation matricielle similaire ? (Voir la norme Frobenius dans la section 2.3.10)

La norme de Frobenius est la racine carrée de la somme des carrés des éléments de la matrice :

$$||X|{|}_{}=\sqrt{\sum _{je=1}\sum _{j=1}{X}_{je}^{}}$$

Semblable au carré de la norme L2, le carré de la norme de Frobenius :

$$||X|{|}_F^{}=X^{TX}\_$$

---

(5) Examinez la relation entre l’erreur de formation et l’erreur de généralisation. En plus de la perte de poids, de l'augmentation des données d'entraînement et de l'utilisation de modèles de complexité appropriée, existe-t-il d'autres moyens de gérer le surapprentissage ?

Méthode de retrait temporaire d'abandon, combinaisons de modèles multiples, etc.

---

(6) Dans les statistiques bayésiennes, nous utilisons le produit du prior et de la vraisemblance, à travers la formule $P(w|X)\propto P(x|w)P\left(w\right)$ obtient le postérieur. Comment obtenir le$P\left(w\right)$？

Voir ci-dessous la vidéo " Explication bayésienne de la " régularisation L1 et L2 " par Wang Mumu , qui est essentiellement l'estimation maximale a posteriori. Comment comprendre en profondeur la formule de Bayes ? 》

En utilisant l’estimation maximale a posteriori, soit :

$$\begin{array}{rl}w& =\underset{w}{arg}P(w|X)\\ & =\underset{w}{arg}\frac{P(x|w}{P\left(x\right)}\cdot P\left(w\right)\\ & =\underset{w}{arg}P(X|w)\cdot P(w)\\ & =\underset{w}{arg}journalg\left(P\right(x|w)\cdot P(w))\\ & =\underset{w}{arg}(logo\_P(X|w)+salutgP\left(w\right)\end{array}$$

dans:

• $\left(2\right)\Rightarrow \left(3\right)$ est dû au dénominateur$P\left(x\right)$ est identique à$w$ est une constante non pertinente, elle peut donc être ignorée.
• $\left(3\right)\Rightarrow \left(4\right)$ est dû à l'ajout habituel de$\mathrm{opération}$$de\; journalisation$ .

$P\left(w\right)$ peut être choisi comme probabilité a priori

• Si nous prenons la distribution gaussienne $w\sim N(0,p^2)$, alors$L_{}$Régularisation :

$$\begin{array}{rl}salutgP\left(w\right)& =salutg\underset{je}{}\frac{}{p\sqrt{14h\_}}{e}^{-\frac{(w_{}-0{)}^{}}{14{heures}^2}}\\ & =-\frac{}{14{heures}^2}\underset{je}{}{w}_{je}^{}+\end{array}$$

• Si l'on prend la distribution de Laplace $w\sim Laplace(0,b)$ , alors$L_{}$Régularisation :

$$\begin{array}{rl}salutgP\left(w\right)& =salutg\underset{je}{}\frac{}{2b}{e}^{-\frac{|w_{}-}{b}}\\ & =-\frac{}{b}\underset{je}{}|w_{}|+\end{array}$$

Comme c’est incroyable !