Opérations de régularisation, de découpage de gradient et d'initialisation de biais dans les modèles profonds

Récemment, j'ai débogué le code et j'ai découvert que peu importe comment le déboguer, j'ai pensé à utiliser certaines méthodes d'optimisation, puis je ne connaissais pas les détails spécifiques de ces méthodes d'optimisation, alors j'ai appris un peu et je l'ai enregistré ici pour référence future.

Régularisation

Méthodes de régularisation couramment utilisées

Régularisation L1

La régularisation L1 est une méthode de régularisation basée sur la norme L1, et sa formule mathématique est :

$$L=L_{dunt}+je\sum _{je=1}|w_{}|$$

où $L_{dunt}$est la perte de données, $w_{}$est le paramètre du modèle, $\lambda$ est un paramètre de régularisation. Le rôle de la régularisation L1 est de punir la valeur absolue des paramètres du modèle, de sorte que certains paramètres deviennent 0, afin d'obtenir l'effet de sélection des caractéristiques et de réduire la complexité du modèle.

Régularisation L2

La régularisation L2 est une méthode de régularisation basée sur la norme L2, et sa formule mathématique est :

$$L=L_{dunt}+je\sum _{je=1}{w}_{je}^{}$$

où $L_{dunt}$est la perte de données, $w_{}$est le paramètre du modèle, $\lambda$ est un paramètre de régularisation. Le rôle de la régularisation L2 est de punir la somme des carrés des paramètres du modèle, en rendant la distribution des poids du modèle plus lisse, en réduisant la complexité du modèle et en évitant le surajustement.

Régularisation des abandons

La régularisation d'abandon est une méthode de régularisation de désactivation aléatoire, et sa formule mathématique est :

$$y=\frac{}{1-p}\times X\times m$$

où $p$ est la probabilité de conserver le nœud,$x$ est l'entrée,$m$ est un masque binarisé, indiquant quels nœuds sont conservés et quels nœuds sont désactivés au hasard. La fonction de la régularisation Dropout est de supprimer aléatoirement certains nœuds, réduisant ainsi la co-adaptation dans le modèle et évitant le surajustement.

augmentation des données

L'augmentation de données est une méthode de régularisation basée sur l'augmentation de données, et sa formule mathématique est :

$$X_{un}=f\left(x\right)$$

où $x$ est la donnée d'origine,$f$ est la fonction d'amélioration des données,$X_{un}$pour les données enrichies. L'augmentation des données peut étendre l'ensemble de données en recadrant, faisant pivoter, retournant, mettant à l'échelle, etc. de manière aléatoire, afin d'améliorer la capacité de généralisation du modèle et d'éviter le surajustement.

Régularisation max-norm du noyau

https://github.com/kevinzakka/pytorch-goodies#max-norm-constraint

《Améliorer les réseaux de neurones en empêchant la co-adaptation des détecteurs de caractéristiques》

La régularisation de la norme maximale du noyau est une méthode de régularisation couramment utilisée, qui peut limiter la norme maximale de la valeur de poids de chaque noyau de convolution dans le réseau de neurones, de manière à contrôler le degré de surajustement.

La régularisation max-norm du noyau n'est valide que pendant la formation, vous devez donc définir les paramètres correspondants lors de la compilation du modèle. Vous n'avez pas besoin d'utiliser cette méthode de régularisation lors des tests ou des prédictions.

Si la norme L2 du vecteur de poids d'une unité cachée $L$ devient toujours plus grand qu'une certaine valeur maximale$c$ , multiplier le vecteur poids par$c/L$ . Appliquez-le immédiatement après chaque mise à jour du vecteur de poids ou après chaqueXXMise à jour du dégradé$X.$

Cette contrainte est une autre forme de régularisation. Alors que L2 pénalise les poids élevés à l'aide de la fonction de perte, la « norme max » agit directement sur les poids. L2 exerce une pression constante pour déplacer les poids près de zéro, ce qui pourrait jeter des informations utiles lorsque la fonction de perte n'incite pas les poids à rester loin de zéro. D'un autre côté, la «norme max» ne conduit jamais les poids à près de zéro. Tant que la norme est inférieure à la valeur de la contrainte, la contrainte n'a aucun effet.

