TechCodeview

PyTorch fournit le module torch.nn pour nous aider dans la création et la formation du réseau neuronal. Nous allons d'abord entraîner le réseau neuronal de base sur l'ensemble de données MNIST sans utiliser aucune fonctionnalité de ces modèles. Nous utiliserons uniquement la fonctionnalité de base du tenseur PyTorch, puis nous ajouterons progressivement une fonctionnalité de torch.nn à la fois.

torch.nn nous propose de nombreux autres cours et modules pour implémenter et former le réseau neuronal.

Le package nn contient les modules et classes suivants :

Oui Non	Classe et module	Description
1.	torch.nn.Paramètre	C'est un type de tenseur qui est à considérer comme un paramètre de module.
2.	Conteneurs
1) torch.nn.Module	Il s'agit d'une classe de base pour tous les modules de réseau neuronal.
2) torch.nn.Séquentiel	Il s'agit d'un conteneur séquentiel dans lequel les modules seront ajoutés dans le même ordre qu'ils sont passés dans le constructeur.
3) torch.nn.ModuleList	Cela contiendra les sous-modules dans une liste.
4) torch.nn.ModuleDict	Cela contiendra les sous-modules dans un répertoire.
5) torch.nn.ParameterList	Cela contiendra les paramètres dans une liste.
6) torch.nn.parameterDict	Cela contiendra les paramètres dans un répertoire.
3.	Couches de convolution
1) torch.nn.Conv1d	Ce package sera utilisé pour appliquer une convolution 1D sur un signal d'entrée composé de plusieurs plans d'entrée.
2) torch.nn.Conv2d	Ce package sera utilisé pour appliquer une convolution 2D sur un signal d'entrée composé de plusieurs plans d'entrée.
3) torch.nn.Conv3d	Ce package sera utilisé pour appliquer une convolution 3D sur un signal d'entrée composé de plusieurs plans d'entrée.
4) torch.nn.ConvTranspose1d	Ce package sera utilisé pour appliquer un opérateur de convolution transposé 1D sur une image d'entrée composée de plusieurs plans d'entrée.
5) torch.nn.ConvTranspose2d	Ce package sera utilisé pour appliquer un opérateur de convolution transposé 2D sur une image d'entrée composée de plusieurs plans d'entrée.
6) torch.nn.ConvTranspose3d	Ce package sera utilisé pour appliquer un opérateur de convolution transposé 3D sur une image d'entrée composée de plusieurs plans d'entrée.
7) torch.nn.Déplier	Il est utilisé pour extraire des blocs locaux glissants d'un tenseur d'entrée par lots.
8) torch.nn.Fold	Il est utilisé pour combiner un tableau de blocs locaux glissants dans un grand tenseur contenant.
4.	Regroupement des couches
1) torch.nn.MaxPool1d	Il est utilisé pour appliquer un pooling 1D max sur un signal d'entrée composé de plusieurs plans d'entrée.
2) torch.nn.MaxPool2d	Il est utilisé pour appliquer un pooling max 2D sur un signal d'entrée composé de plusieurs plans d'entrée.
3) torch.nn.MaxPool3d	Il est utilisé pour appliquer un pooling 3D max sur un signal d'entrée composé de plusieurs plans d'entrée.
4) torch.nn.MaxUnpool1d	Il est utilisé pour calculer l'inverse partiel de MaxPool1d.
5) torch.nn.MaxUnpool2d	Il est utilisé pour calculer l'inverse partiel de MaxPool2d.
6) torch.nn.MaxUnpool3d	Il est utilisé pour calculer l'inverse partiel de MaxPool3d.
7) torch.nn.AvgPool1d	Il est utilisé pour appliquer une mutualisation moyenne 1D sur un signal d'entrée composé de plusieurs plans d'entrée.
8) torch.nn.AvgPool2d	Il est utilisé pour appliquer une mutualisation moyenne 2D sur un signal d'entrée composé de plusieurs plans d'entrée.
9) torch.nn.AvgPool3d	Il est utilisé pour appliquer une mutualisation moyenne 3D sur un signal d'entrée composé de plusieurs plans d'entrée.
10) torch.nn.FractionalMaxPool2d	Il est utilisé pour appliquer un pooling maximum fractionnaire 2D sur un signal d'entrée composé de plusieurs plans d'entrée.
11) torch.nn.LPPool1d	Il est utilisé pour appliquer une mise en commun de puissance moyenne 1D sur un signal d'entrée composé de plusieurs plans d'entrée.
12) torch.nn.LPPool2d	Il est utilisé pour appliquer une mise en commun de puissance moyenne 2D sur un signal d'entrée composé de plusieurs plans d'entrée.
13) torch.nn.AdavtiveMaxPool1d	Il est utilisé pour appliquer un pooling maximum adaptatif 1D sur un signal d'entrée composé de plusieurs plans d'entrée.
14) torch.nn.AdavtiveMaxPool2d	Il est utilisé pour appliquer un pooling maximum adaptatif 2D sur un signal d'entrée composé de plusieurs plans d'entrée.
15) torch.nn.AdavtiveMaxPool3d	Il est utilisé pour appliquer un pooling maximum adaptatif 3D sur un signal d'entrée composé de plusieurs plans d'entrée.
16) torch.nn.AdavtiveAvgPool1d	Il est utilisé pour appliquer une mise en commun moyenne adaptative 1D sur un signal d'entrée composé de plusieurs plans d'entrée.
17) torch.nn.AdavtiveAvgPool2d	Il est utilisé pour appliquer un pooling moyen adaptatif 2D sur un signal d’entrée composé de plusieurs plans d’entrée.
18) torch.nn.AdavtiveAvgPool3d	Il est utilisé pour appliquer une mise en commun moyenne adaptative 3D sur un signal d'entrée composé de plusieurs plans d'entrée.
5.	Couches de rembourrage
1) torch.nn.ReflectionPad1d	Il remplira le tenseur d'entrée en utilisant la réflexion de la limite d'entrée.
2) torch.nn.RefactionPad2d	Il remplira le tenseur d'entrée en utilisant la réflexion de la limite d'entrée.
3) torch.nn.ReplicationPad1	Il remplira le tenseur d'entrée en utilisant la réplication de la limite d'entrée.
4) torch.nn.ReplicationPad2d	Il remplira le tenseur d'entrée en utilisant la réplication de la limite d'entrée.
5) torch.nn.ReplicationPad3d	Il remplira le tenseur d'entrée en utilisant la réplication de la limite d'entrée.
6) torch.nn.ZeroPad2d	Cela remplira les limites du tenseur d'entrée avec zéro.
7) torch.nn.ConstantPad1d	Il remplira les limites du tenseur d'entrée avec une valeur constante.
8) torch.nn.ConstantPad2d	Il remplira les limites du tenseur d'entrée avec une valeur constante.
9) torch.nn.ConstantPad3d	Il remplira les limites du tenseur d'entrée avec une valeur constante.
6.	Activations non linéaires (somme pondérée, non-linéarité)
1) torch.nn.ELU	Il utilisera pour appliquer la fonction élément par élément : ELU(x)=max(0,x)+min(0,α*(exp(x)-1))
2) torch.nn.Hardshrink	Il sera utilisé pour appliquer la fonction de retrait dur par élément :
3) torch.nn.LeakyReLU	Il utilisera pour appliquer la fonction élément par élément : LeakyReLu(x)=max(0,x) + pente_négative*min(0,x)
4) torch.nn.LogSigmoïde	Il utilisera pour appliquer la fonction élément par élément :
5) torch.nn.MultiheadAttention	Il est utilisé pour permettre au modèle de prendre en compte les informations provenant de différents sous-espaces de représentation.
6) torch.nn.PReLU	Il sera utilisé pour appliquer la fonction élément par élément : PReLU(x)=max(0,x)+a*min(0,x)
7) torch.nn.ReLU	Il servira à appliquer la fonction d'unité linéaire rectifiée élément par élément : ReLU(x)=max(0,x)
8) torche.nn.ReLU6	Il sera utilisé pour appliquer la fonction élément par élément : ReLU6(x)=min(max(0,x),6)
9) torch.nn.RReLU	Il sera utilisé pour appliquer la fonction d'unité linéaire rectifiée à fuite aléatoire, par élément, comme décrit dans l'article :
10) torche.nn.SELU	Il utilisera pour appliquer la fonction élément par élément comme : SELU(x)=échelle*(max(0,x)+ min(0,a*(exp(x)-1))) Ici α = 1,6732632423543772848170429916717 et échelle = 1,0507009873554804934193349852946.
11) torche.nn.TARGET	Il utilisera pour appliquer la fonction élément par élément comme :
12) torch.nn.Sigmoïde	Il utilisera pour appliquer la fonction élément par élément comme :
13) torch.nn.Softplus	Il utilisera pour appliquer la fonction élément par élément comme :
14) torch.nn.Softshrink	Il sera utilisé pour appliquer la fonction de retrait doux par élément comme :
15) torch.nn.Softsign	Il utilisera pour appliquer la fonction élément par élément comme :
16) torche.nn.Tanh	Il utilisera pour appliquer la fonction élément par élément comme :
17) torche.nn.Tanhshrink	Il utilisera pour appliquer la fonction élément par élément comme : Tanhshrink(x)=x-Tanh(x)
18) torch.nn.Seuil	Il utilisera pour seuiller chaque élément du Tensor d'entrée. Le seuil est défini comme :
7.	Activations non linéaires (autres)
1) torch.nn.Softmin	Il est utilisé pour appliquer la fonction softmin à un tenseur d'entrée à n dimensions afin de les redimensionner. Après cela, les éléments du Tensor de sortie à n dimensions se situent dans la plage 0, 1 et la somme est égale à 1. Softmin est défini comme :
2) torch.nn.Softmax	Il est utilisé pour appliquer la fonction softmax à un tenseur d'entrée à n dimensions afin de les redimensionner. Après cela, les éléments du tenseur de sortie à n dimensions se situent dans la plage 0, 1 et la somme est égale à 1. Softmax est défini comme :
3) torch.nn.Softmax2d	Il est utilisé pour appliquer SoftMax sur les fonctionnalités à chaque emplacement spatial.
4) torch.nn.LogSoftmax	Il est utilisé pour appliquer la fonction LogSoftmax à un tenseur d'entrée à n dimensions. La fonction LofSoftmax peut être définie comme :
5) torch.nn.AdaptiveLogSoftmaxWithLoss	Il s'agit d'une stratégie de formation de modèles avec de grands espaces de sortie. C'est très efficace lorsque la répartition des étiquettes est très déséquilibrée
8.	Couches de normalisation
1) torch.nn.BatchNorm1d	Il est utilisé pour appliquer une normalisation par lots sur des entrées 2D ou 3D.
2) torch.nn.BatchNorm2d	Il est utilisé pour appliquer la normalisation par lots sur un 4D.
3) torch.nn.BatchNorm3d	Il est utilisé pour appliquer la normalisation par lots sur les entrées 5D.
4) torch.nn.GroupNorm	Il est utilisé pour appliquer une normalisation de groupe sur un mini-lot d'entrées.
5) torch.nn.SyncBatchNorm	Il est utilisé pour appliquer la normalisation par lots sur des entrées à n dimensions.
6) torch.nn.InstanceNorm1d	Il est utilisé pour appliquer une normalisation d'instance sur une entrée 3D.
7) torch.nn.InstanceNorm2d	Il permet d'appliquer une normalisation d'instance sur une entrée 4D.
8) torch.nn.InstanceNorm3d	Il est utilisé pour appliquer une normalisation d'instance sur une entrée 5D.
9) torch.nn.LayerNorm	Il est utilisé pour appliquer la normalisation des couches sur un mini-lot d'entrées.
10) torch.nn.LocalResponseNorm	Il est utilisé pour appliquer une normalisation de réponse locale sur un signal d'entrée composé de plusieurs plans d'entrée, où le canal occupe la deuxième dimension.
9.	Couches récurrentes
1) torche.nn.RNN	Il est utilisé pour appliquer un RNN Elman multicouche avec non-linéarité tanh ou ReLU à une séquence d'entrée. Chaque couche calcule la fonction suivante pour chaque élément de la séquence d'entrée : ht=tanh(WeuxXt+beux+Whhtt-1+bhh)
2) torch.nn.LSTM	Il est utilisé pour appliquer un RNN multicouche à mémoire à long terme et à court terme (LSTM) à une séquence d'entrée. Chaque couche calcule la fonction suivante pour chaque élément de la séquence d'entrée :
3) torch.nn.GRU	Il est utilisé pour appliquer un RNN d’unité récurrente à portes multicouches (GRU) à une séquence d’entrée. Chaque couche calcule la fonction suivante pour chaque élément de la séquence d'entrée :
4) torch.nn.RNNCell	Il est utilisé pour appliquer une cellule Elman RNN avec une non-linéarité tanh ou ReLU à une séquence d'entrée. Chaque couche calcule la fonction suivante pour chaque élément de la séquence d'entrée : h'=tanh(Weuxx+beux+Whhh+bhh) ReLU est utilisé à la place de tanh
5) torch.nn.LSTMCell	Il est utilisé pour appliquer une cellule de mémoire à long terme (LSTM) à une séquence d’entrée. Chaque couche calcule la fonction suivante pour chaque élément de la séquence d'entrée : Où σ est la fonction sigmoïde et * est le produit Hadamard.
6) torch.nn.GRUCell	Il est utilisé pour appliquer une cellule d'unité récurrente fermée (GRU) à une séquence d'entrée. Chaque couche calcule la fonction suivante pour chaque élément de la séquence d'entrée :
dix.	Couches linéaires
1) torch.nn.Identité	Il s'agit d'un opérateur d'identité d'espace réservé qui est insensible aux arguments.
2) torch.nn.Linéaire	Il permet d'appliquer une transformation linéaire aux données entrantes : y = xAT+b
3) torch.nn.Bilinéaire	Il permet d'appliquer une transformation bilinéaire aux données entrantes : y = x1Hache2+b
onze.	Couches abandonnées
1) torch.nn.Dropout	Il est utilisé pour la régularisation et la prévention de la co-adaptation des neurones. Un facteur de pendant la formation, le résultat est mis à l'échelle. Cela signifie que le module calcule une fonction d'identité lors de l'évaluation.
2) torch.nn.Dropout2d	Si les pixels adjacents dans les cartes de fonctionnalités sont corrélés, alors torch.nn.Dropout ne régularisera pas les activations et diminuera le taux d'apprentissage effectif. Dans ce cas, torch.nn.Dropout2d() est utilisé pour promouvoir l'indépendance entre les cartes de fonctionnalités.
3) torch.nn.Dropout3d	Si les pixels adjacents dans les cartes de fonctionnalités sont corrélés, alors torch.nn.Dropout ne régularisera pas les activations et diminuera le taux d'apprentissage effectif. Dans ce cas, torch.nn.Dropout2d () est utilisé pour promouvoir l'indépendance entre les cartes de fonctionnalités.
4) torch.nn.AlphaDropout	Il est utilisé pour appliquer Alpha Dropout sur l’entrée. Alpha Dropout est un type de Dropout qui conserve la propriété d'auto-normalisation.
12.	Couches clairsemées
1) torch.nn.Intégration	Il est utilisé pour stocker les intégrations de mots et les récupérer à l'aide d'index. L'entrée du module est une liste d'index et la sortie est l'intégration de mots correspondante.
2) torch.nn.EmbeddingBag	Il est utilisé pour calculer les sommes ou la moyenne des « sacs » d'intégration sans instancier l'intégration intermédiaire.
13.	Fonction de distance
1) torch.nn.CosineSimilarité	Il renverra la similarité cosinus entre x1 et x2, calculée selon dim.
2) torch.nn.PairwiseDistance	Il calcule la distance par paire par lot entre les vecteurs v1, v2 en utilisant la norme p :
14.	Fonction de perte
1) torch.nn.L1Perte	Il est utilisé pour un critère qui mesure l'erreur absolue moyenne entre chaque élément de l'entrée x et la cible y. La perte non réduite peut être décrite comme suit : l(x,y)=L={l1,...,ln},ln=|xn-etn|, Où N est la taille du lot.
2) torch.nn.MSELoss	Il est utilisé pour un critère qui mesure l'erreur quadratique moyenne entre chaque élément de l'entrée x et la cible y. La perte non réduite peut être décrite comme suit : l(x,y)=L={l1,...,ln},ln=(xn-etn)2, Où N est la taille du lot.
3) torch.nn.CrossEntropyLoss	Ce critère combine nn.LogSoftmax() et nn.NLLLoss() en une seule classe. C'est utile lorsque nous formons un problème de classification avec des classes C.
4) torch.nn.CTCLose	La perte de classification temporelle connexionniste calcule la perte entre une série temporelle continue et une séquence cible.
5) torch.nn.NLLLoss	La perte de log-vraisemblance négative est utilisée pour entraîner un problème de classification avec des classes C.
6) torch.nn.PoissonNLLPerte	La perte de log-vraisemblance négative avec la distribution de Poisson de t target~Poisson(input)loss(input,target)=input-target*log(target!)la cible.
7) torch.nn.KLDivLoss	Il s'agit d'une mesure de distance utile pour la distribution continue, et elle est également utile lorsque nous effectuons une régression directe sur l'espace de distribution continue de la sortie.
8) torch.nn.BCELoss	Il est utilisé pour créer un critère qui mesure l'entropie croisée binaire entre la cible et la sortie. La perte non réduite peut être décrite comme suit : l(x,y)=L={l1,...,ln},ln=-vn[etn*logxn+ (1 ann)*journal(1-xn)], Où N est la taille du lot.
9) torch.nn.BCEWithLogitsLoss	Il combine une couche sigmoïde et le BCELoss en une seule classe. Nous pouvons profiter de l’astuce log-sum-exp pour la stabilité numérique en combinant l’opération en une seule couche.
10) torch.nn.MarginRankingLoss	Il crée un critère qui mesure la perte des entrées données x1, x2, deux tenseurs de mini-lot 1D et un tenseur de mini-lot 1D d'étiquette y qui contient 1 ou -1. La fonction de perte pour chaque échantillon du mini-lot est la suivante : perte(x,y)=max(0,-y*(x1-X2)+marge
11) torch.nn.HingeEmbeddingLoss	HingeEmbeddingLoss mesure la perte d'un tenseur d'entrée x et d'un tenseur d'étiquettes y qui contiennent 1 ou -1. Il est utilisé pour mesurer si deux entrées sont similaires ou différentes. La fonction de perte est définie comme :
12) torch.nn.MultiLabelMarginLoss	Il est utilisé pour créer un critère qui optimise une perte charnière multi-classes multi-classification entre l'entrée x et la sortie y.
13) torch.nn.SmoothL1Loss	Il est utilisé pour créer un critère qui utilise un terme au carré si l'erreur absolue par élément tombe en dessous de 1 et un terme L1 dans le cas contraire. Elle est également connue sous le nom de perte de Huber :
14) torch.nn.SoftMarginLoss	Il est utilisé pour créer un critère qui optimise la perte logistique de classification en deux classes entre le tenseur d'entrée x et le tenseur cible y qui contiennent 1 ou -1.
15) torch.nn.MultiLabelSoftMarginLoss	Il est utilisé pour créer un critère qui optimise la perte multi-étiquettes un contre tous en fonction de l'entropie maximale entre l'entrée x et la cible y de taille (N, C).
16) torch.nn.CosineEmbeddingLoss	Il est utilisé pour créer un critère qui mesure la perte de tenseurs d'entrée donnés x1, x2 et une étiquette de tenseur y avec les valeurs 1 ou -1. Il est utilisé pour mesurer si deux entrées sont similaires ou différentes, en utilisant la distance cosinusoïdale.
17) torch.nn.MultiMarginLoss	Il est utilisé pour créer un critère qui optimise une perte charnière de classification multi-classe entre l'entrée x et la sortie y.
18) torch.nn.TripletMarginLoss	Il est utilisé pour créer un critère qui mesure la perte de triplet d'un tenseur d'entrée donné x1, x2, x3 et d'une marge d'une valeur supérieure à 0. Il est utilisé pour mesurer une similarité relative entre les échantillons. Un triplet est composé d'une ancre, d'un exemple positif et d'un exemple négatif. L(une,p,n)=max{d(uneje,pje)-d(uneje,nje)+marge,0}
quinze.	Couches de vision
1) torch.nn.PixelShuffle	Il permet de réarranger les éléments dans un tenseur de forme(*,C×r2,H,W) en un tenseur de forme (*,C,H×r,W,r)
2) torch.nn.Upsample	Il est utilisé pour suréchantillonner des données multicanaux 1D, 2D ou 3D données.
3) torch.nn.upsamplingNearest2d	Il est utilisé pour appliquer un suréchantillonnage 2D du plus proche voisin à un signal d'entrée composé de plusieurs canaux d'entrée.
4) torch.nn.UpsamplingBilinear2d	Il est utilisé pour appliquer un suréchantillonnage bilinéaire 2D à un signal d'entrée composé de plusieurs canaux d'entrée.
16.	Couches DataParallel (multi-GPU, distribuées)
1) torch.nn.DataParallel	Il est utilisé pour implémenter le parallélisme des données au niveau du module.
2) torch.nn.DistributedDataParallel	Il est utilisé pour implémenter le parallélisme de données distribué, basé sur le package torch.distributed au niveau du module.
3) torch.nn.DistributedDataParallelCPU	Il est utilisé pour implémenter le parallélisme de données distribué pour le CPU au niveau du module.
17.	Utilitaires
1) torch.nn.clip_grad_norm_	Il est utilisé pour découper la norme de gradient d'un itérable de paramètres.
2) torch.nn.clip_grad_value_	Il est utilisé pour découper la norme de gradient d'un itérable de paramètres à la valeur spécifiée.
3) torch.nn.parameters_to_vector	Il est utilisé pour convertir les paramètres en un seul vecteur.
4) torch.nn.vector_to_parameters	Il est utilisé pour convertir un vecteur en paramètres.
5) torch.nn.weight_norm	Il est utilisé pour appliquer la normalisation du poids à un paramètre dans le module donné.
6) torch.nn.remove_weight_norm	Il est utilisé pour supprimer la normalisation du poids et le reparamétrage d'un module.
7) torch.nn.spectral_norm	Il est utilisé pour appliquer la normalisation spectrale à un paramètre dans le module donné.
8) torch.nn.PackedSequence	Il sera utilisé pour contenir les données et la liste des batch_sizes d'une séquence compressée.
9) torch.nn.pack_padded_sequence	Il est utilisé pour emballer un Tensor contenant des séquences rembourrées de longueur variable.
10) torch.nn.pad_packed_sequence	Il est utilisé pour compléter un lot emballé de séquences de longueur variable.
11) torch.nn.pad_sequence	Il est utilisé pour compléter une liste de tenseurs de longueur variable avec une valeur de remplissage.
12) torch.nn.pack_sequence	Il est utilisé pour regrouper une liste de tenseurs de longueur variable
13) torch.nn.remove_spectral_norm	Il est utilisé pour supprimer la normalisation spectrale et le reparamétrage d'un module.

Référence:

https://pytorch.org/docs/stable/nn.html