PyTorch torch.nn Referenzhandbuch

PyTorchstorch.nnModul ist das Kernmodul zum Erstellen und Trainieren neuronaler Netze. Es bietet eine reichhaltige Sammlung von Klassen und Funktionen zum Definieren und Betreiben neuronaler Netze.

Die folgenden sindtorch.nneinige Schlüsselkomponenten des Moduls und ihre Funktionen:

1. Die Klasse nn.Module：

nn.Moduleist die Basisklasse für alle benutzerdefinierten neuronalen Netzmodelle. Benutzer leiten normalerweise ihre eigenen Modellklassen von dieser Klasse ab und definieren darin die Struktur der Netzwerkschichten und die Forward-Pass-Funktion.

2. Vordefinierte Schichten (Module)：

Enthält verschiedene Arten von Schichtkomponenten, wie Faltungsschichten (nn.Conv1d, nn.Conv2d, nn.Conv3d), vollständig verbundene Schichten (nn.Linear), Aktivierungsfunktionen (nn.ReLU, nn.Sigmoid, nn.Tanh), usw.

3. Container-Klassen：

nn.Sequential: Ermöglichen, mehrere Schichten sequenziell zu kombinieren, um ein einfaches linear gestapeltes Netzwerk zu bilden.
nn.ModuleListundnn.ModuleDict: Können Submodule dynamisch speichern und darauf zugreifen und unterstützen Sammlungen von Modulen mit variabler Länge oder benannte Sammlungen von Modulen.

4. Verlustfunktionen：

torch.nnEnthält eine Reihe von Verlustfunktionen zur Messung der Differenz zwischen Modellvorhersagen und wahren Labels, wie etwa der Verlust des mittleren quadratischen Fehlers (nn.MSELoss), der Kreuzentropie-Verlust (nn.CrossEntropyLoss), usw.

5. Funktionale Schnittstelle：

nn.functional(üblicherweise abgekürzt alsF), enthält viele Funktionen, die direkt auf Tensoren operieren können. Sie implementieren dieselbe Funktionalität wie Layer-Objekte, besitzen jedoch nicht die Fähigkeit, Parameter zu speichern und zu aktualisieren. Zum Beispiel können SieF.relu()verwenden, um direkt ReLU-Operationen durchzuführen, oderF.conv2d(), um Faltungsoperationen durchzuführen.

6. Initialisierungsmethoden：

torch.nn.initBietet einige häufig verwendete Strategien zur Gewichtsinitialisierung, wie die Xavier-Initialisierung (nn.init.xavier_uniform_()) und die Kaiming-Initialisierung (nn.init.kaiming_uniform_()), die für das erfolgreiche Trainieren neuronaler Netze entscheidend sind.

7. Transformer-Schichten：

PyTorch bietet vollständige Komponenten der Transformer-Architektur, einschließlichnn.Transformer, nn.TransformerEncoder, nn.TransformerDecodersowie Aufmerksamkeitsmechanismennn.MultiheadAttentionusw.

8. Normalisierungsschichten：

Beinhaltet Batch-Normalisierung (BatchNorm), Layer-Normalisierung (LayerNorm), Gruppen-Normalisierung (GroupNorm), Instanz-Normalisierung (InstanceNorm), und RMSNorm usw.

PyTorch torch.nn Module-Referenzhandbuch

Container für neuronale Netzwerke

Klasse/Funktion	Beschreibung
`torch.nn.Module`	Basisklasse für alle Module neuronaler Netze.
`torch.nn.Sequential(*args)`	Kombiniert mehrere Module sequenziell.
`torch.nn.ModuleList(modules)`	Speichert Untermodule in einer Liste.
`torch.nn.ModuleDict(modules)`	Speichert Untermodule in einem Dictionary.
`torch.nn.ParameterList(parameters)`	Speichert Parameter in einer Liste.
`torch.nn.ParameterDict(parameters)`	Speichert Parameter in einem Dictionary.
`torch.nn.Parameter(data)`	Erstellt einen lernbaren Parameter-Tensor.
`torch.nn.Buffer(data)`	Erstellt einen persistenten Puffer (nicht lernbarer Parameter).
`torch.nn.Identity(args, *kwargs)`	Identitätstransformationsschicht, Eingabe wird direkt ausgegeben.

Globale Hooks

Funktion	Beschreibung
`register_module_forward_pre_hook(hook)`	Registriert einen Forward-Pre-Hook.
`register_module_forward_hook(hook)`	Registriert einen Forward-Hook.
`register_module_backward_hook(hook)`	Registriert einen Backward-Hook.
`register_module_full_backward_pre_hook(hook)`	Registriert einen vollständigen Backward-Pre-Hook.
`register_module_full_backward_hook(hook)`	Registriert einen vollständigen Backward-Hook.

Lineare Schichten

Klasse/Funktion	Beschreibung
`torch.nn.Linear(in_features, out_features, bias)`	Vollständig verbundene Schicht (lineare Transformation).
`torch.nn.Bilinear(in1_features, in2_features, out_features, bias)`	Bilineare Schicht.
`torch.nn.LazyLinear(out_features, bias)`	Lineare Schicht mit verzögerter Initialisierung; leitet automatisch die Eingabedimension während des ersten Forward-Passes ab.

Faltungsschichten

