Mathematische Grundlagen fürs Deep Learning verständlich erklärt

Entdecke grundlegende Mathekonzepte für Data Science und Deep Learning wie Skalar und Vektor, Determinante, Singulärwertzerlegung und mehr.

Aktualisiert 18. Sept. 2026 · 11 Min. lesen

Mit KI erkunden

ChatGPT Claude Perplexity

Data Science ist ein interdisziplinäres Feld, das Mathematik und fortgeschrittene Statistik nutzt, um Vorhersagen zu treffen. Alle Data-Science-Algorithmen greifen direkt oder indirekt auf mathematische Konzepte zurück. Ein solides Matheverständnis hilft dir, innovative Data-Science-Lösungen zu entwickeln, etwa ein Empfehlungssystem. Wenn du in Mathematik fit bist, fällt dir der Einstieg in Data Science deutlich leichter. Als Data Scientist nutzt du grundlegende mathematische Konzepte, um Probleme zu lösen.

Neben Mathematik brauchst du auch Domänenwissen, Programmierkenntnisse, Businesskompetenz, analytisches Denken und Neugier. An Mathematik führt für Data Scientists kein Weg vorbei. Du musst dir die Grundlagen von Mathematik und Statistik aneignen, um Data Scientist zu werden.

Skalar und Vektor

Skalare: Ein Skalar ist eine einzelne Zahl, die mit einem Vektor im Raum über skalares Multiplizieren interagiert.

Vektoren: Ein Vektor V ist eine geordnete Menge von Elementen. Ein Vektor ist ein Zahlenarray, entweder als Zeile oder Spalte. Vektoren lassen sich addieren und mit einer reellen Zahl multiplizieren, die als Skalar bezeichnet wird.

Image Source

# Import numpy module
import numpy as np

# creating a vector
v = np.array([1, 2, 3, 4, 5])
print(v)

[1 2 3 4 5]

# Vector Operations
# Import numpy module
import numpy as np

# Create two vector
a = np.array([1, 2, 3, 4, 5])
b = np.array([1, 2, 3, 4, 5])

# adding two vectors
add = a + b
print("Addition:",add)

# Vector Subtraction
sub = a - b
print("Subtraction:",sub)

# Vector Multiplication
mul = a * b
print("Multiplication:",mul)

# Vector Division
div = a / b
print("division",div)

Addition: [ 2  4  6  8 10]
Subtraction: [0 0 0 0 0]
Multiplication: [ 1  4  9 16 25]
division [1. 1. 1. 1. 1.]

Matrix und Tensor

Matrizen: Eine Matrix ist ein n-dimensionales Zahlenarray, das Transformationen repräsentiert. Du kannst dir eine Matrix als Transformation wie „Skalieren“, „Rotieren“, „Scheren“ oder „Spiegeln“ vorstellen. Sie bildet einzelne Punkte im Raum auf andere Punkte ab.

# Import numpy module
import numpy as np

# create 2*2 matrix
a1=np.array([[1, 2], [3, 4]])
a2=np.array([[1, 2], [3, 4]])

# Dot Product
dot_product = np.dot(a1,a2)
print("Dot Product: \n",dot_product)

# Cross Product
cross_product = np.cross(a1,a2)
print("Cross Product: \n", cross_product)

Dot Product:
 [[ 7 10]
 [15 22]]
Cross Product:
 [0 0]

Das Skalarprodukt zweier Vektoren entspricht der Projektion eines Vektors auf einen anderen. Das Kreuzprodukt zweier Vektoren liefert einen Vektor, der senkrecht auf der Ebene steht, in der beide Vektoren liegen.

Tensoren: Manchmal benötigst du Arrays mit mehr als zwei Dimensionen, deren Dimensionen in einem Gitter angeordnet sind – das ist ein Tensor. Die Anzahl der Dimensionen eines Tensors nennt man seinen Rang. Skalare und Vektoren sind Sonderfälle von Tensoren: Tensoren 0. Ordnung sind Skalare, Tensoren 1. Ordnung sind Vektoren.

Image source

Determinante

