Ein neuronales Netz zur binären Klassifikation von Grund auf schreiben

Matrixmultiplikation, ReLU/Sigmoid-Aktivierung, Kreuzentropie-Verlust und Backpropagation umfassend anwenden—alle Wissenspunkte auf einmal verknüpfen.

Nach Abschluss dieses Falls werden Sie verstehen:Den vollständigen mathematischen Kreislauf des Trainings neuronaler Netze—Matrixtransformation der Daten, Aktivierung, die Nichtlinearität einführt, Kreuzentropie, die Qualität misst, und Backpropagation, die Gradienten weitergibt.


Alltägliche Einführung

Zwei Früchte unterscheiden—Größe allein reicht nicht

Äpfel und Orangen sind gemischt. Nur die Größe zu betrachten reicht nicht aus—manche kleinen Äpfel haben etwa dieselbe Größe wie große Orangen. Sie benötigen zwei Dimensionen (Größe + Farbe) und eine nicht geradlinige Grenze—hier kommen neuronale Netze ins Spiel. Ein einlagiges lineares Modell kann nur gerade Linien zeichnen; das Hinzufügen von verborgenen Schichten und nichtlinearen Aktivierungsfunktionen ermöglicht es, gekrümmte Grenzen zu zeichnen.


Intuitive Vorstellung

Eingabe (2)
Verborgen (8) + ReLU
Ausgabe (1) + Sigmoid
Wahrscheinlichkeit 0~1

Die mathematischen Module, die jeder Komponente entsprechen:

MatrixmultiplikationLineare Algebra
ReLU/SigmoidDifferenzierbare Funktion
KreuzentropieInformationstheorie
KettenregelAnalysis
GradientenabstiegOptimierung

Mathematische Definition

\[ z_1 = X W_1 + b_1,\ a_1 = \text{ReLU}(z_1),\quad z_2 = a_1 W_2 + b_2,\ a_2 = \sigma(z_2) \]

Der Gradient für Sigmoid + Kreuzentropie vereinfacht sich automatisch zur kompaktesten Form: \(\frac{\partial L}{\partial z_2} = a_2 - y\)


Praktische Python-Übung

Beispiel

import numpy as np
np.random.seed(42)

def sigmoid(z):
    return 1 / (1 + np.exp(-np.clip(z, -500, 500)))

def relu(z): return np.maximum(0, z)
def relu_derivative(z): return (z > 0).astype(float)


class TwoLayerNN:
    def __init__(self, n_input, n_hidden, lr=0.1):
        self.W1 = np.random.randn(n_input, n_hidden) * 0.5
        self.b1 = np.zeros(n_hidden)
        self.W2 = np.random.randn(n_hidden, 1) * 0.5
        self.b2 = np.zeros(1)
        self.lr = lr
        self.loss_history = []

    def forward(self, X):
        self.z1 = X @ self.W1 + self.b1
        self.a1 = relu(self.z1)
        self.z2 = self.a1 @ self.W2 + self.b2
        self.a2 = sigmoid(self.z2)
        return self.a2

    def compute_loss(self, y_pred, y_true, eps=1e-9):
        y_pred = np.clip(y_pred, eps, 1 - eps)
        return -np.mean(y_true * np.log(y_pred) +
                        (1 - y_true) * np.log(1 - y_pred))

    def backward(self, X, y_true):
        n = X.shape[0]
        y_true = y_true.reshape(-1, 1)
        dz2 = (self.a2 - y_true) / n          # Sigmoid+CE-Vereinfachung
        dW2 = self.a1.T @ dz2
        db2 = np.sum(dz2, axis=0)
        da1 = dz2 @ self.W2.T                 # Kettenregel-Backpropagation
        dz1 = da1 * relu_derivative(self.z1)
        dW1 = X.T @ dz1
        db1 = np.sum(dz1, axis=0)
        self.W2 -= self.lr * dW2
        self.b2 -= self.lr * db2
        self.W1 -= self.lr * dW1
        self.b1 -= self.lr * db1

    def fit(self, X, y, epochs=1000):
        for epoch in range(epochs):
            y_pred = self.forward(X)
            loss = self.compute_loss(y_pred, y)
            self.loss_history.append(loss)
            self.backward(X, y)
            if epoch % 200 == 0:
                acc = np.mean((y_pred.flatten() > 0.5) == y)
                print(f"BEISPIEL epoch {epoch:4d} loss={loss:.4f} acc={acc:.3f}")

    def predict(self, X):
        return (self.forward(X).flatten() > 0.5).astype(int)


# Konzentrische Kreis-Daten (nichtlinear trennbar)
n = 300
theta = np.random.uniform(0, 2 * np.Pi, n)
r_inner = np.random.normal(1.0, 0.15, n // 2)
r_outer = np.random.normal(2.5, 0.15, n // 2)
X = np.vstack([
    np.c_[r_inner * np.cos(theta[:n//2]), r_inner * np.sin(theta[:n//2])],
    np.c_[r_outer * np.cos(theta[n//2:]), r_outer * np.sin(theta[n//2:])],
])
y = np.array([0] * (n // 2) + [1] * (n // 2))

model = TwoLayerNN(n_input=2, n_hidden=8, lr=0.5)
model.fit(X, y, epochs=1000)
print(f"\nBEISPIEL Endgültige Genauigkeit: {np.mean(model.predict(X) == y):.2%}")
print(f"Verlust: {model.loss_history[0]:.4f} -> {model.loss_history[-1]:.4f}")
EXAMPLE epoch    0  loss=0.6932  acc=0.497
EXAMPLE epoch  200  loss=0.1494  acc=0.930
EXAMPLE epoch  400  loss=0.0615  acc=0.967
EXAMPLE epoch  600  loss=0.0272  acc=0.990
EXAMPLE epoch  800  loss=0.0134  acc=1.000
EXAMPLE epoch 1000  loss=0.0075  acc=1.000

EXAMPLE 最终准确率: 100.00%
损失: 0.6932 -> 0.0075

Anwendungsszenarien in der KI

SzenarioBeziehung zu diesem Fall
BildklassifikationCNN = In diesem Fall wird die Matrixmultiplikation durch eine Faltungsoperation ersetzt.
TextklassifikationBERT-Fine-Tuning = dieser Fall + Transformer-Encoder
AnomalieerkennungGeben Sie die Anomaliewahrscheinlichkeit von 0 bis 1 aus—das ist der Spezialfall der binären Klassifikation dieses Falls.
Weitere Erweiterungen