Klasse/Funktion	Beschreibung
`torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias, padding_mode)`	1D-Faltungsschicht, die häufig für Text und Audio verwendet wird.
`torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias, padding_mode)`	2D-Faltungsschicht, die häufig für Bilder verwendet wird.
`torch.nn.Conv3d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias, padding_mode)`	3D-Faltungsschicht, die häufig für Videos und volumetrische Daten verwendet wird.
`torch.nn.ConvTranspose1d(in_channels, out_channels, kernel_size, stride, padding, output_padding, groups, bias, dilation, padding_mode)`	1D-transponierte Faltung (Dekonvolution), die für Upsampling verwendet wird.
`torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride, padding, output_padding, groups, bias, dilation, padding_mode)`	2D-transponierte Faltung (Dekonvolution), die für Upsampling verwendet wird.
`torch.nn.ConvTranspose3d(in_channels, out_channels, kernel_size, stride, padding, output_padding, groups, bias, dilation, padding_mode)`	3D-transponierte Faltung (Dekonvolution), verwendet zum Upsampling.
`torch.nn.Unfold(kernel_size, dilation, padding, stride)`	Entfaltet den Eingabetensor in Blöcke mit gleitendem Fenster.
`torch.nn.Fold(output_size, kernel_size, dilation, padding, stride)`	Setzt die entfalteten Blöcke wieder zu einem Tensor zusammen.

Pooling-Schichten

Klasse/Funktion	Beschreibung
`torch.nn.MaxPool1d(kernel_size, stride, padding, dilation, return_indices)`	1D-Max-Pooling-Schicht.
`torch.nn.MaxPool2d(kernel_size, stride, padding, dilation, return_indices, ceil_mode)`	2D-Max-Pooling-Schicht.
`torch.nn.MaxPool3d(kernel_size, stride, padding, dilation, return_indices, ceil_mode)`	3D-Max-Pooling-Schicht.
`torch.nn.MaxUnpool1d(kernel_size, stride, padding)`	1D-Max-Unpooling-Schicht.
`torch.nn.MaxUnpool2d(kernel_size, stride, padding)`	2D-Max-Unpooling-Schicht.
`torch.nn.MaxUnpool3d(kernel_size, stride, padding)`	3D-Max-Unpooling-Schicht.
`torch.nn.AvgPool1d(kernel_size, stride, padding)`	1D-Mittelwert-Pooling-Schicht.
`torch.nn.AvgPool2d(kernel_size, stride, padding, ceil_mode, count_include_pad)`	2D-Mittelwert-Pooling-Schicht.
`torch.nn.AvgPool3d(kernel_size, stride, padding, ceil_mode, count_include_pad)`	3D-Mittelwert-Pooling-Schicht.
`torch.nn.AdaptiveMaxPool1d(output_size, return_indices)`	1D adaptives Max-Pooling, feste Ausgabegröße.
`torch.nn.AdaptiveMaxPool2d(output_size, return_indices)`	2D adaptives Max-Pooling, feste Ausgabegröße.
`torch.nn.AdaptiveMaxPool3d(output_size, return_indices)`	3D adaptives Max-Pooling, feste Ausgabegröße.
`torch.nn.AdaptiveAvgPool1d(output_size)`	1D adaptives Average-Pooling, feste Ausgabegröße.
`torch.nn.AdaptiveAvgPool2d(output_size)`	2D adaptives Average-Pooling, feste Ausgabegröße.
`torch.nn.AdaptiveAvgPool3d(output_size)`	3D adaptives Average-Pooling, feste Ausgabegröße.
`torch.nn.LPPool1d(norm_type, kernel_size, stride, padding)`	1D-Lp-Pooling-Schicht.
`torch.nn.LPPool2d(norm_type, kernel_size, stride, padding)`	2D-Lp-Pooling-Schicht.
`torch.nn.FractionalMaxPool2d(kernel_size, output_size, output_ratio, return_indices)`	2D fraktionales Max-Pooling mit zufälligen Schrittgrößen.
`torch.nn.FractionalMaxPool3d(kernel_size, output_size, output_ratio, return_indices)`	3D fraktionales Max-Pooling mit zufälligen Schrittgrößen.

Padding-Schichten

Klasse/Funktion	Beschreibung
`torch.nn.ReflectionPad1d(padding)`	1D-Reflection-Padding, kopiert durch Reflexion entlang des Rands.
`torch.nn.ReflectionPad2d(padding)`	2D-Reflexionspadding, kopiert durch Spiegeln entlang der Grenze.
`torch.nn.ReflectionPad3d(padding)`	3D-Reflexionspadding, kopiert durch Spiegeln entlang der Grenze.
`torch.nn.ReplicationPad1d(padding)`	1D-Replikationspadding, kopiert Randwerte entlang der Grenze.
`torch.nn.ReplicationPad2d(padding)`	2D-Replikationspadding, kopiert Randwerte entlang der Grenze.
`torch.nn.ReplicationPad3d(padding)`	3D-Replikationspadding, kopiert Randwerte entlang der Grenze.
`torch.nn.ZeroPad1d(padding)`	1D-Nullpadding.
`torch.nn.ZeroPad2d(padding)`	2D-Nullpadding.
`torch.nn.ZeroPad3d(padding)`	3D-Nullpadding.
`torch.nn.ConstantPad1d(padding, value)`	1D-Konstantenpadding, füllt mit einem angegebenen Wert.
`torch.nn.ConstantPad2d(padding, value)`	2D-Konstantenpadding, füllt mit einem angegebenen Wert.
`torch.nn.ConstantPad3d(padding, value)`	3D-Konstantenpadding, füllt mit einem angegebenen Wert.
`torch.nn.CircularPad1d(padding)`	1D-zyklisches Padding.
`torch.nn.CircularPad2d(padding)`	2D zyklisches Padding.
`torch.nn.CircularPad3d(padding)`	3D zyklisches Padding.

