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
Die mathematischen Module, die jeder Komponente entsprechen:
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
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
| Szenario | Beziehung zu diesem Fall |
|---|---|
| Bildklassifikation | CNN = In diesem Fall wird die Matrixmultiplikation durch eine Faltungsoperation ersetzt. |
| Textklassifikation | BERT-Fine-Tuning = dieser Fall + Transformer-Encoder |
| Anomalieerkennung | Geben Sie die Anomaliewahrscheinlichkeit von 0 bis 1 aus—das ist der Spezialfall der binären Klassifikation dieses Falls. |