Section courante

A propos

Section administrative du site

torch.nn

 Réseaux de neurones Torche
PyTorch Python

Description

Ce module contient les éléments de base des graphiques.

Liste des classes

Nom Description
Buffer Cette classe permet de représenter un Tensor faisant partie de l'état d'un module mais n'étant pas considéré comme un paramètre entraînable par l'optimiseur.
Parameter Cette classe permet de représenter un Tensor étant considéré comme un paramètre entraînable d'un module, et pour lequel les gradients sont calculés automatiquement.
UninitializedParameter Cette classe permet de marquer un paramètre comme existant mais pas encore initialisé avec des valeurs concrètes. Son initialisation est généralement différée jusqu'au premier appel du module.
UninitializedBuffer Cette classe permet de marquer un tampon comme existant mais pas encore initialisé avec des valeurs concrètes. Son initialisation est généralement différée jusqu'au premier appel du module.

Liste des conteneurs

Nom Description
Module Ce conteneur permet de servir de classe de base pour tous les modules de réseaux de neurones. C'est le bloc fondamental pour construire n'importe quelle partie d'un modèle PyTorch, gérant automatiquement les sous-modules et les paramètres.
Sequential Ce conteneur permet d'empiler des modules de manière séquentielle, où la sortie d'un module est l'entrée du module suivant. Il est très pratique pour construire des architectures de réseaux de neurones linéaires et simples.
ModuleList Ce conteneur permet de contenir une liste de sous-modules. C'est utile lorsque vous avez des modules que vous voulez gérer comme une liste, par exemple pour créer des blocs répétitifs ou des chemins dynamiques dans votre réseau.
ModuleDict Ce conteneur permet de contenir un dictionnaire de sous-modules. Il est pratique pour organiser des modules avec des noms personnalisés, ce qui peut être utile pour les réseaux complexes où différentes parties ont des rôles spécifiques.
ParameterList Ce conteneur permet de contenir une liste de paramètres (torch.nn.Parameter). Il est utilisé lorsque vous avez une collection de paramètres que vous voulez gérer sous forme de liste sans les lier directement à une couche spécifique.
ParameterDict Ce conteneur permet de contenir un dictionnaire de paramètres (torch.nn.Parameter). Il est pratique pour organiser des paramètres individuels avec des clés nommées.

Crochets globaux pour le module :

Nom Description
register_module_forward_pre_hook Cette fonction permet d'enregistrer un "hook" (crochet) qui sera exécuté juste avant le passage avant (forward pass) de tous les modules PyTorch.
register_module_forward_hook Cette fonction permet d'enregistrer un "hook" (crochet) global qui sera exécuté juste après le passage avant (forward pass) de tous les modules PyTorch.
register_module_backward_hook Cette fonction permet d'enregistrer un "hook" (crochet) qui sera exécuté après le calcul des gradients (passage arrière) de tous les modules PyTorch.
register_module_full_backward_pre_hook Cette fonction permet d'enregistrer un "hook" (crochet) qui sera exécuté juste avant le calcul des gradients complets (passage arrière) de tous les modules PyTorch.
register_module_full_backward_hook Cette fonction permet d'enregistrer un "hook" (crochet) qui sera exécuté après le calcul des gradients complets (passage arrière) de tous les modules PyTorch.
register_module_buffer_registration_hook Cette fonction permet d'enregistrer un "hook" (crochet) qui sera exécuté lors de l'enregistrement d'un tampon (buffer) dans n'importe quel module PyTorch.
register_module_module_registration_hook Cette fonction permet d'enregistrer un "hook" (crochet) qui sera exécuté lors de l'enregistrement d'un sous-module dans n'importe quel module PyTorch.
register_module_parameter_registration_hook Cette fonction permet d'enregistrer un "hook" (crochet) qui sera exécuté lors de l'enregistrement d'un paramètre (parameter) dans n'importe quel module PyTorch.

Couches de convolution