Aktivierungsfunktionen (nichtlineare Aktivierungen - gewichtete Summe)

Klasse/Funktion	Beschreibung
`torch.nn.ReLU(inplace)`	ReLU-Aktivierungsfunktion, f(x) = max(0, x).
`torch.nn.ReLU6(inplace)`	ReLU6-Aktivierungsfunktion, f(x) = min(max(0, x), 6).
`torch.nn.Sigmoid()`	Sigmoid-Aktivierungsfunktion, f(x) = 1 / (1 + exp(-x)).
`torch.nn.Tanh()`	Tanh-Aktivierungsfunktion, f(x) = (exp(x) - exp(-x)) / (exp(x) + exp(-x)).
`torch.nn.LeakyReLU(negative_slope, inplace)`	LeakyReLU, ermöglicht kleine Gradienten für negative Werte.
`torch.nn.PReLU(num_parameters, init)`	Parametrisches ReLU, mit lernbarem negativen Steigungsparameter.
`torch.nn.ELU(alpha, inplace)`	Exponential Linear Unit, verwendet die Exponentialfunktion für negative Werte.
`torch.nn.CELU(alpha, inplace)`	Stetig differenzierbare Exponential Linear Unit.
`torch.nn.SELU(inplace)`	Selbstnormalisierende Exponential Linear Unit.
`torch.nn.GELU()`	Gaussian Error Linear Unit, häufig in Transformers verwendet.
`torch.nn.SiLU(inplace)`	Sigmoid Linear Unit (Swish), f(x) = x * sigmoid(x).
`torch.nn.Mish(inplace)`	Mish-Aktivierungsfunktion, f(x) = x * tanh(softplus(x)).
`torch.nn.Hardtanh(min_value, max_value, inplace)`	Hard hyperbolic tangent, begrenzt den Ausgabebereich.
`torch.nn.Hardswish(inplace)`	Hard Swish, eine glatte Version von ReLU6.
`torch.nn.Hardsigmoid(inplace)`	Hard Sigmoid, stückweise lineare Approximation.
`torch.nn.RReLU(lower, upper, inplace)`	Randomized LeakyReLU, wählt während des Trainings zufällig eine negative Steigung aus.
`torch.nn.Softplus(beta, threshold)`	Softplus, eine glatte Approximation von ReLU.
`torch.nn.Softshrink(lambda)`	Softshrink-Aktivierungsfunktion.
`torch.nn.Hardshrink(lambda)`	Hardshrink-Aktivierungsfunktion.
`torch.nn.Softsign()`	Softsign-Aktivierungsfunktion, f(x) = x / (1 + \|x\|).
`torch.nn.Tanhshrink()`	Tanhshrink, f(x) = x - tanh(x).
`torch.nn.LogSigmoid()`	Log Sigmoid, f(x) = log(sigmoid(x)).
`torch.nn.Threshold(threshold, value, inplace)`	Threshold-Aktivierungsfunktion.
`torch.nn.GLU(dim)`	Gated Linear Unit, teilt die Eingabe entlang einer angegebenen Dimension in zwei Teile und multipliziert sie elementweise.

Aktivierungsfunktionen (nichtlineare Aktivierungen – Sonstige)

Klasse/Funktion	Beschreibung
`torch.nn.Softmax(dim)`	Softmax-Aktivierungsfunktion, wandelt Werte in eine Wahrscheinlichkeitsverteilung um.
`torch.nn.Softmax2d()`	Softmax über räumliche Dimensionen, wird für Bilder verwendet.
`torch.nn.LogSoftmax(dim)`	Log Softmax, numerisch stabile Version von Softmax.
`torch.nn.Softmin(dim)`	Softmin, das Gegenteil von Softmax.
`torch.nn.AdaptiveLogSoftmaxWithLoss(in_features, n_classes, cutoffs, div_value, head_bias)`	Adaptives Log Softmax, verwendet für die Klassifikation mit großem Vokabular.

Normalisierungsschichten