Die Determinante ist ein Skalarwert, der angibt, um welchen Faktor Längen (in 1D), Flächen (in 2D) oder Volumina (in 3D) durch eine lineare Abbildung skaliert werden. Hat die Determinante den Wert 2, verdoppelt sich zum Beispiel das Volumen (in 3D). Ist sie 1, ändert sich das Volumen nicht. Bei einer Determinante von 0 ist die Matrix nicht invertierbar, da Null mal irgendetwas wieder Null ergibt.

Eigenschaften:

Die Determinante eines Matrixprodukts ist das Produkt der Determinanten: det(M1·M2) = det(M1) · det(M2).
Die Determinante einer Matrix entspricht dem Produkt ihrer Eigenwerte.
Multiplizierst du eine Matrix mit einer Konstanten c, ändert sich die Determinante zu det(cM) = c^N · det(M), wobei N die Dimension der Matrix ist.

Wenn deine Matrix ein dehnbares Spielzeug beschreibt, zeigt dir die Determinante, wie stark du es gedehnt hast.

# Import numpy module
import numpy as np

# Create 2*2 matrix
arr=np.array([[1,2],[3,4]])

# Compute Determinant of a matrix
arr_det=np.linalg.det(arr)

# Print the Computed Determinant
print("Determinant:",arr_det)

Determinant: -2.0000000000000004

Eigenwerte und Eigenvektoren

Ein Eigenvektor einer quadratischen Matrix A ist ein von Null verschiedener Vektor v, der durch Multiplikation mit A nur in seiner Länge skaliert wird.

Image Source

Eigenvektoren heißen auch charakteristische Vektoren. Bei einer linearen Transformation ändern sie sich ausschließlich um einen Skalarfaktor.

Eigenvektoren sind die Rotationsachsen der linearen Transformation. Diese Richtungen bleiben fest; der zugehörige Eigenwert ist der Skalierungsfaktor, um den die Matrix streckt oder staucht. Eigenwerte werden auch charakteristische Werte oder -wurzeln genannt. Vereinfacht: Eigenvektoren geben die festen Richtungen (Geraden/Ebenen) der Transformation vor, und die Eigenwerte bestimmen deren Verzerrungsfaktoren.

Die Determinante beschreibt, um wie viel sich Flächen bzw. Volumina unter einer linearen Transformation ändern. Daher ist das Produkt der Eigenwerte gleich der Determinante.

# Import numpy module
import numpy as np

# Create 2*2 matrix
arr=np.array([[1,2],[3,4]])

# Find eigenvalues and eigenvectors
eigenvalues, eigenvectors = np.linalg.eig(arr)

# print the eigenvalues and eigenvectors
print("Eigen Values: \n",eigenvalues)
print("Eigen Vectors:\n", eigenvectors)

Eigen Values:
 [-0.37228132  5.37228132]
Eigen Vectors:
 [[-0.82456484 -0.41597356]
 [ 0.56576746 -0.90937671]]

NORM-Funktion

Manchmal möchtest du die Größe eines Vektors messen. Dabei hilft die Normfunktion. Sie ordnet jedem Vektor im Vektorraum eine strikt positive Länge zu, außer dem Nullvektor. Dazu gehören die L^p-Normen. Normen bilden Vektoren auf nichtnegative Werte ab. Für Vektoren entspricht die Norm der euklidischen Länge; für Matrizen ist sie gleich dem größten Singulärwert.

# import numpy module
import numpy as np

# Create 3*3 Matrix
a = np.array([[1,2,3],[4,5,6],[7,8,9]])

# Compute norm
a_norm = np.linalg.norm(a)

# print the norm of function
print(a_norm)

16.881943016134134

Matrixfaktorisierung

Matrixfaktorisierung, auch Matrixzerlegung genannt, zerlegt eine Matrix in ihre Bestandteile. Sie ist vergleichbar mit der Primfaktorzerlegung von Zahlen, etwa 10 = 2 × 5. Sie wird zum Lösen linearer Gleichungssysteme eingesetzt.

Gängige Verfahren der Matrixfaktorisierung sind:

LU-Zerlegung für quadratische Matrizen; sie zerlegt in L- und U-Komponenten.

QR-Zerlegung für m×n-Matrizen (nicht auf quadratische Matrizen beschränkt); sie zerlegt in Q- und R-Komponenten.

Cholesky-Zerlegung für lineare Ausgleichsprobleme in der linearen Regression sowie in Simulation und Optimierung.