Nom Description
nn.Conv1d Cette couche de convolution permet d'appliquer une convolution 1D sur un signal d'entrée composé de plusieurs plans d'entrée, couramment utilisée pour les séquences et séries temporelles.
nn.Conv2d Cette couche de convolution permet d'appliquer une convolution 2D sur un signal d'entrée composé de plusieurs plans d'entrée, couramment utilisée pour les images.
nn.Conv3d Cette couche de convolution permet d'appliquer une convolution 3D sur un signal d'entrée composé de plusieurs plans d'entrée, couramment utilisée pour les volumes ou séquences vidéo.
nn.ConvTranspose1d Cette couche de convolution permet d'appliquer une opération de convolution transposée 1D sur un signal d'entrée, souvent utilisée pour l'upsampling ou la déconvolution.
nn.ConvTranspose2d Cette couche de convolution permet d'appliquer une opération de convolution transposée 2D sur un signal d'entrée, souvent utilisée pour l'upsampling dans les tâches de segmentation d'images.
nn.ConvTranspose3d Cette couche de convolution permet d'appliquer une opération de convolution transposée 3D sur un signal d'entrée, utilisée pour l'upsampling de données volumétriques ou vidéo.
nn.LazyConv1d Cette couche de convolution permet une initialisation différée de l'argument in_channels pour une convolution 1D, ce qui est utile lorsque le nombre de canaux d'entrée n'est pas connu à l'avance.
nn.LazyConv2d Cette couche de convolution permet une initialisation différée de l'argument in_channels pour une convolution 2D, pratique lorsque la dimension d'entrée est déterminée dynamiquement.
nn.LazyConv3d Cette couche de convolution permet une initialisation différée de l'argument in_channels pour une convolution 3D, utile dans des architectures où la taille d'entrée varie.
nn.LazyConvTranspose1d Cette couche de convolution permet une initialisation différée de l'argument in_channels pour une convolution transposée 1D.
nn.LazyConvTranspose2d Cette couche de convolution permet une initialisation différée de l'argument in_channels pour une convolution transposée 2D.
nn.LazyConvTranspose3d Cette couche de convolution permet une initialisation différée de l'argument in_channels pour une convolution transposée 3D.
nn.Unfold Cette couche de convolution permet d'extraire des blocs locaux glissants d'un tenseur d'entrée par lot, transformant une image en une séquence de "patches".
nn.Fold Cette couche de convolution permet de combiner un tableau de blocs locaux glissants en un grand tenseur conteneur, agissant comme l'inverse de nn.Unfold.

Couches de regroupement