Klasse/Funktion	Beschreibung
`torch.nn.BatchNorm1d(num_features, eps, momentum, affine, track_running_stats)`	Eindimensionale Batch-Normalisierungsschicht, normalisiert Mini-Batch-Daten.
`torch.nn.BatchNorm2d(num_features, eps, momentum, affine, track_running_stats)`	Zweidimensionale Batch-Normalisierungsschicht, häufig in Faltungsnetzwerken verwendet.
`torch.nn.BatchNorm3d(num_features, eps, momentum, affine, track_running_stats)`	Dreidimensionale Batch-Normalisierungsschicht, verwendet für dreidimensionale Daten wie Videos.
`torch.nn.LazyBatchNorm1d()`	Eindimensionale Batch-Normalisierung mit verzögerter Initialisierung.
`torch.nn.LazyBatchNorm2d()`	Zweidimensionale Batch-Normalisierung mit verzögerter Initialisierung.
`torch.nn.LazyBatchNorm3d()`	Dreidimensionale Batch-Normalisierung mit verzögerter Initialisierung.
`torch.nn.LayerNorm(normalized_shape, eps, elementwise_affine)`	Layer-Normalisierung, häufig in Transformers verwendet.
`torch.nn.GroupNorm(num_groups, num_channels, eps, affine)`	Group-Normalisierung, normalisiert nach der Gruppierung der Kanäle.
`torch.nn.InstanceNorm1d(num_features, eps, momentum, affine, track_running_stats)`	Eindimensionale Instanz-Normalisierung, verwendet für Style-Transfer.
`torch.nn.InstanceNorm2d(num_features, eps, momentum, affine, track_running_stats)`	Zweidimensionale Instanz-Normalisierung, verwendet für Style-Transfer.
`torch.nn.InstanceNorm3d(num_features, eps, momentum, affine, track_running_stats)`	Dreidimensionale Instanz-Normalisierung, verwendet für Style-Transfer.
`torch.nn.SyncBatchNorm(num_features, eps, momentum, affine, track_running_stats, process_group)`	Synchronisierte Batch-Normalisierung, verwendet für verteiltes Multi-GPU-Training.
`torch.nn.LocalResponseNorm(k, alpha, beta, size)`	Local-Response-Normalisierung, verwendet in faltungsneuronalen Netzen zur lateralen Hemmung.
`torch.nn.RMSNorm(normalized_shape, eps, elementwise_affine)`	RMS-Normalisierung, häufig in Transformers verwendet.

Schichten für rekurrente neuronale Netze

Klasse/Funktion	Beschreibung
`torch.nn.RNN(input_size, hidden_size, num_layers, nonlinearity, bias, batch_first, dropout, bidirectional)`	Einfache RNN-Schicht.
`torch.nn.LSTM(input_size, hidden_size, num_layers, bias, batch_first, dropout, bidirectional, proj_size)`	LSTM-Schicht (Long Short-Term Memory).
`torch.nn.GRU(input_size, hidden_size, num_layers, bias, batch_first, dropout, bidirectional, proj_size)`	GRU-Schicht (Gated Recurrent Unit).
`torch.nn.RNNCell(input_size, hidden_size, bias, nonlinearity)`	RNN-Zelle (einzelne Schicht).
`torch.nn.LSTMCell(input_size, hidden_size, bias)`	LSTM-Zelle (einzelne Schicht).
`torch.nn.GRUCell(input_size, hidden_size, bias)`	GRU-Zelle (einzelne Schicht).

Transformer-Schichten

Klasse/Funktion	Beschreibung
`torch.nn.Transformer(d_model, nhead, num_encoder_layers, num_decoder_layers, dim_feedforward, dropout, activation, custom_encoder, custom_decoder, layer_norm_eps, normalize_before, need_src_mask, need_tgt_mask, need_memory_mask, batch_first, norm_first, bias)`	Vollständiges Transformer-Modell.
`torch.nn.TransformerEncoder(encoder_layer, num_layers, norm)`	Transformer-Encoder.
`torch.nn.TransformerDecoder(decoder_layer, num_layers, norm)`	Transformer-Decoder.
`torch.nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout, activation, layer_norm_eps, batch_first, norm_first, bias)`	Transformer-Encoder-Schicht.
`torch.nn.TransformerDecoderLayer(d_model, nhead, dim_feedforward, dropout, activation, layer_norm_eps, batch_first, norm_first, bias)`	Transformer-Decoder-Schicht.
`torch.nn.MultiheadAttention(embed_dim, num_heads, dropout, bias, add_bias_kv, add_zero_attn, kdim, vdim, batch_first)`	Multi-Head-Attention-Mechanismus.

Aufmerksamkeitsmechanismen

Funktion	Beschreibung
`torch.nn.functional.scaled_dot_product_attention(query, key, value, attn_mask, dropout_p, is_causal)`	Skalierte Dot-Product-Aufmerksamkeit, PyTorchs optimierte Aufmerksamkeitsimplementierung.
`torch.nn.attention.sdpa_kernel(backends)`	Legt das SDP-(Scaled Dot-Product-)Attention-Backend fest.

Embedding-Schichten (Sparse-Schichten)

Klasse/Funktion	Beschreibung
`torch.nn.Embedding(num_embeddings, embedding_dim, padding_idx, max_norm, norm_type, scale_grad_by_freq, sparse)`	Embedding-Schicht, bildet diskrete Indizes auf dichte Vektoren ab.
`torch.nn.EmbeddingBag(num_embeddings, embedding_dim, max_norm, norm_type, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset, padding_idx)`	Embedding-Bag, aggregiert mehrere Embeddings.

Dropout-Schichten

Klasse/Funktion	Beschreibung
`torch.nn.Dropout(p, inplace)`	Dropout-Schicht, setzt Eingabeelemente zufällig auf null.
`torch.nn.Dropout1d(p, inplace)`	Eindimensionales Dropout, verwendet für eindimensionale Eingaben.
`torch.nn.Dropout2d(p, inplace)`	Zweidimensionales Dropout, verwendet für zweidimensionale Feature-Maps.
`torch.nn.Dropout3d(p, inplace)`	Dreidimensionales Dropout, verwendet für dreidimensionale Feature-Volumes.
`torch.nn.AlphaDropout(p, inplace)`	Alpha Dropout, behält selbstnormalisierende Eigenschaften bei.
`torch.nn.FeatureAlphaDropout(p, inplace)`	Feature Alpha Dropout.

Vision-Schichten

Klasse/Funktion	Beschreibung
`torch.nn.PixelShuffle(upscale_factor)`	Pixel-Shuffle, wandelt Kanal-Dimensionen in räumliche Dimensionen um (Upsampling).
`torch.nn.PixelUnshuffle(downscale_factor)`	Inverses Pixel-Shuffle, wandelt räumliche Dimensionen in Kanal-Dimensionen um (Downsampling).
`torch.nn.Upsample(size, scale_factor, mode, align_corners, recompute_scale_factor)`	Upsampling-Schicht.
`torch.nn.UpsamplingNearest2d(size, scale_factor)`	Zweidimensionales Nearest-Neighbor-Upsampling.
`torch.nn.UpsamplingBilinear2d(size, scale_factor, align_corners)`	Zweidimensionales bilineares Upsampling.
`torch.nn.ChannelShuffle(groups)`	Channel-Shuffle, verwendet für ChannelShuffle-Netzwerke.

Verlustfunktionen

Klasse/Funktion	Beschreibung
`torch.nn.MSELoss(size_average, reduce, reduction)`	Mean-Squared-Error-Verlust.
`torch.nn.L1Loss(size_average, reduce, reduction)`	L1-Verlust (mittlerer absoluter Fehler).
`torch.nn.CrossEntropyLoss(weight, size_average, ignore_index, reduce, reduction, label_smoothing)`	Cross-Entropy-Verlust, verwendet für Multiklassen-Klassifizierungsaufgaben.
`torch.nn.NLLLoss(weight, size_average, ignore_index, reduce, reduction)`	Negative-Log-Likelihood-Verlust.
`torch.nn.BCELoss(weight, size_average, reduce, reduction)`	Binärer Cross-Entropy-Verlust (binäre Klassifizierung).
`torch.nn.BCEWithLogitsLoss(weight, pos_weight, size_average, reduce, reduction, label_smoothing)`	Binärer Kreuzentropie-Verlust mit Sigmoid, numerisch stabiler.
`torch.nn.KLDivLoss(size_average, reduce, reduction, log_target)`	KL-Divergenz-Verlust, verwendet für Verteilungs-Matching.
`torch.nn.HuberLoss(delta, size_average, reduce, reduction)`	Huber-Verlust, eine Kombination aus L1 und L2, robuster gegenüber Ausreißern.
`torch.nn.SmoothL1Loss(beta, size_average, reduce, reduction)`	Smooth-L1-Verlust (eine Variante des Huber-Verlusts).
`torch.nn.CTCLoss(blank, reduction, zero_infinity)`	Connectionist Temporal Classification-Verlust, verwendet für Sequenzaufgaben wie Spracherkennung.
`torch.nn.PoissonNLLLoss(log_input, full, size_average, reduce, reduction)`	Poisson-Verlust der negativen Log-Likelihood.
`torch.nn.GaussianNLLLoss(full, size_average, reduce, reduction)`	Gaußscher Verlust der negativen Log-Likelihood.
`torch.nn.MarginRankingLoss(margin, size_average, reduce, reduction)`	Margin-Ranking-Verlust, verwendet für Learning-to-Rank.
`torch.nn.HingeEmbeddingLoss(margin, size_average, reduce, reduction)`	Hinge-Embedding-Verlust, verwendet für metrisches Lernen.
`torch.nn.MultiLabelMarginLoss(size_average, reduce, reduction)`	Multi-Label-Margin-Verlust.
`torch.nn.SoftMarginLoss(size_average, reduce, reduction)`	Soft-Margin-Verlust.
`torch.nn.MultiLabelSoftMarginLoss(weight, size_average, reduce, reduction)`	Multi-Label-Soft-Margin-Verlust.
`torch.nn.CosineEmbeddingLoss(margin, size_average, reduce, reduction)`	Cosine-Embedding-Loss, wird für metrisches Lernen verwendet.
`torch.nn.MultiMarginLoss(p, margin, weight, size_average, reduce, reduction)`	Multi-Class-Margin-Loss.
`torch.nn.TripletMarginLoss(margin, p, eps, swap, size_average, reduce, reduction)`	Triplet-Loss, wird für metrisches Lernen und kontrastives Lernen verwendet.
`torch.nn.TripletMarginWithDistanceLoss(distance_function, margin, swap, size_average, reduce, reduction)`	Triplet-Loss mit Distanzfunktion.

Distanzfunktionen

Klasse/Funktion	Beschreibung
`torch.nn.PairwiseDistance(p, eps, keepdim)`	Paarweise Distanzberechnung.
`torch.nn.CosineSimilarity(dim, eps)`	Kosinusähnlichkeitsberechnung.

Parallele Schichten (DataParallel)

Klasse/Funktion	Beschreibung
`torch.nn.DataParallel(module, device_ids, output_device, dim)`	Datenparallelismus, führt das Modell parallel auf mehreren GPUs aus.
`torch.nn.parallel.DistributedDataParallel(module, device_ids, broadcast_buffers, bucket_cap_mb, find_unused_parameters, gradient_as_bucket_view, static_graph)`	Verteilter Datenparallelismus, wird für verteiltes Training über mehrere Knoten verwendet.

Hilfsfunktionen (nn.functional)