Singulärwertzerlegung, erklärt im nächsten Abschnitt.

Singulärwertzerlegung

Vorhin haben wir die Eigenzerlegung einer Matrix gesehen, die in Eigenvektoren und Eigenwerte zerlegt. Die Singulärwertzerlegung (SVD) ist eine Form der Matrixfaktorisierung, die in Singulärvektoren und Singulärwerte zerlegt. Sie hat zahlreiche Anwendungen, u. a. in Signalverarbeitung, Psychologie, Soziologie, Klima- und Atmosphärenwissenschaften, Statistik und Astronomie.

M ist eine m×m-Matrix.
U ist eine m×n-Matrix der linken Singulärvektoren.
Σ ist eine n×n-Diagonalmatrix mit nichtnegativen reellen Zahlen.
V ist eine m×n-Matrix der rechten Singulärvektoren.
V* ist eine n×m-Matrix, die Transponierte von V.

# Import numpy module
import numpy as np

# Create 3*3 matrix
a = np.array([[1, 3, 4], [5, 6, 9], [1, 2, 3], [7, 6, 8]])

# Decomposition of matrix using SVD
U, s, Vh = np.linalg.svd(a, full_matrices=False)

U,s,Vh

(array([[-0.27067357, -0.61678044,  0.69789573],
        [-0.65939972, -0.2937857 , -0.62152182],
        [-0.20244298, -0.3480035 , -0.06765408],
        [-0.67152413,  0.64200111,  0.34939247]]),
 array([18.0376394 ,  2.34360292,  0.38870323]),
 array([[-0.46961711, -0.51018039, -0.72053851],
        [ 0.87911451, -0.19502274, -0.43488368],
        [-0.08134773,  0.83766467, -0.54009299]]))

# Generate the initial matrix
new_a = np.dot(U, np.dot(np.diag(s), Vh))

# Print original matrix
print(new_a)

[[1. 3. 4.]
 [5. 6. 9.]
 [1. 2. 3.]
 [7. 6. 8.]]

Moore-Penrose-Pseudoinverse

Die Pseudoinverse einer Matrix verallgemeinert die Inverse. Sie wird zur Berechnung von Ausgleichslösungen (Least Squares) verwendet. Die Moore-Penrose-Inverse ist die gebräuchlichste Form der Matrixpseudoinversen.

# Import numpy module
import numpy as np

# Create 3*3 matrix
a = np.array([[1, 3, 4], [5, 6, 9], [1, 2, 3], [7, 6, 8]])

# Compute the (Moore-Penrose) pseudo-inverse of a matrix.
inv=np.linalg.pinv(a)

# Print pseudo-inverse of a matrix.
print(inv)

[[-0.37037037  0.03703704 -0.11111111  0.18518519]
 [ 1.56296296 -1.2962963  -0.11111111  0.71851852]
 [-0.84444444  0.94444444  0.16666667 -0.57777778]]

Hadamard-Produkt

Das Hadamard- oder Schur-Produkt ist die elementweise Multiplikation zweier Matrizen gleicher Dimension. Es ist einfacher als das übliche Matrixprodukt. Das Hadamard-Produkt findet unter anderem Einsatz in JPEG-Lossy-Kompressionsalgorithmen. Es ist kommutativ, assoziativ und distributiv, erleichtert das Invertieren und vereinfacht die Berechnung von Potenzmatrizen.

Das Hadamard-Produkt wird in vielen Bereichen genutzt, etwa bei Fehlerkorrektur in Satellitenübertragungen, Informationstheorie, Kryptographie, Mustererkennung, neuronalen Netzen, Maximum-Likelihood-Schätzung, JPEG-Lossy-Kompression, multivariater Statistik und linearem Modellieren.

# Import numpy module
import numpy as np

# Create 2*2 matrix a1 and a2
a1=np.array([[1, 2], [3, 4]])
a2=np.array([[1, 2], [3, 4]])

# Element wise multiplication
hadamard_product = np.multiply(a1,a2)

# Print hadamard distance
print("Hadamard Product: \n", hadamard_product)

Hadamard Product:
 [[ 1  4]
 [ 9 16]]

Entropie