Nom Description
nn.MaxPool1d Cette couche de regroupement permet d'appliquer une opération de regroupement par maximum 1D sur un signal d'entrée. Elle réduit la dimension spatiale d'une séquence en prenant la valeur maximale dans chaque région.
nn.MaxPool2d Cette couche de regroupement permet d'appliquer une opération de regroupement par maximum 2D sur un signal d'entrée, couramment utilisée pour les images. Elle réduit les dimensions spatiales en sélectionnant la valeur maximale dans des fenêtres définies.
nn.MaxPool3d Cette couche de regroupement permet d'appliquer une opération de regroupement par maximum 3D sur un signal d'entrée, adaptée aux données volumétriques ou vidéo. Elle réduit les dimensions en profondeur, hauteur et largeur.
nn.MaxUnpool1d Cette couche de regroupement permet de calculer une inverse partielle de MaxPool1d. Elle est utilisée pour "dé-regrouper" les tenseurs, souvent dans les réseaux de neurones pour la reconstruction d'images ou la segmentation sémantique, en utilisant les indices du MaxPool1d original.
nn.MaxUnpool2d Cette couche de regroupement permet de calculer une inverse partielle de MaxPool2d, souvent utilisée pour l'upsampling en ramenant les valeurs aux positions d'origine avant le regroupement maximal.
nn.MaxUnpool3d Cette couche de regroupement permet de calculer une inverse partielle de MaxPool3d, utile pour la reconstruction de volumes 3D.
nn.AvgPool1d Cette couche de regroupement permet d'appliquer une opération de regroupement par moyenne 1D sur un signal d'entrée. Elle réduit la dimension spatiale en calculant la moyenne des valeurs dans chaque région.
nn.AvgPool2d Cette couche de regroupement permet d'appliquer une opération de regroupement par moyenne 2D sur un signal d'entrée. Elle est souvent utilisée pour lisser les caractéristiques et réduire la sensibilité aux variations de position.
nn.AvgPool3d Cette couche de regroupement permet d'appliquer une opération de regroupement par moyenne 3D sur un signal d'entrée, réduisant les dimensions en profondeur, hauteur et largeur par la moyenne.
nn.FractionalMaxPool2d Cette couche de regroupement permet d'appliquer un regroupement par maximum fractionnaire 2D. Contrairement au MaxPool standard, elle utilise des régions de regroupement de taille non uniforme, ce qui peut aider à créer des architectures plus efficaces.
nn.FractionalMaxPool3d Cette couche de regroupement permet d'appliquer un regroupement par maximum fractionnaire 3D, étendant le concept de regroupement fractionnaire aux données volumétriques.
nn.LPPool1d Cette couche de regroupement permet d'appliquer un regroupement Power-Average (norme L_p) 1D sur un signal d'entrée, généralisant le regroupement par moyenne (L1) et par maximum (L infini).
nn.LPPool2d Cette couche de regroupement permet d'appliquer un regroupement Power-Average (norme L_p) 2D sur un signal d'entrée, offrant une flexibilité entre la moyenne et le maximum pour l'agrégation des caractéristiques.
nn.LPPool3d Cette couche de regroupement permet d'appliquer un regroupement Power-Average (norme L_p) 3D sur un signal d'entrée, utile pour des agrégations de caractéristiques plus sophistiquées en 3D.
nn.AdaptiveMaxPool1d Cette couche de regroupement permet d'appliquer un regroupement par maximum adaptatif 1D sur un signal d'entrée, en ajustant automatiquement la taille du noyau et la foulée pour produire une sortie de taille fixe, indépendamment de la taille d'entrée.
nn.AdaptiveMaxPool2d Cette couche de regroupement permet d'appliquer un regroupement par maximum adaptatif 2D, très utile pour garantir une taille de sortie fixe à la fin d'une partie convolutive d'un réseau, avant les couches linéaires par exemple.
nn.AdaptiveMaxPool3d Cette couche de regroupement permet d'appliquer un regroupement par maximum adaptatif 3D, pour obtenir une sortie de taille fixe à partir d'entrées volumétriques de différentes tailles.
nn.AdaptiveAvgPool1d Cette couche de regroupement permet d'appliquer un regroupement par moyenne adaptatif 1D sur un signal d'entrée, produisant une sortie de taille fixe.
nn.AdaptiveAvgPool2d Cette couche de regroupement permet d'appliquer un regroupement par moyenne adaptatif 2D, couramment utilisé dans les dernières couches des réseaux de neurones pour réduire les caractéristiques à une taille fixe avant une couche de classification.
nn.AdaptiveAvgPool3d Cette couche de regroupement permet d'appliquer un regroupement par moyenne adaptatif 3D, idéal pour normaliser la taille des tenseurs volumétriques ou vidéo avant des couches entièrement connectées.

Couches de rembourrage