Funktion	Beschreibung
`torch.nn.functional.relu(input, inplace)`	Wendet die ReLU-Aktivierungsfunktion an.
`torch.nn.functional.sigmoid(input)`	Wendet die Sigmoid-Aktivierungsfunktion an.
`torch.nn.functional.tanh(input)`	Wendet die Tanh-Aktivierungsfunktion an.
`torch.nn.functional.softmax(input, dim, dtype)`	Wendet die Softmax-Aktivierungsfunktion an.
`torch.nn.functional.log_softmax(input, dim, dtype)`	Wendet die Log-Softmax-Aktivierungsfunktion an.
`torch.nn.functional.gelu(input)`	Wendet die GELU-Aktivierungsfunktion an.
`torch.nn.functional.silu(input)`	Wendet die SiLU-Aktivierungsfunktion (Swish) an.
`torch.nn.functional.mish(input)`	Wendet die Mish-Aktivierungsfunktion an.
`torch.nn.functional.hardswish(input)`	Wendet die Hardswish-Aktivierungsfunktion an.
`torch.nn.functional.leaky_relu(input, negative_slope, inplace)`	Wendet die LeakyReLU-Aktivierungsfunktion an.
`torch.nn.functional.elu(input, alpha, inplace)`	Wendet die ELU-Aktivierungsfunktion an.
`torch.nn.functional.dropout(input, p, training, inplace)`	Wendet Dropout an.
`torch.nn.functional.conv1d(input, weight, bias, stride, padding, dilation, groups)`	Eindimensionale Faltungsoperation.
`torch.nn.functional.conv2d(input, weight, bias, stride, padding, dilation, groups)`	Zweidimensionale Faltungsoperation.
`torch.nn.functional.conv3d(input, weight, bias, stride, padding, dilation, groups)`	Dreidimensionale Faltungsoperation.
`torch.nn.functional.max_pool1d(input, kernel_size, stride, padding, dilation, return_indices)`	Eindimensionales Max-Pooling.
`torch.nn.functional.max_pool2d(input, kernel_size, stride, padding, dilation, return_indices, ceil_mode)`	Zweidimensionales Max-Pooling.
`torch.nn.functional.avg_pool1d(input, kernel_size, stride, padding, ceil_mode, count_include_pad)`	Eindimensionales Average-Pooling.
`torch.nn.functional.avg_pool2d(input, kernel_size, stride, padding, ceil_mode, count_include_pad)`	Zweidimensionales Average-Pooling.
`torch.nn.functional.linear(input, weight, bias)`	Lineare Transformation (Matrixmultiplikation).
`torch.nn.functional.cross_entropy(input, target, weight, size_average, ignore_index, reduce, reduction, label_smoothing)`	Berechnet den Cross-Entropy-Verlust.
`torch.nn.functional.mse_loss(input, target, size_average, reduce, reduction)`	Berechnet den Mean-Squared-Error-Verlust.
`torch.nn.functional.l1_loss(input, target, size_average, reduce, reduction)`	Berechnet den L1-Verlust.
`torch.nn.functional.binary_cross_entropy(input, target, weight, size_average, reduce, reduction)`	Berechnet den binären Cross-Entropy-Verlust.
`torch.nn.functional.nll_loss(input, target, weight, size_average, ignore_index, reduce, reduction)`	Berechnet den negativen Log-Likelihood-Verlust.
`torch.nn.functional.huber_loss(input, target, delta, size_average, reduce, reduction)`	Berechnet den Huber-Verlust.
`torch.nn.functional.batch_norm(input, running_mean, running_var, weight, bias, training, momentum, eps, track_running_stats)`	Batch-Normalisierungsoperation.
`torch.nn.functional.layer_norm(input, normalized_shape, weight, bias, eps)`	Layer-Normalisierungsoperation.
`torch.nn.functional.group_norm(input, num_groups, weight, bias, eps)`	Gruppen-Normalisierungsoperation.
`torch.nn.functional.interpolate(input, size, scale_factor, mode, align_corners, recompute_scale_factor)`	Interpolation (Upsampling/Downsampling).
`torch.nn.functional.grid_sample(input, grid, mode, padding_mode, align_corners)`	Grid-Sampling, verwendet für Bildregistrierung und Spatial-Transformer-Netzwerke.
`torch.nn.functional.affine_grid(theta, size, align_corners)`	Affine-Gitter-Generierung, verwendet für Spatial-Transformer-Netzwerke.
`torch.nn.functional.pixel_shuffle(input, upscale_factor)`	Pixel-Shuffle.
`torch.nn.functional.pixel_unshuffle(input, downscale_factor)`	Inverser Pixel-Shuffle.
`torch.nn.functional.pad(input, pad, mode, value)`	Padding-Operation.
`torch.nn.functional.one_hot(tensor, num_classes)`	Wandelt Ganzzahlen in One-Hot-Kodierung um.
`torch.nn.functional.embedding(input, weight, padding_idx, max_norm, norm_type, scale_grad_by_freq, sparse)`	Embedding-Operation.
`torch.nn.functional.cosine_similarity(x1, x2, dim, eps)`	Kosinusähnlichkeitsberechnung.
`torch.nn.functional.pairwise_distance(x1, x2, p, eps, keepdim)`	Paarweise Distanzberechnung.

Hilfsfunktionen (nn.utils)