„Die Entropie einer Zufallsvariablen ist eine Funktion, die versucht, deren Unvorhersehbarkeit zu charakterisieren.“ (Entropy and Mutual Information) Sie dient beim automatischen Aufbau von Entscheidungsbäumen zur Merkmalsauswahl nach Entropiekriterien. Die Modellwahl folgt oft dem Prinzip der maximalen Entropie: Von mehreren konkurrierenden Modellen ist das mit der höchsten Entropie das beste.

„Nimmt eine Zufallsvariable X Werte aus der Menge χ={x1, x2, ..., xn} an und ist durch eine Wahrscheinlichkeitsverteilung P(X) definiert, dann schreiben wir die Entropie der Zufallsvariablen wie folgt:“ (Entropy and Mutual Information)

„Wenn der Logarithmus zur Basis 2 verwendet wird, wird die Entropie in Bits angegeben. Beim natürlichen Logarithmus wird sie in Nats ausgedrückt. Üblicher ist die Angabe in Bits.“ (Entropy and Mutual Information)

# Import scipy and numpy module
import scipy.stats
import numpy as np

# Create an array
a=np.array([1,1,2,3,1,3,4,2,5,6,3,2,4,3])


# Compute probability distribution
a_pdf=scipy.stats.norm.pdf(a)

# Calculate the entropy of a distribution for given probability values.
entropy = scipy.stats.entropy(a_pdf) # get entropy from probability values
print("Entropy: ",entropy)

Entropy:  1.6688066853941022

Kullback-Leibler-Divergenz

Die Kullback–Leibler-Divergenz ist die relative Entropie zweier Wahrscheinlichkeitsverteilungen. Sie misst, wie stark sich eine Verteilung von einer Referenzverteilung unterscheidet. Ein Wert von 0 bedeutet, dass beide Verteilungen identisch sind. Formal lässt sie sich so ausdrücken:

Sie klingt wie ein Abstandsmaß, ist es aber nicht, da sie asymmetrisch ist, also nicht kommutativ. Allgemein gilt D(p, q) ≠ D(q, p). Die KL-Divergenz wird häufig in unüberwachten Verfahren wie „Variational Autoencoders“ eingesetzt.

# Import scipy.stats and numpy module
import scipy.stats
import numpy as np

# Create numpy arrays
a=np.array([1,1,2,3,1,3,4,2,5,6,3,2,4,3])
b=np.array([1,1,3,4,2,4,5,2,5,6,3,2,4,3])

# Compute probability distribution
a_pdf=scipy.stats.norm.pdf(a)
b_pdf=scipy.stats.norm.pdf(b)

# compute relative entropy or KL Divergence
kl_div=scipy.stats.entropy(a_pdf,b_pdf)

print("KL Divergence: ",kl_div)

KL Divergence:  0.26732496641464365

Gradientenabstieg

Der Gradientenabstieg ist einer der bekanntesten Optimierungsalgorithmen für Koeffizienten und Bias in linearer Regression, logistischer Regression und neuronalen Netzen. Er ist ein iteratives Verfahren, das das Minimum einer gegebenen Funktion findet.

Image Source

Image Source

Es gibt drei Varianten: Full-Batch, Stochastic und Mini-Batch Gradientenabstieg. Full-Batch nutzt das gesamte Dataset zur Gradientenberechnung, Stochastic verwendet jeweils nur ein einzelnes Beispiel. Mini-Batch kombiniert beide Ansätze: Das Trainingsset wird in kleine Batches aufgeteilt, die den Loss nacheinander berechnen und am Ende mitteln.

Fazit

Glückwunsch, du hast es bis ans Ende dieses Tutorials geschafft!

Du hast grundlegende mathematische Konzepte fürs Deep Learning kennengelernt: Skalar, Vektor, Matrix, Tensor, Determinante, Eigenwerte, Eigenvektoren, NORM-Funktion, Singulärwertzerlegung (SVD), Moore-Penrose-Pseudoinverse, Hadamard-Produkt, Entropie, Kullback-Leibler-Divergenz und Gradientenabstieg.

Unterwegs hast du diese Konzepte in Python mit NumPy und SciPy praktisch angewendet.

Wenn du mehr über Python lernen möchtest, schau dir diese DataCamp-Kurse an: