PyTorch stellt das Modul Torch.nn zur Verfügung, das uns bei der Erstellung und dem Training des neuronalen Netzwerks unterstützt. Wir werden zunächst das grundlegende neuronale Netzwerk anhand des MNIST-Datensatzes trainieren, ohne Funktionen dieser Modelle zu verwenden. Wir werden nur die grundlegende PyTorch-Tensor-Funktionalität verwenden und dann schrittweise jeweils eine Funktion von Torch.nn hinzufügen.

Torch.nn stellt uns viele weitere Klassen und Module zur Implementierung und zum Training des neuronalen Netzwerks zur Verfügung.

Das nn-Paket enthält die folgenden Module und Klassen:

Ja Nein	Klasse und Modul	Beschreibung
1.	Torch.nn.Parameter	Es handelt sich um eine Art Tensor, der als Modulparameter zu betrachten ist.
2.	Behälter
1) Torch.nn.Module	Es ist eine Basisklasse für alle neuronalen Netzwerkmodule.
2) Torch.nn.Sequentiell	Es handelt sich um einen sequentiellen Container, in dem Module in derselben Reihenfolge hinzugefügt werden, in der sie im Konstruktor übergeben werden.
3) Torch.nn.ModuleList	Dadurch werden Untermodule in einer Liste gespeichert.
4) Torch.nn.ModuleDict	Dadurch werden Untermodule in einem Verzeichnis gespeichert.
5) Torch.nn.ParameterList	Dadurch werden die Parameter in einer Liste gespeichert.
6) Torch.nn.parameterDict	Dadurch werden die Parameter in einem Verzeichnis gespeichert.
3.	Faltungsschichten
1) Torch.nn.Conv1d	Dieses Paket wird verwendet, um eine 1D-Faltung auf ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
2) Torch.nn.Conv2d	Dieses Paket wird verwendet, um eine 2D-Faltung auf ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
3) Torch.nn.Conv3d	Dieses Paket wird verwendet, um eine 3D-Faltung auf ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
4) Torch.nn.ConvTranspose1d	Dieses Paket wird verwendet, um einen 1D-transponierten Faltungsoperator auf ein Eingabebild anzuwenden, das aus mehreren Eingabeebenen besteht.
5) Torch.nn.ConvTranspose2d	Dieses Paket wird verwendet, um einen 2D-transponierten Faltungsoperator auf ein Eingabebild anzuwenden, das aus mehreren Eingabeebenen besteht.
6) Torch.nn.ConvTranspose3d	Dieses Paket wird verwendet, um einen 3D-transponierten Faltungsoperator auf ein Eingabebild anzuwenden, das aus mehreren Eingabeebenen besteht.
7) Torch.nn.Entfalten	Es wird verwendet, um gleitende lokale Blöcke aus einem Batch-Input-Tensor zu extrahieren.
8) Fackel.nn.Falten	Es wird verwendet, um ein Array gleitender lokaler Blöcke zu einem großen enthaltenden Tensor zu kombinieren.
4.	Pooling-Schichten
1) Torch.nn.MaxPool1d	Es wird verwendet, um ein 1D-Max-Pooling auf ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
2) Torch.nn.MaxPool2d	Es wird verwendet, um ein 2D-Max-Pooling auf ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
3) Torch.nn.MaxPool3d	Es wird verwendet, um ein 3D-Max-Pooling auf ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
4) Torch.nn.MaxUnpool1d	Es wird verwendet, um die partielle Umkehrung von MaxPool1d zu berechnen.
5) Torch.nn.MaxUnpool2d	Es wird verwendet, um die partielle Umkehrung von MaxPool2d zu berechnen.
6) Torch.nn.MaxUnpool3d	Es wird verwendet, um die partielle Umkehrung von MaxPool3d zu berechnen.
7) Torch.nn.AvgPool1d	Es wird verwendet, um ein 1D-Durchschnittspooling über ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
8) Torch.nn.AvgPool2d	Es wird verwendet, um ein 2D-Durchschnittspooling über ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
9) Torch.nn.AvgPool3d	Es wird verwendet, um ein 3D-Durchschnittspooling über ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
10) Torch.nn.FractionalMaxPool2d	Es wird verwendet, um ein 2D-Fractional-Max-Pooling auf ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
11) Torch.nn.LPPool1d	Es wird verwendet, um ein 1D-Leistungsmittel-Pooling auf ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
12) Torch.nn.LPPool2d	Es wird verwendet, um ein 2D-Leistungsmittel-Pooling auf ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
13) Torch.nn.AdavtiveMaxPool1d	Es wird verwendet, um ein 1D-adaptives Max-Pooling auf ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
14) Torch.nn.AdavtiveMaxPool2d	Es wird verwendet, um ein 2D-adaptives Max-Pooling auf ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
15) Torch.nn.AdavtiveMaxPool3d	Es wird verwendet, um ein 3D-adaptives Max-Pooling auf ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
16) Torch.nn.AdavtiveAvgPool1d	Es wird verwendet, um ein 1D-adaptives Durchschnittspooling auf ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
17) Torch.nn.AdavtiveAvgPool2d	Es wird verwendet, um ein 2D-adaptives Durchschnittspooling über ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
18) Torch.nn.AdavtiveAvgPool3d	Es wird verwendet, um ein 3D-adaptives Durchschnittspooling auf ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht.
5.	Polsterschichten
1) Torch.nn.ReflectionPad1d	Der Eingabetensor wird mithilfe der Reflexion der Eingabegrenze aufgefüllt.
2) Torch.nn.ReflactionPad2d	Der Eingabetensor wird mithilfe der Reflexion der Eingabegrenze aufgefüllt.
3) Torch.nn.ReplicationPad1	Der Eingabetensor wird mithilfe der Replikation der Eingabegrenze aufgefüllt.
4) Torch.nn.ReplicationPad2d	Der Eingabetensor wird mithilfe der Replikation der Eingabegrenze aufgefüllt.
5) Torch.nn.ReplicationPad3d	Der Eingabetensor wird mithilfe der Replikation der Eingabegrenze aufgefüllt.
6) Torch.nn.ZeroPad2d	Dadurch werden die Grenzen des Eingabetensors mit Nullen aufgefüllt.
7) Torch.nn.ConstantPad1d	Dadurch werden die Grenzen des Eingabetensors mit einem konstanten Wert aufgefüllt.
8) Torch.nn.ConstantPad2d	Dadurch werden die Grenzen des Eingabetensors mit einem konstanten Wert aufgefüllt.
9) Torch.nn.ConstantPad3d	Dadurch werden die Grenzen des Eingabetensors mit einem konstanten Wert aufgefüllt.
6.	Nichtlineare Aktivierungen (gewichtete Summe, Nichtlinearität)
1) Torch.nn.ELU	Es wird verwendet, um die elementweise Funktion anzuwenden: ELU(x)=max(0,x)+min(0,α*(exp(x)-1))
2) Torch.nn.Hardshrink	Es wird verwendet, um die harte Schrumpfungsfunktion elementweise anzuwenden:
3) Torch.nn.LeakyReLU	Es wird verwendet, um die elementweise Funktion anzuwenden: LeakyReLu(x)=max(0,x) +negative_slope*min(0,x)
4) Torch.nn.LogSigmoid	Es wird verwendet, um die elementweise Funktion anzuwenden:
5) Torch.nn.MultiheadAttention	Es wird verwendet, um dem Modell zu ermöglichen, Informationen aus verschiedenen Darstellungsunterräumen zu berücksichtigen
6) Torch.nn.PReLU	Es wird verwendet, um die elementweise Funktion anzuwenden: PReLU(x)=max(0,x)+a*min(0,x)
7) Torch.nn.ReLU	Es wird verwendet, um die gleichgerichtete lineare Einheitsfunktion elementweise anzuwenden: ReLU(x)=max(0,x)
8) Torch.nn.ReLU6	Es wird verwendet, um die elementweise Funktion anzuwenden: ReLU6(x)=min(max(0,x),6)
9) Torch.nn.RReLU	Es wird verwendet, um die randomisierte, gleichgerichtete, lineare Einheitsfunktion elementweise anzuwenden, wie im Artikel beschrieben:
10) Torch.nn.SELU	Die elementweise Funktion wird wie folgt angewendet: SELU(x)=scale*(max(0,x)+ min(0,a*(exp(x)-1))) Hier ist α = 1,6732632423543772848170429916717 und Skala = 1,0507009873554804934193349852946.
11) Torch.nn.TARGET	Die elementweise Funktion wird wie folgt angewendet:
12) Torch.nn.Sigmoid	Die elementweise Funktion wird wie folgt angewendet:
13) Torch.nn.Softplus	Die elementweise Funktion wird wie folgt angewendet:
14) Torch.nn.Softshrink	Es wird verwendet, um die weiche Schrumpfungsfunktion elementweise wie folgt anzuwenden:
15) Torch.nn.Softsign	Die elementweise Funktion wird wie folgt angewendet:
16) Fackel.nn.Tanh	Die elementweise Funktion wird wie folgt angewendet:
17) Torch.nn.Tanhshrink	Die elementweise Funktion wird wie folgt angewendet: Tanhshrink(x)=x-Tanh(x)
18) Torch.nn.Threshold	Es wird verwendet, um für jedes Element des Eingabetensors einen Schwellenwert festzulegen. Der Schwellenwert ist definiert als:
7.	Nichtlineare Aktivierungen (sonstige)
1) Torch.nn.Softmin	Es wird verwendet, um die Softmin-Funktion auf einen n-dimensionalen Eingabetensor anzuwenden und ihn neu zu skalieren. Danach liegen die Elemente des n-dimensionalen Ausgabetensors im Bereich 0, 1 und summieren sich zu 1. Softmin ist definiert als:
2) Torch.nn.Softmax	Es wird verwendet, um die Softmax-Funktion auf einen n-dimensionalen Eingabetensor anzuwenden und diesen neu zu skalieren. Danach liegen die Elemente des n-dimensionalen Ausgabetensors im Bereich 0, 1 und summieren sich zu 1. Softmax ist definiert als:
3) Torch.nn.Softmax2d	Es wird verwendet, um SoftMax über Features auf jeden räumlichen Standort anzuwenden.
4) Torch.nn.LogSoftmax	Es wird verwendet, um die LogSoftmax-Funktion auf einen n-dimensionalen Eingabetensor anzuwenden. Die LofSoftmax-Funktion kann wie folgt definiert werden:
5) Torch.nn.AdaptiveLogSoftmaxWithLoss	Es handelt sich um eine Strategie zum Trainieren von Modellen mit großen Ausgaberäumen. Dies ist sehr effektiv, wenn die Etikettenverteilung stark unausgewogen ist
8.	Normalisierungsebenen
1) Torch.nn.BatchNorm1d	Es wird verwendet, um eine Stapelnormalisierung auf 2D- oder 3D-Eingaben anzuwenden.
2) Torch.nn.BatchNorm2d	Es wird verwendet, um eine Stapelnormalisierung über ein 4D anzuwenden.
3) Torch.nn.BatchNorm3d	Es wird verwendet, um die Batch-Normalisierung auf 5D-Eingaben anzuwenden.
4) Torch.nn.GroupNorm	Es wird verwendet, um die Gruppennormalisierung auf einen Mini-Batch von Eingaben anzuwenden.
5) Torch.nn.SyncBatchNorm	Es wird verwendet, um die Batch-Normalisierung auf n-dimensionale Eingaben anzuwenden.
6) Torch.nn.InstanceNorm1d	Es wird verwendet, um eine Instanznormalisierung auf eine 3D-Eingabe anzuwenden.
7) Torch.nn.InstanceNorm2d	Es wird verwendet, um eine Instanznormalisierung auf eine 4D-Eingabe anzuwenden.
8) Torch.nn.InstanceNorm3d	Es wird verwendet, um eine Instanznormalisierung auf eine 5D-Eingabe anzuwenden.
9) Torch.nn.LayerNorm	Es wird verwendet, um eine Ebenennormalisierung auf einen Mini-Batch von Eingaben anzuwenden.
10) Torch.nn.LocalResponseNorm	Es wird verwendet, um eine lokale Antwortnormalisierung auf ein Eingangssignal anzuwenden, das aus mehreren Eingangsebenen besteht, wobei der Kanal die zweite Dimension einnimmt.
9.	Wiederkehrende Schichten
1) Torch.nn.RNN	Es wird verwendet, um ein mehrschichtiges Elman-RNN mit Tanh- oder ReLU-Nichtlinearität auf eine Eingabesequenz anzuwenden. Jede Ebene berechnet die folgende Funktion für jedes Element in der Eingabesequenz: HT=tanh(WihnenXT+bihnen+WhhTt-1+bhh)
2) Torch.nn.LSTM	Es wird verwendet, um ein mehrschichtiges Long Short-Term Memory (LSTM) RNN auf eine Eingabesequenz anzuwenden. Jede Ebene berechnet die folgende Funktion für jedes Element in der Eingabesequenz:
3) Torch.nn.GRU	Es wird verwendet, um eine mehrschichtige Gated Recurrent Unit (GRU) RNN auf eine Eingabesequenz anzuwenden. Jede Ebene berechnet die folgende Funktion für jedes Element in der Eingabesequenz:
4) Torch.nn.RNNCell	Es wird verwendet, um eine Elman-RNN-Zelle mit Tanh- oder ReLU-Nichtlinearität auf eine Eingabesequenz anzuwenden. Jede Ebene berechnet die folgende Funktion für jedes Element in der Eingabesequenz: h'=tanh(Wihnenx+bihnen+Whhh+bhh) ReLU wird anstelle von tanh verwendet
5) Torch.nn.LSTMCell	Es wird verwendet, um eine LSTM-Zelle (Long Short-Term Memory) auf eine Eingabesequenz anzuwenden. Jede Ebene berechnet die folgende Funktion für jedes Element in der Eingabesequenz: Dabei ist σ die Sigmoidfunktion und * das Hadamard-Produkt.
6) Torch.nn.GRUCell	Es wird verwendet, um eine GRU-Zelle (Gated Recurrent Unit) auf eine Eingabesequenz anzuwenden. Jede Ebene berechnet die folgende Funktion für jedes Element in der Eingabesequenz:
10.	Lineare Schichten
1) Torch.nn.Identity	Es handelt sich um einen Platzhalter-Identitätsoperator, der argumentunabhängig ist.
2) Torch.nn.Linear	Es wird verwendet, um eine lineare Transformation auf die eingehenden Daten anzuwenden: y=xAT+b
3) Torch.nn.Bilinear	Es wird verwendet, um eine bilineare Transformation auf die eingehenden Daten anzuwenden: y=x1Axt2+b
elf.	Dropout-Ebenen
1) Torch.nn.Dropout	Es wird zur Regularisierung und Verhinderung der Koadaptation von Neuronen eingesetzt. Ein Faktor von Während des Trainings wird die Ausgabe skaliert. Das bedeutet, dass das Modul bei der Auswertung eine Identitätsfunktion berechnet.
2) Torch.nn.Dropout2d	Wenn benachbarte Pixel innerhalb von Feature-Maps korreliert sind, reguliert Torch.nn.Dropout die Aktivierungen nicht und verringert die effektive Lernrate. In diesem Fall wird Torch.nn.Dropout2d() verwendet, um die Unabhängigkeit zwischen Feature-Maps zu fördern.
3) Torch.nn.Dropout3d	Wenn benachbarte Pixel innerhalb von Feature-Maps korreliert sind, reguliert Torch.nn.Dropout die Aktivierungen nicht und verringert die effektive Lernrate. In diesem Fall wird Torch.nn.Dropout2d () verwendet, um die Unabhängigkeit zwischen Feature-Maps zu fördern.
4) Torch.nn.AlphaDropout	Es wird verwendet, um Alpha Dropout auf die Eingabe anzuwenden. Alpha Dropout ist ein Dropout-Typ, der die selbstnormalisierende Eigenschaft beibehält.
12.	Spärliche Schichten
1) Torch.nn.Embedding	Es wird verwendet, um Worteinbettungen zu speichern und sie mithilfe von Indizes abzurufen. Die Eingabe für das Modul ist eine Liste von Indizes und die Ausgabe ist die entsprechende Worteinbettung.
2) Torch.nn.EmbeddingBag	Es wird verwendet, um Summen oder Mittelwerte von „Beuteln“ der Einbettung zu berechnen, ohne die Zwischeneinbettung zu instanziieren.
13.	Distanzfunktion
1) Torch.nn.CosineSimilarity	Es wird die Kosinusähnlichkeit zwischen x1 und x2 zurückgegeben, berechnet entlang dim.
2) Torch.nn.PairwiseDistance	Es berechnet den stapelweisen paarweisen Abstand zwischen den Vektoren v1, v2 mithilfe der p-Norm:
14.	Verlustfunktion
1) Torch.nn.L1Loss	Es wird als Kriterium verwendet, das den mittleren absoluten Fehler zwischen jedem Element in der Eingabe x und dem Ziel y misst. Der ungeminderte Verlust kann wie folgt beschrieben werden: l(x,y)=L={l1,...,lN},lN=|xN-UndN|, Wobei N die Chargengröße ist.
2) Torch.nn.MSELoss	Es wird als Kriterium verwendet, das den mittleren quadratischen Fehler zwischen jedem Element in der Eingabe x und dem Ziel y misst. Der ungeminderte Verlust kann wie folgt beschrieben werden: l(x,y)=L={l1,...,lN},lN=(xN-UndN)2, Wobei N die Chargengröße ist.
3) Torch.nn.CrossEntropyLoss	Dieses Kriterium kombiniert nn.LogSoftmax() und nn.NLLLoss() in einer einzigen Klasse. Es ist hilfreich, wenn wir ein Klassifizierungsproblem mit C-Klassen trainieren.
4) Torch.nn.CTCLoss	Der Verlust der konnektionistischen zeitlichen Klassifizierung berechnet den Verlust zwischen einer kontinuierlichen Zeitreihe und einer Zielsequenz.
5) Torch.nn.NLLLoss	Der Negative Log-Likelihood-Verlust wird verwendet, um ein Klassifizierungsproblem mit C-Klassen zu trainieren.
6) Torch.nn.PoissonNLLLoss	Der negative Log-Likelihood-Verlust mit der Poisson-Verteilung von t target~Poisson(input)loss(input,target)=input-target*log(target!)das Ziel.
7) Torch.nn.KLDivLoss	Es ist ein nützliches Abstandsmaß für die kontinuierliche Verteilung und auch nützlich, wenn wir eine direkte Regression über den Raum der kontinuierlichen Ausgabeverteilung durchführen.
8) Torch.nn.BCELoss	Es wird verwendet, um ein Kriterium zu erstellen, das die binäre Kreuzentropie zwischen dem Ziel und der Ausgabe misst. Der ungeminderte Verlust kann wie folgt beschrieben werden: l(x,y)=L={l1,...,lN},lN=-vN[UndN*logxN+ (1-jN)*log(1-xN)], Wobei N die Chargengröße ist.
9) Torch.nn.BCEWithLogitsLoss	Es kombiniert eine Sigmoid-Schicht und den BCELoss in einer einzigen Klasse. Wir können den Log-Summen-Exp-Trick für die numerische Stabilität nutzen, indem wir die Operation in einer Ebene kombinieren.
10) Torch.nn.MarginRankingLoss	Es wird ein Kriterium erstellt, das den Verlust gegebener Eingaben x1, x2, zweier 1D-Mini-Batch-Tensoren und eines Label-1D-Mini-Batch-Tensors y misst, die 1 oder -1 enthalten. Die Verlustfunktion für jede Probe im Mini-Batch lautet wie folgt: Verlust(x,y)=max(0,-y*(x1-X2)+Marge
11) Torch.nn.HingeEmbeddingLoss	HingeEmbeddingLoss misst den Verlust eines gegebenen Eingabetensors x und eines Beschriftungstensors y, die 1 oder -1 enthalten. Es wird verwendet, um zu messen, ob zwei Eingaben ähnlich oder unähnlich sind. Die Verlustfunktion ist definiert als:
12) Torch.nn.MultiLabelMarginLoss	Es wird verwendet, um ein Kriterium zu erstellen, das einen Scharnierverlust mit mehreren Klassen und mehreren Klassifizierungen zwischen Eingabe x und Ausgabe y optimiert.
13) Torch.nn.SmoothL1Loss	Es wird verwendet, um ein Kriterium zu erstellen, das einen quadratischen Term verwendet, wenn der absolute Elementfehler unter 1 fällt, andernfalls einen L1-Term. Es wird auch als Huber-Verlust bezeichnet:
14) Torch.nn.SoftMarginLoss	Es wird verwendet, um ein Kriterium zu erstellen, das den logistischen Verlust der Zwei-Klassen-Klassifizierung zwischen Eingabetensor x und Zieltensor y optimiert, die 1 oder -1 enthalten.
15) Torch.nn.MultiLabelSoftMarginLoss	Es wird verwendet, um ein Kriterium zu erstellen, das den Multi-Label-Eins-gegen-Alle-Verlust basierend auf der maximalen Entropie zwischen Eingabe x und Ziel y der Größe (N, C) optimiert.
16) Torch.nn.CosineEmbeddingLoss	Es wird verwendet, um ein Kriterium zu erstellen, das den Verlust gegebener Eingabetensoren x1, x2 und einer Tensorbezeichnung y mit den Werten 1 oder -1 misst. Mithilfe des Kosinusabstands wird gemessen, ob zwei Eingaben ähnlich oder unähnlich sind.
17) Torch.nn.MultiMarginLoss	Es wird verwendet, um ein Kriterium zu erstellen, das den Scharnierverlust einer Mehrklassenklassifizierung zwischen Eingabe x und Ausgabe y optimiert.
18) Torch.nn.TripletMarginLoss	Es wird verwendet, um ein Kriterium zu erstellen, das den Triplettverlust gegebener Eingabetensoren x1, x2, x3 und einer Marge mit einem Wert größer als 0 misst. Es wird zum Messen einer relativen Ähnlichkeit zwischen Stichproben verwendet. Ein Triplett besteht aus einem Anker, einem positiven Beispiel und einem negativen Beispiel. L(a,p,n)=max{d(aich,Pich)-d(aich,Nich)+marge,0}
fünfzehn.	Visionsebenen
1) Torch.nn.PixelShuffle	Es wird verwendet, um die Elemente in einem Tensor der Form (*,C×r) neu anzuordnen2,H,W) zu einem Tensor der Form (*,C,H×r,W,r)
2) Torch.nn.Upsample	Es wird zum Upsampling bestimmter mehrkanaliger 1D-, 2D- oder 3D-Daten verwendet.
3) Torch.nn.upsamplingNearest2d	Es wird verwendet, um das 2D-Upsampling des nächsten Nachbarn auf ein Eingangssignal anzuwenden, das aus mehreren Eingangskanälen besteht.
4) Torch.nn.UpsamplingBilinear2d	Es wird verwendet, um 2D-bilineares Upsampling auf ein Eingangssignal anzuwenden, das aus mehreren Eingangskanälen besteht.
16.	DatenParallele Schichten (Multi-GPU, verteilt)
1) Torch.nn.DataParallel	Es wird verwendet, um Datenparallelität auf Modulebene zu implementieren.
2) Torch.nn.DistributedDataParallel	Es wird zur Implementierung der verteilten Datenparallelität verwendet, die auf dem Paket Torch.distributed auf Modulebene basiert.
3) Torch.nn.DistributedDataParallelCPU	Es wird verwendet, um verteilte Datenparallelität für die CPU auf Modulebene zu implementieren.
17.	Dienstprogramme
1) Torch.nn.clip_grad_norm_	Es wird verwendet, um die Gradientennorm eines iterierbaren Parameters zu beschneiden.
2) Torch.nn.clip_grad_value_	Es wird verwendet, um die Gradientennorm eines iterierbaren Parameters auf den angegebenen Wert zu beschneiden.
3) Torch.nn.parameters_to_vector	Es wird verwendet, um Parameter in einen Vektor umzuwandeln.
4) Torch.nn.vector_to_parameters	Es wird verwendet, um einen Vektor in die Parameter umzuwandeln.
5) Torch.nn.weight_norm	Es wird verwendet, um eine Gewichtsnormalisierung auf einen Parameter im angegebenen Modul anzuwenden.
6) Torch.nn.remove_weight_norm	Es wird verwendet, um die Gewichtsnormalisierung und Neuparametrisierung aus einem Modul zu entfernen.
7) Torch.nn.spectral_norm	Es wird verwendet, um eine spektrale Normalisierung auf einen Parameter im angegebenen Modul anzuwenden.
8) Torch.nn.PackedSequence	Es wird verwendet, um die Daten und die Liste der Batch-Größen einer gepackten Sequenz zu speichern.
9) Torch.nn.pack_padded_sequence	Es wird verwendet, um einen Tensor zu packen, der aufgefüllte Sequenzen variabler Länge enthält.
10) Torch.nn.pad_packed_sequence	Es wird verwendet, um einen gepackten Stapel von Sequenzen variabler Länge aufzufüllen.
11) Torch.nn.pad_sequence	Es wird verwendet, um eine Liste von Tensoren variabler Länge mit Füllwerten aufzufüllen.
12) Torch.nn.pack_sequence	Es wird verwendet, um eine Liste von Tensoren variabler Länge zu packen
13) Torch.nn.remove_spectral_norm	Es wird verwendet, um die spektrale Normalisierung und Neuparametrisierung von einem Modul zu entfernen.

Referenz:

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