Funktion	Beschreibung
`torch.nn.utils.clip_grad_norm_(parameters, max_norm, norm_type, error_if_nonfinite)`	Begrenzt die Gradientennorm (In-Place-Operation).
`torch.nn.utils.clip_grad_norm(parameters, max_norm, norm_type)`	Begrenzt die Gradientennorm (nicht in-place).
`torch.nn.utils.clip_grad_value_(parameters, clip_value)`	Begrenzt den Wertebereich der Gradienten.
`torch.nn.utils.get_total_norm(parameters, norm_type)`	Berechnet die Gesamtgradientennorm.
`torch.nn.utils.weight_norm(module, name, dim)`	Wendet Gewichtsnormalisierung auf Modulparameter an.
`torch.nn.utils.remove_weight_norm(module, name)`	Entfernt die Gewichtsnormalisierung.
`torch.nn.utils.spectral_norm(module, name, n_power_iterations, eps, bias)`	Wendet Spektralnormalisierung auf Modulparameter an.
`torch.nn.utils.remove_spectral_norm(module, name)`	Entfernt die Spektralnormalisierung.
`torch.nn.utils.fuse_conv_bn_eval(conv, bn)`	Fusioniert Faltungsschichten und Batch-Normalisierungsschichten (Inferenzmodus).
`torch.nn.utils.fuse_linear_bn_eval(linear, bn)`	Fusioniert lineare Schichten und Batch-Normalisierungsschichten (Inferenzmodus).
`torch.nn.utils.skip_init(module_class, args, *kwargs)`	Überspringt die Parameterinitialisierung.
`torch.nn.utils.parameters_to_vector(parameters)`	Flacht eine Parameterliste zu einem Vektor ab.
`torch.nn.utils.vector_to_parameters(vector, parameters)`	Formt einen Vektor zu einer Parameterliste um.

Parameterinitialisierung (nn.init)

Funktion	Beschreibung
`torch.nn.init.zeros_(tensor)`	Initialisiert einen Tensor mit Nullen.
`torch.nn.init.ones_(tensor)`	Initialisiert einen Tensor mit Einsen.
`torch.nn.init.uniform_(tensor, a, b)`	Initialisierung mit Gleichverteilung.
`torch.nn.init.normal_(tensor, mean, std)`	Initialisierung mit Normalverteilung.
`torch.nn.init.constant_(tensor, val)`	Initialisierung mit konstantem Wert.
`torch.nn.init.eye_(tensor)`	Initialisierung mit Einheitsmatrix (nur auf quadratische 2D-Matrizen anwendbar).
`torch.nn.init.dirac_(tensor)`	Dirac-Delta-Initialisierung (behält die Anzahl der Eingabekanäle bei).
`torch.nn.init.xavier_uniform_(tensor, gain)`	Xavier-Initialisierung mit Gleichverteilung.
`torch.nn.init.xavier_normal_(tensor, gain)`	Xavier-Initialisierung mit Normalverteilung.
`torch.nn.init.kaiming_uniform_(tensor, a, mode, nonlinearity)`	Kaiming-Initialisierung mit Gleichverteilung, geeignet für ReLU-Aktivierungen.
`torch.nn.init.kaiming_normal_(tensor, a, mode, nonlinearity)`	Kaiming-Initialisierung mit Normalverteilung, geeignet für ReLU-Aktivierungen.
`torch.nn.init.trunc_normal_(tensor, mean, std, a, b)`	Initialisierung mit abgeschnittener Normalverteilung.
`torch.nn.init.orthogonal_(tensor, gain)`	Orthogonale Initialisierung.
`torch.nn.init.sparse_(tensor, sparsity, std)`	Sparse-Initialisierung (größtenteils null).
`torch.nn.init.calculate_gain(nonlinearity, param)`	Berechnet den Initialisierungs-Gain-Wert.

RNN-Hilfsfunktionen

Funktion	Beschreibung
`torch.nn.utils.rnn.PackedSequence`	Sequenzen packen, um Sequenzen variabler Länge zu verarbeiten.
`torch.nn.utils.rnn.pack_padded_sequence(input, lengths, batch_first, enforce_sorted)`	Gepolsterte Sequenzen packen.
`torch.nn.utils.rnn.pad_packed_sequence(input, batch_first, padding_value, total_length)`	Sequenzen entpacken.
`torch.nn.utils.rnn.pad_sequence(sequences, batch_first, padding_value)`	Sequenzen auf dieselbe Länge auffüllen.
`torch.nn.utils.rnn.pack_sequence(sequences, enforce_sorted)`	Direkt eine Liste von Sequenzen packen.

Pruning-Funktionen

Funktion	Beschreibung
`torch.nn.utils.prune.random_unstructured(module, name, amount)`	Zufälliges unstrukturiertes Pruning.
`torch.nn.utils.prune.l1_unstructured(module, name, amount)`	Unstrukturiertes L1-Pruning.
`torch.nn.utils.prune.global_unstructured(parameters, pruning_method, amount)`	Globales unstrukturiertes Pruning.
`torch.nn.utils.prune.remove(module, name)`	Pruning entfernen.
`torch.nn.utils.prune.is_pruned(module)`	Prüfen, ob ein Modul gepruned wurde.

Flatten-Layer

Klasse/Funktion	Beschreibung
`torch.nn.Flatten(start_dim, end_dim)`	Einen Tensor abflachen, um einen mehrdimensionalen Tensor auf zwei Dimensionen zu reduzieren.
`torch.nn.Unflatten(dim, unflattened_size)`	Unflatten, einen eindimensionalen Tensor in einen mehrdimensionalen umformen.

Beispiel

import torch
import torch.nn as nn

# Ein einfaches neuronales Netzwerk definieren
class SimpleNet(nn.Module):
def __init__(self):
super(SimpleNet, self).__init__()
self.fc1 = nn.Linear(10, 20)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(20, 1)