La première méthode de mise en œuvre :

def max_norm(model, max_val=3, eps=1e-8):
    for name, param in model.named_parameters():
        if 'bias' not in name:
            norm = param.norm(2, dim=0, keepdim=True)
            desired = torch.clamp(norm, 0, max_val)
            param = param * (desired / (eps + norm))

La deuxième méthode de mise en œuvre :

class Conv2dWithConstraint(nn.Conv2d):
    def __init__(self, *args, doWeightNorm = True, max_norm=1, **kwargs):
        self.max_norm = max_norm
        self.doWeightNorm = doWeightNorm
        super(Conv2dWithConstraint, self).__init__(*args, **kwargs)

    def forward(self, x):
        if self.doWeightNorm: 
            self.weight.data = torch.renorm(
                self.weight.data, p=2, dim=0, maxnorm=self.max_norm
            )
        return super(Conv2dWithConstraint, self).forward(x)

class Conv1dWithConstraint(nn.Conv1d):
    def __init__(self, *args, doWeightNorm = True, max_norm=1, **kwargs):
        self.max_norm = max_norm
        self.doWeightNorm = doWeightNorm
        super(Conv1dWithConstraint, self).__init__(*args, **kwargs)

    def forward(self, x):
        if self.doWeightNorm: 
            self.weight.data = torch.renorm(
                self.weight.data, p=2, dim=0, maxnorm=self.max_norm
            )
        return super(Conv1dWithConstraint, self).forward(x)


class LinearWithConstraint(nn.Linear):
    def __init__(self, *args, doWeightNorm = True, max_norm=1, **kwargs):
        self.max_norm = max_norm
        self.doWeightNorm = doWeightNorm
        super(LinearWithConstraint, self).__init__(*args, **kwargs)

    def forward(self, x):
        if self.doWeightNorm: 
            self.weight.data = torch.renorm(
                self.weight.data, p=2, dim=0, maxnorm=self.max_norm
            )
        return super(LinearWithConstraint, self).forward(x)

Quel est le principe de l'ajout de la régularisation L1 et L2 à la perte pour obtenir l'effet d'empêcher le surajustement ?

L'ajout d'un terme de régularisation à la fonction de perte est un moyen courant d'éviter le surajustement. Le principe de base est 对模型参数进行约束de réduire la complexité du modèle de , afin d'éviter que le modèle ne surajuste les données d'apprentissage.

Plus précisément, le terme de régularisation a généralement deux formes : régularisation L1 et régularisation L2. La régularisation L1 consiste à utiliser la valeur absolue du paramètre du modèle comme terme de régularisation, et la régularisation L2 consiste à utiliser le carré du paramètre du modèle comme terme de régularisation. 在损失函数中加入正则化项后，优化器在训练模型时不仅需要最小化损失函数的输出值，还需要最小化正则化项的输出值，从而使得模型参数尽量接近于0.

L'ajout d'un terme de régularisation a pour effet d'empêcher la valeur des paramètres du modèle de devenir trop grande, évitant ainsi que le modèle ne surajuste les données d'apprentissage . En effet, lorsque les paramètres du modèle sont trop grands, le modèle sur-adapte aux données d'apprentissage et ne parvient pas à se généraliser aux données de test. Grâce aux contraintes du terme de régularisation, la valeur des paramètres du modèle sera contrôlée dans une plage plus petite, rendant le modèle plus généralisable.

Il convient de noter que la force de contrainte du terme de régularisation est contrôlée par le paramètre de régularisation, c'est-à-dire que plus le paramètre de régularisation est grand, plus la valeur du paramètre de modèle est proche de 0 . Cependant, un paramètre de régularisation trop grand peut également conduire à un sous-ajustement du modèle, il est donc nécessaire de sélectionner un paramètre de régularisation approprié en fonction de la situation spécifique.

Quelle est la différence entre la régularisation L1 et la régularisation L2

La régularisation L1 est obtenue en imposant des contraintes sur la norme L1 sur les paramètres de poids. Concrètement, la régularisation L1 consiste à additionner la valeur absolue de chaque élément dans le paramètre de poids, puis à la multiplier par un coefficient de régularisation λ pour obtenir un terme de régularisation, qui s'ajoute à la fonction objectif. 通过L1正则化可以使得部分权重参数变成0，从而实现特征选择的效果，即去除对模型影响较小的特征.