Nom Description
nn.ReflectionPad1d Cette couche de rembourrage permet d'agrandir un tenseur d'entrée en utilisant une réflexion des valeurs de la bordure d'entrée sur une dimension.
nn.ReflectionPad2d Cette couche de rembourrage permet d'agrandir un tenseur d'entrée en utilisant une réflexion des valeurs de la bordure d'entrée sur deux dimensions (typiquement pour les images).
nn.ReflectionPad3d Cette couche de rembourrage permet d'agrandir un tenseur d'entrée en utilisant une réflexion des valeurs de la bordure d'entrée sur trois dimensions (pour les volumes ou séquences vidéo).
nn.ReplicationPad1d Cette couche de rembourrage permet d'agrandir un tenseur d'entrée en répétant la valeur de la bordure d'entrée sur une dimension.
nn.ReplicationPad2d Cette couche de rembourrage permet d'agrandir un tenseur d'entrée en répétant la valeur de la bordure d'entrée sur deux dimensions.
nn.ReplicationPad3d Cette couche de rembourrage permet d'agrandir un tenseur d'entrée en répétant la valeur de la bordure d'entrée sur trois dimensions.
nn.ZeroPad1d Cette couche de rembourrage permet d'agrandir les bordures du tenseur d'entrée avec des zéros sur une dimension.
nn.ZeroPad2d Cette couche de rembourrage permet d'agrandir les bordures du tenseur d'entrée avec des zéros sur deux dimensions.
nn.ZeroPad3d Cette couche de rembourrage permet d'agrandir les bordures du tenseur d'entrée avec des zéros sur trois dimensions.
nn.ConstantPad1d Cette couche de rembourrage permet d'agrandir les bordures du tenseur d'entrée avec une valeur constante spécifiée sur une dimension.
nn.ConstantPad2d Cette couche de rembourrage permet d'agrandir les bordures du tenseur d'entrée avec une valeur constante spécifiée sur deux dimensions.
nn.ConstantPad3d Cette couche de rembourrage permet d'agrandir les bordures du tenseur d'entrée avec une valeur constante spécifiée sur trois dimensions.
nn.CircularPad1d Cette couche de rembourrage permet d'agrandir le tenseur d'entrée en utilisant un rembourrage circulaire de la bordure d'entrée sur une dimension, comme si les bords étaient connectés.
nn.CircularPad2d Cette couche de rembourrage permet d'agrandir le tenseur d'entrée en utilisant un rembourrage circulaire de la bordure d'entrée sur deux dimensions, créant un effet "tore".
nn.CircularPad3d Cette couche de rembourrage permet d'agrandir le tenseur d'entrée en utilisant un rembourrage circulaire de la bordure d'entrée sur trois dimensions.

Fonctions de perte