def forward(self, x):
x = self.fc1(x)
x = self.relu(x)
x = self.fc2(x)
return x

# Modell und Eingabe erstellen
model = SimpleNet()
input = torch.randn(5, 10)
output = model(input)
print(output)

Beispiel: Bildklassifikation mit CNN

import torch
import torch.nn as nn

class CNN(nn.Module):
def __init__(self):
super(CNN, self).__init__()
# Faltungsschicht
self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)
self.conv3 = nn.Conv2d(32, 64, kernel_size=3, padding=1)

# Pooling-Schicht
self.pool = nn.MaxPool2d(2, 2)

# Batch-Normalisierung
self.bn1 = nn.BatchNorm2d(16)
self.bn2 = nn.BatchNorm2d(32)
self.bn3 = nn.BatchNorm2d(64)

# Aktivierungsfunktion
self.relu = nn.ReLU()

# Vollständig verbundene Schicht
self.fc1 = nn.Linear(64 * 4 * 4, 256)
self.fc2 = nn.Linear(256, 10)

# Dropout
self.dropout = nn.Dropout(0.5)

def forward(self, x):
# Conv -> BN -> ReLU -> Pool
x = self.pool(self.relu(self.bn1(self.conv1(x))))
x = self.pool(self.relu(self.bn2(self.conv2(x))))
x = self.pool(self.relu(self.bn3(self.conv3(x))))

# Flatten
x = x.view(x.size(0), -1)

# FC -> ReLU -> Dropout -> FC
x = self.dropout(self.relu(self.fc1(x)))
x = self.fc2(x)
return x

# Modell erstellen
model = CNN()
print(model)

# Teste die Vorwärtspropagation
input_tensor = torch.randn(1, 3, 32, 32)
output = model(input_tensor)
print("Ausgabeform:", output.shape)

Beispiel: Textklassifikation mit LSTM

import torch
import torch.nn as nn

class LSTMClassifier(nn.Module):
def __init__(self, vocab_size, embedding_dim, hidden_dim, num_layers, output_dim):
super(LSTMClassifier, self).__init__()

# Embedding-Schicht
self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=0)

# LSTM-Schicht
self.lstm = nn.LSTM(
embedding_dim,
hidden_dim,
num_layers=num_layers,
batch_first=True,
bidirectional=True,
dropout=0.5
)

# Vollständig verbundene Schicht
self.fc = nn.Linear(hidden_dim * 2, output_dim)

# Dropout
self.dropout = nn.Dropout(0.5)

def forward(self, text, text_lengths):
# Einbettung
embedded = self.embedding(text)

# Sequenzen packen, um Eingaben variabler Länge zu verarbeiten
packed = nn.utils.rnn.pack_padded_sequence(
embedded, text_lengths.cpu(), batch_first=True, enforce_sorted=False
)

# LSTM
packed_output, (hidden, cell) = self.lstm(packed)

# Entpacken
output, output_lengths = nn.utils.rnn.pad_packed_sequence(packed_output, batch_first=True)

# Bidirektionale finale verborgene Zustände zusammenführen
hidden = torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1)

# Dropout und vollständig verbunden
hidden = self.dropout(hidden)
output = self.fc(hidden)

return output

# Parameter
vocab_size = 10000
embedding_dim = 128
hidden_dim = 256
num_layers = 2
output_dim = 5 # 5 Klassen

# Modell erstellen
model = LSTMClassifier(vocab_size, embedding_dim, hidden_dim, num_layers, output_dim)
print(model)

Beispiel: Verwendung des Transformer-Encoders

import torch
import torch.nn as nn

class TransformerClassifier(nn.Module):
def __init__(self, input_dim, d_model, nhead, num_layers, dim_feedforward, output_dim, dropout):
super(TransformerClassifier, self).__init__()

# Embedding-Schicht
self.embedding = nn.Linear(input_dim, d_model)

# Positionskodierung
self.positional_encoding = nn.Parameter(torch.randn(1, 1000, d_model) * 0.1)

# Transformer-Encoder-Schicht
encoder_layer = nn.TransformerEncoderLayer(
d_model=d_model,
nhead=nhead,
dim_feedforward=dim_feedforward,
dropout=dropout,
batch_first=True
)

# Transformer-Encoder
self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)

# Klassifizierungskopf
self.fc = nn.Linear(d_model, output_dim)
self.dropout = nn.Dropout(dropout)

def forward(self, x):
# Positionskodierung hinzufügen
seq_len = x.size(1)
x = self.embedding(x) + self.positional_encoding[:, :seq_len, :]

# Transformer-Kodierung
x = self.transformer_encoder(x)

# Die Ausgabe an der ersten Position zur Klassifizierung verwenden (ähnlich dem CLS-Token)
x = x[:, 0, :]

x = self.dropout(x)
x = self.fc(x)

return x

# Parameter
input_dim = 512
d_model = 512
nhead = 8
num_layers = 6
dim_feedforward = 2048
output_dim = 10
dropout = 0.1

# Modell erstellen
model = TransformerClassifier(input_dim, d_model, nhead, num_layers, dim_feedforward, output_dim, dropout)
print(model)

# Test
x = torch.randn(32, 100, input_dim) # batch_size=32, seq_len=100
output = model(x)
print("Ausgabeform:", output.shape) # (32, 10)

Wenn Sie ausführlichere Informationen benötigen, können Siedie offizielle PyTorch-Dokumentation konsultieren。

Weitere Erweiterungen