La régularisation L2 est obtenue en imposant une contrainte sur la norme L2 sur les paramètres de poids. Concrètement, la régularisation L2 consiste à additionner le carré de chaque élément dans le paramètre de poids, puis à le multiplier par un coefficient de régularisation λ pour obtenir un terme de régularisation, qui s'ajoute à la fonction objectif. 通过L2正则化可以使得权重参数的值变得更加平滑，从而减少模型的复杂度，提高模型的泛化性能.

Quel effet la valeur du coefficient de régularisation λ a-t-elle sur le modèle ?

1. Lorsque le coefficient de régularisation λ est petit, la capacité d'ajustement du modèle est plus forte et les données d'apprentissage peuvent être mieux ajustées, mais le problème de surajustement peut survenir, entraînant une mauvaise performance du modèle sur les données de test.
2. Lorsque le coefficient de régularisation λ est grand, la capacité d'ajustement du modèle est faible, ce qui peut éviter le problème de surajustement, mais le problème de sous-ajustement peut survenir, entraînant de mauvaises performances du modèle sur les données d'apprentissage.

Comment déterminer la meilleure valeur du coefficient de régularisation λ

Déterminer la valeur optimale du coefficient de régularisation λ est un problème courant en apprentissage profond. Il existe de nombreuses façons de résoudre ce problème. Voici quelques méthodes couramment utilisées :

Recherche de grille

La recherche par grille est une méthode simple mais efficace qui permet de trouver le meilleur coefficient de régularisation λ. Plus précisément, un ensemble de coefficients de régularisation candidats λ peut être défini dans un premier temps, puis une recherche exhaustive est effectuée parmi ces valeurs, et enfin le coefficient de régularisation λ qui rend le modèle le plus performant sur l'ensemble de validation est sélectionné.

Recherche aléatoire

La recherche aléatoire est une méthode plus efficace qui peut être utilisée pour trouver le meilleur coefficient de régularisation λ. Plus précisément, vous pouvez d'abord définir une distribution de la valeur d'un ensemble de coefficients de régularisation λ, puis échantillonner au hasard dans ces distributions, et enfin sélectionner le coefficient de régularisation λ qui rend le modèle le plus performant sur l'ensemble de validation.

Validation croisée

La validation croisée est une méthode courante qui peut être utilisée pour évaluer les performances de généralisation du modèle et choisir le meilleur coefficient de régularisation λ. Plus précisément, l'ensemble de données peut être divisé en ensemble d'apprentissage et en ensemble de validation, puis entraîner le modèle sur l'ensemble d'apprentissage, utiliser l'ensemble de validation pour sélectionner le meilleur coefficient de régularisation λ, et enfin utiliser l'ensemble de test pour évaluer les performances de généralisation du modèle. .

Régularisation adaptative des poids

Le taux d'apprentissage adaptatif avec régularisation est un moyen efficace d'optimiser simultanément les paramètres de poids et le coefficient de régularisation λ. Plus précisément, un terme de pénalité peut être ajouté à la fonction de perte afin que les paramètres de poids soient optimisés avec le coefficient de régularisation λ. Cette méthode peut ajuster automatiquement la valeur du coefficient de régularisation λ pour obtenir de meilleures performances de généralisation.

Comment ajouter la régularisation L2 au modèle

Voici un exemple de code qui utilise PyTorch pour définir un cadre d'apprentissage en profondeur simple et ajoute une régularisation L2 :

import torch
import torch.nn as nn
import torch.optim as optim

# 定义模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(784, 64)
        self.fc2 = nn.Linear(64, 10)

    def forward(self, x):
        x = x.view(-1, 784)
        x = nn.functional.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 创建模型实例
model = Net()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, weight_decay=0.01)

# 训练模型
for epoch in range(10):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data

        # 梯度清零
        optimizer.zero_grad()

        # 前向传播
        outputs = model(inputs)

        # 计算损失
        loss = criterion(outputs, labels)

        # 反向传播
        loss.backward()

        # 更新参数
        optimizer.step()

        running_loss += loss.item()

    print('Epoch %d, loss: %.3f' % (epoch + 1, running_loss / len(trainloader)))

