Einführung: nn.Linear in PyTorch, klar erklärt

Name

Matt Popovic

Updated on 14.11.2025

nn.Linear ist einer der grundlegendsten Bausteine in PyTorch.
Egal ob du ein einfaches Multi-Layer Perceptron (MLP), einen Transformer oder ein großskaliges Deep-Learning-System baust – lineare Layer sind überall und führen schnelle affine Transformationen auf deinen Daten aus.

Mit PyTorch 2.x profitieren lineare Layer nun von aktualisierten Kernels, Compiler-Optimierungen (torch.compile) und besserer GPU-Beschleunigung. Dieser aktualisierte Leitfaden deckt alles ab, was du wissen musst – von den Grundlagen bis hin zur modernen Deep-Learning-Nutzung.

Du möchtest schnell Data Visualization aus einem Python Pandas DataFrame mit zero code erstellen?

PyGWalker ist eine Python-Bibliothek für Exploratory Data Analysis mit Visualization.
Sie verwandelt dein pandas- oder polars-DataFrame in ein Tableau-ähnliches UI in Jupyter Notebook.

👉 PyGWalker auf GitHub (opens in a new tab)

(opens in a new tab)

nn.Linear in PyTorch verstehen

Was ist nn.Linear?

nn.Linear wendet eine affine Transformation auf Eingabedaten an:

[ y = xA^T + b ]

• x: Eingabetensor
• A: Gewichtsmatrix (out_features × in_features)
• b: Bias-Vektor (out_features)
• y: Ausgabetensor

Das Modul nimmt zwei Pflichtargumente:

nn.Linear(in_features, out_features, bias=True)

Beispiel:

import torch
from torch import nn
 
linear_layer = nn.Linear(in_features=3, out_features=1)

Dies erzeugt:

• Gewichtsshape: 1 × 3
• Bias-Shape: 1

Wie funktioniert nn.Linear?

Ein Forward-Pass führt aus:

• Matrixmultiplikation mit den Gewichten
• Addition des Bias (falls aktiviert)

output = linear_layer(torch.tensor([1., 2., 3.]))
print(output)

📌 Moderne Nutzung: Batched Inputs

PyTorch wendet nn.Linear auf die letzte Dimension an.
Dadurch funktioniert es nahtlos mit:

2D-Inputs (batch, features)

[batch, in_features]

3D-Inputs (batch, seq_len, features)

Typisch in Transformern:

[batch, seq_len, in_features] → [batch, seq_len, out_features]

Beispiel:

x = torch.randn(32, 128, 512)   # batch=32, seq_len=128, hidden=512
linear = nn.Linear(512, 1024)
y = linear(x)                   # output: [32, 128, 1024]

Kein Reshape nötig – das ist wichtig für Attention-Projektionen (Q, K, V).

Initialisierung von Gewichten und Biases

PyTorch initialisiert Gewichte standardmäßig mit Kaiming Uniform, aber du kannst das mit torch.nn.init anpassen.

import torch.nn.init as init
 
init.xavier_uniform_(linear_layer.weight)
init.zeros_(linear_layer.bias)

Wann bias=False verwenden

Du schaltest den Bias häufig aus, wenn:

• direkt nach dem Linear-Layer Normalization-Layer folgen
  (z. B. LayerNorm in Transformern)
• Q/K/V-Projektionslayer in Attention-Blöcken
• Linear-Layer innerhalb von Residual-Blöcken verwendet werden

Beispiel:

nn.Linear(embed_dim, embed_dim, bias=False)

Vergleich von nn.Linear und nn.Conv2d

Wichtige Unterschiede:

• Linear-Layer verwenden dichte Verbindungen (all-to-all).
• Conv2D verwendet räumlich lokale Kernel, reduziert Parameter und führt Inductive Bias ein.

Anwendungen von nn.Linear im Deep Learning

1. Multi-Layer Perceptron (MLP)

layer = nn.Linear(256, 128)

2. Transformer-Modelle

Ein Standard-Transformer verwendet Linear-Layer für:

• Q-, K-, V-Projektionen
• MLP-Feed-Forward-Netzwerke
• Output-Heads

Beispiel:

q = nn.Linear(d_model, d_model, bias=False)

3. Classification Heads

classifier = nn.Linear(hidden_dim, num_classes)

4. Autoencoder

Sowohl Encoder als auch Decoder verwenden Linear-Layer zum Komprimieren und Rekonstruieren.

Verwendung von nn.Linear in einem PyTorch-Modell

import torch.nn.functional as F
from torch import nn
 
class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(10, 5)
        self.fc2 = nn.Linear(5, 2)
 
    def forward(self, x):
        x = F.relu(self.fc1(x))
        return self.fc2(x)
 
net = Net()

Moderne PyTorch 2.x Tipps (Wichtig!)

🚀 1. torch.compile optimiert Linear-Layer

model = torch.compile(net)

Compiling fused Operationen für schnellere GPU-Performance.

⚡ 2. AMP für schnelleres Training auf GPUs

with torch.cuda.amp.autocast():
    output = model(x)

📉 3. Quantized Linear für Inference

import torch.ao.quantization as quant

Reduziert die Modellgröße und beschleunigt Inference.

🔧 4. F.linear für eigene gefusete Operationen verwenden

import torch.nn.functional as F
y = F.linear(x, weight, bias)

Nützlich, wenn du mehrere Operationen manuell kombinierst.

Häufige Fehler und wie man sie behebt

1. Shape-Mismatch

RuntimeError: mat1 and mat2 shapes cannot be multiplied

Lösung: Stelle sicher, dass die letzte Dimension des Inputs zu in_features passt.

2. 3D-Inputs übergeben, ohne nn.Linear die Shape übernehmen zu lassen

Vermeide unnötiges Reshaping – Linear unterstützt 3D bereits.

3. .float() vergessen, wenn Integer-Tensoren im Spiel sind

x = x.float()

Fazit

nn.Linear ist ein scheinbar einfaches, aber fundamentales Modul in PyTorch.
Von MLPs über Transformer bis hin zu modernen generativen Modellen – Linear-Layer machen einen Großteil der Rechenarbeit in heutigen Deep-Learning-Systemen aus.

Wenn du verstehst,

• wie sie funktionieren,
• wie sie mit verschiedenen Input-Shapes umgehen
• und wie du sie mit PyTorch 2.x optimierst,

wirst du deutlich effektiver beim Bau neuronaler Modelle.

FAQs

Was ist der Zweck eines Bias-Vektors in nn.Linear?

Der Bias erlaubt es dem Modell, Ausgabewerte unabhängig vom Input zu verschieben. Das erhöht die Flexibilität, insbesondere wenn Inputs nicht um Null zentriert sind.

Wie initialisiert man Gewichte und Biases?

PyTorch initialisiert sie automatisch, aber du kannst dies mit torch.nn.init überschreiben (z. B. Xavier-Initialisierung).

Unterschied zwischen nn.Linear und nn.Conv2d?

nn.Linear wendet eine dichte affine Transformation an; nn.Conv2d wendet räumliche Convolution an. Linear-Layer werden in MLPs und Transformern verwendet, während Conv2D-Layer in CNNs für Bilddaten eingesetzt werden.