Nom Description
nn.L1Loss Cette fonction permet de calculer l'erreur absolue moyenne (MAE) entre chaque élément de l'entrée et de la cible, ce qui est utile pour la régression lorsque l'on veut une robustesse aux valeurs aberrantes.
nn.MSELoss Cette fonction permet de calculer l'erreur quadratique moyenne (MSE) entre chaque élément de l'entrée et de la cible, mesurant la moyenne des carrés des erreurs et pénalisant davantage les grandes erreurs.
nn.CrossEntropyLoss Cette fonction permet de calculer la perte d'entropie croisée entre les logits d'entrée et la cible, généralement utilisée pour les problèmes de classification multi-classes.
nn.CTCLoss Cette fonction permet de calculer la perte CTC (Connectionist Temporal Classification), adaptée aux problèmes de séquence où l'alignement entre l'entrée et la cible n'est pas connu à l'avance, comme la reconnaissance vocale.
nn.NLLLoss Cette fonction permet de calculer la perte de log-vraisemblance négative, souvent utilisée en conjonction avec une couche nn.LogSoftmax pour la classification.
nn.PoissonNLLLoss Cette fonction permet de calculer la perte de log-vraisemblance négative avec une distribution de Poisson pour la cible, utile pour la régression de dénombrements.
nn.GaussianNLLLoss Cette fonction permet de calculer la perte de log-vraisemblance négative gaussienne, adaptée à la régression où l'on souhaite modéliser l'incertitude des prédictions.
nn.KLDivLoss Cette fonction permet de calculer la divergence de Kullback-Leibler (KL) entre deux distributions de probabilités, souvent utilisée pour mesurer la différence entre une distribution prédite et une distribution cible.
nn.BCELoss Cette fonction permet de calculer l'entropie binaire croisée entre les probabilités prédites et une cible binaire, principalement utilisée pour la classification binaire.
nn.BCEWithLogitsLoss Cette fonction permet de combiner une couche Sigmoïde et la BCELoss en une seule classe pour une stabilité numérique accrue lors de la classification binaire.
nn.MarginRankingLoss Cette fonction permet de mesurer la perte pour une tâche de classement, étant donné deux entrées et une étiquette indiquant laquelle des deux entrées est préférée.
nn.HingeEmbeddingLoss Cette fonction permet de mesurer la perte pour des tâches où la similarité est importante, comme l'apprentissage d'incorporations (embeddings), en comparant un tenseur d'entrée et un tenseur d'étiquettes.
nn.MultiLabelMarginLoss Cette fonction permet d'optimiser une perte de marge (hinge loss) pour la classification multi-classe multi-étiquette, où chaque échantillon peut appartenir à plusieurs classes.
nn.HuberLoss Cette fonction permet de calculer une perte qui est quadratique pour les petites erreurs et linéaire pour les grandes erreurs, offrant une robustesse aux valeurs aberrantes tout en étant lisse autour de zéro.
nn.SmoothL1Loss Cette fonction permet de calculer une perte qui utilise un terme au carré si l'erreur absolue élément par élément tombe en dessous d'un seuil beta et un terme L1 sinon, offrant une version lissée de la perte L1.
nn.SoftMarginLoss Cette fonction permet d'optimiser une perte logistique de classification à deux classes entre un tenseur d'entrée et un tenseur cible.
nn.MultiLabelSoftMarginLoss Cette fonction permet d'optimiser une perte multi-étiquette un-contre-tous basée sur l'entropie maximale, pour les problèmes où plusieurs étiquettes peuvent être vraies simultanément pour une seule entrée.
nn.CosineEmbeddingLoss Cette fonction permet de mesurer la perte basée sur la similarité cosinus entre deux tenseurs d'entrée, souvent utilisée pour l'apprentissage de similarité où les paires similaires sont rapprochées et les paires dissimilaires sont éloignées.
nn.MultiMarginLoss Cette fonction permet d'optimiser une perte de marge (hinge loss) de classification multi-classes, où une seule classe est correcte par échantillon.
nn.TripletMarginLoss Cette fonction permet de mesurer la perte triplet, utilisée pour l'apprentissage métrique. Elle vise à ce qu'une "ancre" soit plus proche d'un "positif" que d'un "négatif" d'une certaine marge.
nn.TripletMarginWithDistanceLoss Cette fonction permet de mesurer la perte triplet avec une fonction de distance personnalisable, offrant plus de flexibilité pour définir la relation entre l'ancre, le positif et le négatif.

Couches de vision

Nom Description
nn.PixelShuffle Cette couche de vision permet de réorganiser les éléments d'un tenseur pour augmenter sa résolution spatiale selon un facteur d'agrandissement, souvent utilisée dans les tâches de super-résolution d'images.
nn.PixelUnshuffle Cette couche de vision permet d'inverser l'opération PixelShuffle, réduisant la résolution spatiale d'un tenseur tout en augmentant sa profondeur de canaux.
nn.Upsample Cette couche de vision permet de suréchantillonner des données multi-canaux 1D (temporelles), 2D (spatiales) ou 3D (volumétriques) en utilisant diverses méthodes d'interpolation pour augmenter leur taille.
nn.UpsamplingNearest2d Cette couche de vision permet d'appliquer un suréchantillonnage 2D par voisin le plus proche à un signal d'entrée composé de plusieurs canaux. Les pixels sont répétés, créant un effet de blocs.
nn.UpsamplingBilinear2d Cette couche de vision permet d'appliquer un suréchantillonnage 2D par interpolation bilinéaire à un signal d'entrée composé de plusieurs canaux. Cela produit des images agrandies plus lisses que le voisin le plus proche.


Dernière mise à jour : Samedi, le 7 juin 2025