Après avoir défini le paramètre weight_decay dans l'optimiseur, l'optimiseur ajoutera automatiquement le terme de régularisation à la mise à jour du gradient, réalisant ainsi la régularisation L2.

Le paramètre weight_decay dans la fonction d'optimisation de pytorch régularise-t-il tous les paramètres du réseau ?

Dans PyTorch, le paramètre weight_decay de l'optimiseur est utilisé pour contrôler la force de la régularisation L2 (également appelée décroissance du poids). Lorsque le paramètre weight_decay est défini, l'optimiseur effectuera une régularisation L2 sur tous les paramètres chaque fois que les paramètres sont mis à jour , c'est-à-dire qu'il multipliera la valeur de mise à jour de chaque paramètre par un facteur inférieur à 1, et ce facteur est la valeur du paramètre weight_decay . Par conséquent, le paramètre weight_decay régularise tous les paramètres du réseau.

Il convient de noter que le paramètre weight_decay a des significations différentes pour différents optimiseurs. Dans les optimiseurs tels que SGD et Adam, le paramètre weight_decay contrôle la force de la régularisation L2 ; dans les optimiseurs tels que RMSprop, le paramètre weight_decay contrôle le coefficient de régularisation L2 . Par conséquent, lors de l'utilisation de différents optimiseurs, il est nécessaire d'ajuster la valeur du paramètre weight_decay en fonction de la situation spécifique pour obtenir de meilleures performances de généralisation. En outre, certains optimiseurs fournissent également d'autres méthodes de régularisation, telles que les optimiseurs AdamW et LAMB, qui peuvent contrôler davantage l'effet de la régularisation lors de l'utilisation de ces optimiseurs.

Quelle est la différence dans la signification du paramètre weight_decay dans des optimiseurs tels que SGD et Adam et dans des optimiseurs tels que RMSprop ?

Dans les optimiseurs tels que SGD et Adam, le paramètre weight_decay est généralement utilisé pour contrôler la force de la régularisation L2. Plus précisément, weight_decay参数会在每次参数更新时对参数值进行衰减，从而使得权重参数尽量分散，防止过拟合. Dans SGD et Adam, le paramètre weight_decay équivaut à ajouter un terme de régularisation L2 à la fonction de perte, c'est-à-dire à multiplier la somme des carrés du poids par un coefficient de décroissance du poids, contraignant ainsi la norme du paramètre de poids.

Dans les optimiseurs tels que RMSprop, la signification du paramètre weight_decay est différente et il est utilisé pour contrôler le coefficient de régularisation L2. Plus précisément, weight_decay参数会在计算梯度平方的移动平均值时，对其进行加权衰减，从而使得梯度的范数尽量分散，防止过拟合. Dans RMSprop, le paramètre weight_decay équivaut à ajouter un terme de régularisation L2 au-dessus du gradient, c'est-à-dire à multiplier la somme des carrés du poids par un coefficient de décroissance du poids, contraignant ainsi la norme du paramètre de poids.

Quelle est la différence entre l'algorithme d'optimisation Adam et l'algorithme d'optimisation AdamW

La décroissance du poids dans l'algorithme d'optimisation d'Adam est implémentée sur la base de la régularisation L2, c'est-à-dire que le paramètre de poids est multiplié par un coefficient de décroissance du poids chaque fois que le paramètre est mis à jour. Cependant, cette méthode va soumettre la mise à jour des paramètres de poids à des contraintes plus importantes, 特别是在学习率较小时，可能会导致模型的收敛速度减慢.

Afin de résoudre ce problème, l'algorithme d'optimisation AdamW propose une nouvelle méthode de décroissance des poids. Dans AdamW, la décroissance du poids est implémentée sur la base de la somme pondérée de la régularisation L2 et de la décroissance du poids , c'est-à-dire qu'à chaque mise à jour des paramètres, le paramètre de poids est multiplié par une somme pondérée d'un coefficient de régularisation L2 et d'un coefficient de décroissance du poids. De cette façon, cela fonctionne 缓解权重参数更新受到较大约束的问题，同时还可以防止过拟合.

À l'exception de la gestion différente de la perte de poids, AdamW et Adam sont fondamentalement les mêmes à d'autres égards. Ce sont tous des algorithmes d'optimisation basés sur le taux d'apprentissage adaptatif, qui peuvent ajuster automatiquement le taux d'apprentissage en fonction de différents modèles et ensembles de données. De plus, les deux peuvent gérer des problèmes tels que les gradients clairsemés et les fonctions objectifs non stationnaires.

En termes d'application, l'algorithme d'optimisation d'Adam est plus adapté à la plupart des tâches d'apprentissage en profondeur, en particulier pour les modèles comportant de nombreux paramètres , les performances d'Adam sont généralement meilleures que les algorithmes d'optimisation de base tels que SGD. L' algorithme d'optimisation AdamW est plus adapté pour traiter le problème de la décroissance du poids, en particulier lorsque le taux d'apprentissage est faible , AdamW peut mieux contrôler la mise à jour des paramètres de poids, améliorant ainsi les performances de généralisation du modèle. Par conséquent, dans les tâches nécessitant une perte de poids, l'utilisation d'AdamW peut permettre d'obtenir de meilleures performances.

Comment ajouter un terme de régularisation à une certaine couche du modèle

Voici un exemple de code qui montre comment implémenter la régularisation pour une couche dans PyTorch :

import torch
import torch.nn as nn
import torch.optim as optim

# 定义模型
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.lin1 = nn.Linear(10, 10)
        self.lin2 = nn.Linear(10, 5)
    
    def forward(self, x):
        x = self.lin1(x)
        x = nn.functional.relu(x)
        x = self.lin2(x)
        return x

model = MyModel()

# 定义正则化项的权重
weight_decay = 0.01

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
for epoch in range(10):
    running_loss = 0.0
    for i in range(100):
        # 获取数据和标签
        inputs = torch.randn(10)
        labels = torch.randint(0, 5, (1,)).long()
        
        # 清空梯度
        optimizer.zero_grad()
        
        # 前向传播和计算损失
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        
        # 计算正则化项
        reg_loss = 0.0
        for name, param in model.named_parameters():
            if 'weight' in name:
                reg_loss += torch.norm(param, p=2)**2
                
        # 总损失为交叉熵损失加上正则化项
        total_loss = loss + weight_decay * reg_loss
        
        # 反向传播和计算梯度
        total_loss.backward()
        
        # 更新参数
        optimizer.step()
        
        running_loss += loss.item()
    
    print("Epoch %d, loss: %.3f" % (epoch+1, running_loss/100))

Dans le code ci-dessus, nous définissons d'abord un modèle simple appelé MyModel, qui contient deux couches entièrement connectées. Ensuite, nous définissons le poids weight_decay du terme de régularisation. Pendant le processus de formation, lors du calcul de la perte totale, nous ajoutons le produit de la perte d'entropie croisée et du terme de régularisation à la perte totale pour obtenir une régularisation pour une certaine couche.

Il convient de noter que pour différents modèles et tâches, le type et le poids des termes de régularisation les plus appropriés peuvent être différents. Habituellement, nous pouvons trouver une stratégie de régularisation appropriée en essayant différentes méthodes de régularisation et valeurs de poids, afin d'obtenir de meilleures performances du modèle.

Ajouter clip_grad_norm_ au modèle

Voici un exemple de code utilisant le framework PyTorch qui montre comment utiliser la fonction torch.nn.utils.clip_grad_norm_() pour découper les dégradés pendant la formation du modèle :

import torch
import torch.nn as nn
import torch.optim as optim

# 定义模型
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.lin1 = nn.Linear(10, 10)
        self.lin2 = nn.Linear(10, 5)
    
    def forward(self, x):
        x = self.lin1(x)
        x = nn.functional.relu(x)
        x = self.lin2(x)
        return x

model = MyModel()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
for epoch in range(10):
    running_loss = 0.0
    for i in range(100):
        # 获取数据和标签
        inputs = torch.randn(10)
        labels = torch.randint(0, 5, (1,)).long()
        
        # 清空梯度
        optimizer.zero_grad()
        
        # 前向传播和计算损失
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        
        # 反向传播和计算梯度
        loss.backward()
        
        # 对梯度进行裁剪
        nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
        
        # 更新参数
        optimizer.step()
        
        running_loss += loss.item()
    
    print("Epoch %d, loss: %.3f" % (epoch+1, running_loss/100))

Dans le code ci-dessus, nous définissons d'abord un modèle simple appelé MyModel, qui contient deux couches entièrement connectées. Ensuite, nous définissons la fonction de perte et l'optimiseur, et commençons à entraîner le modèle. Lors du processus de rétropropagation de chaque mini-lot de données, nous utilisons la fonction nn.utils.clip_grad_norm_() pour découper le gradient du modèle afin d'éviter le problème d'explosion du gradient. Après cela, nous appelons la fonction step() de l'optimiseur pour mettre à jour les paramètres du modèle.

Il convient de noter que pour différents modèles et tâches, le seuil d'écrêtage de gradient le plus approprié peut être différent. Habituellement, nous pouvons trouver une plage d'écrêtage appropriée en ajustant la taille du seuil, afin d'obtenir de meilleures performances du modèle.

Quel est le rôle de la régularisation et du gradient clipping, quelle est la différence et dans quelles circonstances sont-ils utilisés

La régularisation et l'écrêtage du gradient sont des techniques d'optimisation de modèle couramment utilisées, et leur fonction est d'éviter le problème de surajustement du modèle ou d'explosion du gradient. Bien que les deux technologies servent un objectif similaire, elles sont mises en œuvre et utilisées dans des situations légèrement différentes.

Le rôle de la régularisation est d'éviter le problème de surajustement du modèle en ajoutant des contraintes sur les paramètres du modèle dans la fonction de perte . Les méthodes de régularisation courantes incluent la régularisation L1, la régularisation L2, etc. Dans le processus de mise en œuvre, nous pouvons ajouter un élément de régularisation (comme la norme du poids) à la fonction de perte pour pénaliser la taille des paramètres du modèle, afin de réaliser les contraintes sur le modèle. La régularisation est généralement appliquée lors de la formation du modèle pour réduire l'erreur de généralisation du modèle.

La fonction du gradient clipping est d'éviter le problème d'explosion du gradient en limitant le gradient du modèle . Lorsque le gradient du modèle est trop important, on peut le limiter à une plage raisonnable en écrêtant le gradient, évitant ainsi une mise à jour excessive des paramètres du modèle. L'écrêtage du gradient est généralement appliqué dans le processus de rétropropagation de l'optimiseur pour éviter l'impact de l'explosion du gradient sur le modèle.

la différence:

1. La régularisation consiste à contraindre les paramètres du modèle, tandis que l'écrêtage du gradient consiste à limiter le gradient.
2. La régularisation peut éviter le surajustement du modèle, et l'écrêtage du gradient peut éviter l'explosion du gradient.
3. La régularisation est généralement appliquée lors de la formation du modèle, tandis que l'écrêtage du gradient est généralement appliqué lors de la rétropropagation de l'optimiseur.

scènes à utiliser :

1. La régularisation est généralement appliquée lorsque le modèle est surajusté. Lorsque le modèle fonctionne bien sur l'ensemble d'apprentissage, mais pas sur l'ensemble de test, vous pouvez essayer d'utiliser des techniques de régularisation.
2. L'écrêtage de gradient est généralement applicable à la situation où le modèle a une explosion de gradient.Lorsque le gradient du modèle est trop important, la mise à jour des paramètres du modèle est trop drastique et affecte les performances du modèle, vous pouvez essayer d'utiliser le gradient technique de découpage.

Initialiser le biais de la couche convolutive à 0

Dans la plupart des frameworks d'apprentissage en profondeur, cela peut être réalisé en définissant le paramètre d'initialisation de biais de la couche convolutive sur 0. Voici un exemple de code utilisant Python et le framework PyTorch :

import torch.nn as nn

# 定义卷积层（具体参数可以根据实际情况进行修改）
conv_layer = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1, bias=True)

# 将卷积层的偏置初始化为0
conv_layer.bias.data.fill_(0.0)

Dans le code ci-dessus, nous utilisons d'abord le framework PyTorch pour définir une couche convolutive conv_layer, et spécifions que la couche doit contenir un biais via le paramètre bias=True. Ensuite, nous initialisons le biais de la couche convolutive à 0 via conv_layer.bias.data.fill_(0.0).