Neurale Netzwerke in Python & Scratch erstellen: Eine unterhaltsame Einführung!

Entschlüsselung von KI: Erstellen von Neuronalen Netzen in Python und Scratch

Hallo, ich bin Alex Petrov, ein ML-Ingenieur. Heute werden wir neuronale Netze entmystifizieren. Vielleicht denken Sie, sie seien komplex und für fortgeschrittene Programmierer reserviert. Aber ich werde Ihnen zeigen, wie Sie beginnen können, neuronale Netze in Python zu erstellen, und überraschenderweise sogar zentrale Konzepte mit Scratch visualisieren können. Dieser Artikel bietet praktische, umsetzbare Schritte für Anfänger, um ihre ersten KI-Modelle zu verstehen und zu erstellen.

Unsere Reise wird die grundlegende Theorie, eine praktische Python-Implementierung und dann eine kreative Möglichkeit, die Mechanik durch Scratch zu begreifen, abdecken. Ziel ist es, „Neuronale Netze in Python und Scratch zu erstellen“ für jeden zugänglich und verständlich zu machen.

Was ist ein Neuronales Netz? Die Kernidee

Stellen Sie sich Ihr Gehirn vor. Es hat Milliarden von Neuronen, die miteinander verbunden sind und Informationen verarbeiten. Ein neuronales Netz ist ein vereinfachtes Modell dieses biologischen Prozesses. Es handelt sich um eine Serie von Algorithmen, die versucht, zugrunde liegende Beziehungen in einem Datensatz zu identifizieren, indem sie einen Prozess nachahmt, der der Funktionsweise des menschlichen Gehirns ähnelt.

Im Kern nimmt ein neuronales Netz Eingabedaten, leitet sie durch Schichten von miteinander verbundenen „Neuronen“ (oder Knoten) und erzeugt eine Ausgabe. Jede Verbindung hat ein „Gewicht“ und jedes Neuron hat einen „Bias“. Diese Gewichte und Biases werden während des Trainings angepasst, um die Vorhersagen des Netzwerks genauer zu machen.

Eingaben, Verborgene Schichten und Ausgaben

Denken Sie daran folgendermassen:

• Eingabeschicht: Hier gelangen Ihre Daten hinein. Wenn Sie beispielsweise Vorhersagen für Hauspreise treffen, könnten die Eingaben Quadratmeterzahl, Anzahl der Schlafzimmer und Standort sein.
• Verborgene Schichten: Dies sind die „denkenden“ Teile. Sie führen Berechnungen auf den Eingabedaten durch und transformieren diese. Ein Netzwerk kann eine oder mehrere verborgene Schichten haben. Komplexere Probleme erfordern oft mehr verborgene Schichten.
• Ausgabeschicht: Dies ist das Endergebnis. Bei Hauspreisen wäre die Ausgabe der vorhergesagte Preis. Bei der Klassifizierung von Bildern könnte es das Label „Katze“ oder „Hund“ sein.

Gewichte und Biases: Die Lernbaren Parameter des Netzwerks

Jede Verbindung zwischen Neuronen hat ein Gewicht. Dieses Gewicht bestimmt die Stärke und Bedeutung dieser Verbindung. Ein höheres Gewicht bedeutet, dass die Eingabe einen stärkeren Einfluss auf die Aktivierung des nächsten Neurons hat. Ein Bias ist ein zusätzlicher Parameter in jedem Neuron, der hilft, die Aktivierungsfunktion zu verschieben. Zusammen sind Gewichte und Biases das, was das neuronale Netzwerk während des Trainings „lernt“.

Aktivierungsfunktionen: Einführung der Nicht-Linearität

Nachdem ein Neuron Eingaben erhalten hat, sie mit ihren Gewichten multipliziert und einen Bias hinzufügt, leitet es das Ergebnis durch eine Aktivierungsfunktion. Diese Funktion führt Nicht-Linearität in das Netzwerk ein. Ohne Aktivierungsfunktionen wäre ein neuronales Netzwerk einfach ein lineares Modell, das nicht in der Lage ist, komplexe Muster zu lernen. Zu den gängigen Aktivierungsfunktionen gehören ReLU (Rectified Linear Unit), Sigmoid und Tanh.

Ein Einfaches Neuronales Netz in Python Erstellen

Jetzt lassen Sie uns praktisch werden. Wir werden Python verwenden, um ein grundlegendes neuronales Netz zu erstellen. Dazu benutzen wir NumPy für numerische Operationen, was eine grundlegende Bibliothek für wissenschaftliches Rechnen in Python ist. Dies wird unser erster Schritt zur Erstellung neuronaler Netze in Python sein.

Einrichten Ihrer Umgebung

Stellen Sie zunächst sicher, dass Python installiert ist. Installieren Sie dann NumPy:

pip install numpy

Das Problem: XOR-Gatter

Wir werden unser Netzwerk trainieren, um das XOR (exclusive OR) Problem zu lösen. Das XOR-Gatter ist ein klassisches Beispiel in neuronalen Netzen, da es nicht linear trennbar ist. Das bedeutet, dass eine einzelne gerade Linie die wahren Ausgaben nicht von den falschen Ausgaben trennen kann. Es erfordert eine verborgene Schicht.

XOR-Wahrheitstabelle:

• Eingabe (0, 0) -> Ausgabe (0)
• Eingabe (0, 1) -> Ausgabe (1)
• Eingabe (1, 0) -> Ausgabe (1)
• Eingabe (1, 1) -> Ausgabe (0)

Python-Implementierung: Ein Zweischichtiges Neuronales Netz

Hier ist der Python-Code für ein einfaches Feedforward-neuronales Netz mit einer verborgenen Schicht. Wir verwenden die Sigmoid-Aktivierungsfunktion und implementieren den Backpropagation-Algorithmus für das Training.

import numpy as np

# Sigmoid-Aktivierungsfunktion und deren Ableitung
def sigmoid(x):
 return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
 return x * (1 - x)

# Eingabedatensatz
X = np.array([[0,0],
 [0,1],
 [1,0],
 [1,1]])

# Ausgabedatensatz
y = np.array([[0],
 [1],
 [1],
 [0]])

# Seed für Reproduzierbarkeit
np.random.seed(1)

# Initialisieren der Gewichte und Biases
# Gewichte von Eingabe zur verborgenen Schicht (2 Eingaben, 4 verborgene Neuronen)
weights_input_hidden = np.random.uniform(size=(2,4))
# Gewichte von der verborgenen zur Ausgabeschicht (4 verborgene Neuronen, 1 Ausgabe)
weights_hidden_output = np.random.uniform(size=(4,1))

# Biases (optional, aber gute Praxis für komplexere Netzwerke)
# Zur Vereinfachung lassen wir die expliziten Biases in diesem grundlegenden Beispiel weg
# und lassen die Gewichte vorerst die Verschiebung handhaben.
# Für fortgeschrittenere Netzwerke sind Biases entscheidend.

learning_rate = 0.1
epochs = 10000

print("Anfängliche Gewichte (Eingabe zu verborgen):\n", weights_input_hidden)
print("Anfängliche Gewichte (versteckt zu Ausgabe):\n", weights_hidden_output)

for epoch in range(epochs):
 # Vorwärtspropagation
 # Berechnen der Ausgabe der verborgenen Schicht
 hidden_layer_input = np.dot(X, weights_input_hidden)
 hidden_layer_output = sigmoid(hidden_layer_input)

 # Berechnen der Ausgabe der Ausgabeschicht
 output_layer_input = np.dot(hidden_layer_output, weights_hidden_output)
 predicted_output = sigmoid(output_layer_input)

 # Backpropagation
 # Fehler berechnen
 error = y - predicted_output

 # Delta für die Ausgabeschicht berechnen
 d_predicted_output = error * sigmoid_derivative(predicted_output)

 # Fehler für die verborgene Schicht berechnen
 error_hidden_layer = d_predicted_output.dot(weights_hidden_output.T)
 d_hidden_layer = error_hidden_layer * sigmoid_derivative(hidden_layer_output)

 # Gewichte aktualisieren
 weights_hidden_output += hidden_layer_output.T.dot(d_predicted_output) * learning_rate
 weights_input_hidden += X.T.dot(d_hidden_layer) * learning_rate

 if epoch % 1000 == 0:
 loss = np.mean(np.abs(error))
 print(f"Epoch {epoch}, Verlust: {loss:.4f}")

print("\nTraining abgeschlossen.")
print("Endgültige Gewichte (Eingabe zu verborgen):\n", weights_input_hidden)
print("Endgültige Gewichte (versteckt zu Ausgabe):\n", weights_hidden_output)
print("\nVorhergesagte Ausgabe nach dem Training:\n", predicted_output.round())

Verstehen des Python-Codes

Lassen Sie uns den Python-Code für die Erstellung eines neuronalen Netzes in Python aufschlüsseln:

1. `sigmoid` und `sigmoid_derivative` Funktionen: Diese implementieren die Sigmoid-Aktivierungsfunktion und deren Ableitung, die für die Backpropagation entscheidend ist.
2. `X` und `y` Datensätze: Diese repräsentieren unsere Eingaben und Ausgaben für das XOR-Problem.
3. Gewichtinitialisierung: `weights_input_hidden` und `weights_hidden_output` werden mit zufälligen Werten initialisiert. Diese Zufälligkeit ist entscheidend, um zu vermeiden, dass alle Neuronen das Gleiche lernen.
4. `learning_rate`: Diese steuert, wie stark die Gewichte bei jedem Training angepasst werden. Eine kleinere Lernrate bedeutet langsameres, aber potenziell stabileres Lernen.
5. `epochs`: Die Anzahl der Male, die das Netzwerk den gesamten Trainingsdatensatz durchlaufen wird.
6. Vorwärtspropagation:
   • Die Eingaben werden mit `weights_input_hidden` multipliziert, um `hidden_layer_input` zu erhalten.
   • `hidden_layer_input` wird durch die `sigmoid` Funktion geleitet, um `hidden_layer_output` zu erhalten.
   • `hidden_layer_output` wird mit `weights_hidden_output` multipliziert, um `output_layer_input` zu erhalten.
   • `output_layer_input` wird durch `sigmoid` geleitet, um die `predicted_output` zu erhalten.
7. Backpropagation: Dies ist der „Lern“-Teil.
   • Fehlerberechnung: Wir finden den Unterschied zwischen `y` (tatsächliche Ausgabe) und `predicted_output`.
   • Delta der Ausgabeschicht: Dies ist der Fehler multipliziert mit der Ableitung des Sigmoids der vorhergesagten Ausgabe. Es zeigt uns, wie viel wir die Gewichte der Ausgabeschicht anpassen müssen.
   • Fehler der verborgenen Schicht: Wir propagieren den Fehler von der Ausgabeschicht zurück zur verborgenen Schicht.
   • Delta der verborgenen Schicht: Ähnlich wie bei der Ausgabeschicht zeigt uns dies, wie viel wir die Gewichte der verborgenen Schicht anpassen müssen.
   • Gewichtsaktualisierungen: Schließlich werden die Gewichte basierend auf ihren jeweiligen Deltas und der `learning_rate` angepasst. Dies ist der Kern, wie das Netzwerk lernt.

Nach dem Ausführen dieses Codes werden Sie sehen, dass der Verlust des Netzwerks über die Epochen abnimmt und die `predicted_output` eng mit den `y` (Werte der XOR-Wahrheitstabelle) übereinstimmen sollte, was erfolgreiches Lernen demonstriert. Dies ist ein grundlegendes Beispiel für die Erstellung neuronaler Netze in Python.

Visualisierung von Konzepten Neuronaler Netze mit Scratch

Die abstrakte Mathematik zu verstehen, kann schwierig sein. Das ist der Punkt, an dem Scratch ins Spiel kommt! Obwohl Sie kein komplexes neuronales Netz direkt in Scratch erstellen können, können Sie interaktive Simulationen erstellen, die zentrale Konzepte wie Neuronen, Gewichte und Aktivierungen demonstrieren. Dies hilft, das Verständnis von „Neuronalen Netzen in Python und Scratch zu erstellen“ durch eine visuelle Analogie zu festigen.

Warum Scratch für Neuronale Netze?

• Visuelles Feedback: Sehen Sie, wie Eingaben die Ausgaben in Echtzeit beeinflussen.
• Interaktives Lernen: Manipulieren Sie „Gewichte“ und „Biases“ direkt.
• Komplexität vereinfachen: Konzentrieren Sie sich auf ein Konzept nach dem anderen.
• Engagierend: Macht das Lernen unterhaltsam und zugänglich.

Erstellen eines Einfachen „Neurons“ in Scratch

Lass uns ein einzelnes Neuron simulieren, das zwei Eingaben übernimmt, sie mit Gewichten multipliziert, sie summiert und eine einfache Schwelle anwendet (wie eine Schritt-Aktivierungsfunktion). Dies ist eine großartige Möglichkeit, einen Perzeptron zu visualisieren, die einfachste Form eines neuronalen Netzwerks.

Scratch-Projektidee: Ein „Entscheidungsträger“-Neuron

Stell dir ein Neuron vor, das entscheidet, ob du „Nach Draussen gehen“ solltest, basierend auf zwei Eingaben: „Ist es sonnig?“ (1 für Ja, 0 für Nein) und „Ist es warm?“ (1 für Ja, 0 für Nein).

Schritte in Scratch:

1. Variablen erstellen:
   • `Input_Sunny` (Regler, Bereich 0-1)
   • `Input_Warm` (Regler, Bereich 0-1)
   • `Weight_Sunny` (Regler, Bereich -2 bis 2)
   • `Weight_Warm` (Regler, Bereich -2 bis 2)
   • `Bias` (Regler, Bereich -2 bis 2)
   • `Weighted_Sum`
   • `Output_Decision` (wird 0 oder 1 sein)
2. Sprites erstellen:
   • Ein „Neuron“-Sprite (ein Kreis)
   • Ein „Output“-Sprite (z. B. ein glückliches Gesicht für „Nach Draussen gehen“, ein trauriges Gesicht für „Drinnen bleiben“)
3. Neuron-Sprite-Skript:

   
    wenn die grüne Flagge angeklickt wird
    für immer
    setze Weighted_Sum auf (Input_Sunny * Weight_Sunny) + (Input_Warm * Weight_Warm) + Bias
    wenn Weighted_Sum > 0 dann
    setze Output_Decision auf 1 // Nach Draussen gehen
    sonst
    setze Output_Decision auf 0 // Drinnen bleiben
    ende
    ende
    

4. Output-Sprite-Skript:

   
    wenn die grüne Flagge angeklickt wird
    für immer
    wenn Output_Decision = 1 dann
    wechsle das Kostüm zu [Glückliches Gesicht]
    sage "Lass uns nach draussen gehen!" für 2 Sekunden
    sonst
    wechsle das Kostüm zu [Trauriges Gesicht]
    sage "Bleibe heute drinnen." für 2 Sekunden
    ende
    ende
    

Experimentieren in Scratch

Sobald du dies in Scratch erstellt hast, spiele mit den Reglern herum:

• Ändere `Weight_Sunny` und `Weight_Warm`: Wie beeinflusst das Erhöhen eines Gewichts die Wichtigkeit dieser Eingabe für die „Nach Draussen gehen“-Entscheidung?
• Passe `Bias` an: Wie beeinflusst der Bias die Schwelle? Kannst du das Neuron dazu bringen, immer zu entscheiden, nach draussen zu gehen, selbst wenn es nicht sonnig oder warm ist? Oder immer drinnen zu bleiben?
• Beobachte `Weighted_Sum`: Sieh, wie sich der Wert mit verschiedenen Eingaben und Gewichten ändert.

Dieses einfache Scratch-Projekt veranschaulicht lebhaft die grundlegenden Mechanismen: Eingaben, Gewichte, Summierung und eine Aktivierungs- (Schwellen-)Funktion. Es ist ein hervorragendes visuelles Hilfsmittel, um die Verbindung zu „neuronalen Netzwerken in Python in Scratch erstellen“ zu verstehen, insbesondere den „Scratch“-Teil für das konzeptionelle Verständnis.

Erweitere dein Wissen: Nächste Schritte in Python

Während unser einfaches Python-Beispiel ein großartiger Anfang ist, verwenden echte neuronale Netzwerke fortgeschrittenere Bibliotheken und Techniken. Hier sind einige Richtungen, die du erkunden kannst, nachdem du die Grundlagen zur Erstellung neuronaler Netzwerke in Python gemeistert hast:

TensorFlow und Keras

Diese sind leistungsstarke, weit verbreitete Bibliotheken zum Erstellen und Trainieren neuronaler Netzwerke. Keras bietet insbesondere eine hochgradige API, die das Erstellen komplexer Modelle viel einfacher macht als mit reinem NumPy. Du definierst Schichten, Aktivierungsfunktionen und kompilierst dein Modell mit nur wenigen Zeilen Code.

# Beispiel unter Verwendung von Keras (vereinfacht)
from tensorflow import keras
from tensorflow.keras import layers

# Definiere das Modell
modell = keras.Sequential([
 layers.Dense(4, activation='relu', input_shape=(2,)), # Verborgene Schicht mit 4 Neuronen, ReLU
 layers.Dense(1, activation='sigmoid') # Ausgabeschicht mit 1 Neuron, Sigmoid
])

# Kompiliere das Modell
modell.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Trainiere das Modell (unter Verwendung von X und y aus unserem XOR-Beispiel)
modell.fit(X, y, epochs=1000, verbose=0)

# Vorhersagen treffen
vorhersagen = modell.predict(X)
print("Keras-Vorhersagen:\n", vorhersagen.round())

Verschiedene Aktivierungsfunktionen

Experimentiere mit ReLU, Leaky ReLU, Tanh und anderen Aktivierungsfunktionen. Jede hat ihre Stärken und Schwächen, abhängig vom Problem.

Mehr Schichten und Neuronen

Baue tiefere Netzwerke (mehr verborgene Schichten) und breitere Netzwerke (mehr Neuronen pro Schicht), um komplexere Probleme anzugehen. Sei dir der Überanpassung bewusst, bei der das Netzwerk die Trainingsdaten zu gut lernt und bei neuen, ungesehenen Daten schwach abschneidet.

Verlustfunktionen und Optimierer

Untersuche verschiedene Verlustfunktionen (z. B. Mittlerer quadratischer Fehler, Kategorische Kreuzentropie) und Optimierer (z. B. Adam, SGD mit Momentum). Diese beeinflussen entscheidend, wie gut und wie schnell dein Netzwerk lernt.

Echte Datensätze

Bewege dich über XOR hinaus. Arbeite mit Datensätzen von scikit-learn (z. B. Iris, Wein) oder öffentlich verfügbaren Datensätzen wie MNIST für die Bildklassifizierung. Hier zeigt sich die Kraft, neuronale Netzwerke in Python zu erstellen.

Fazit

Du hast einen bedeutenden ersten Schritt in die Welt der KI gemacht, indem du ein neuronales Netzwerk verstanden und implementiert hast. Von den grundlegenden Konzepten der Neuronen, Gewichte und Aktivierungsfunktionen bis hin zu einer praktischen Python-Implementierung für das XOR-Problem und sogar einer visuellen Simulation in Scratch hast du jetzt einen soliden Überblick. Der Weg zur Erstellung neuronaler Netzwerke in Python in Scratch dreht sich nicht nur um Codierung; es geht darum, Intuition aufzubauen und zu verstehen, wie diese intelligenten Systeme lernen.

Denk daran, KI ist ein iterativer Prozess. Experimentiere weiter, lerne weiter und scheue dich nicht, Dinge zu brechen und sie neu aufzubauen. Die Fähigkeiten, die du hier erworben hast, sind übertragbar und bieten eine starke Grundlage für fortgeschrittenere Projekte im Bereich des maschinellen Lernens. Viel Spaß beim Programmieren!

FAQ

F1: Warum ist eine verborgene Schicht für Probleme wie XOR notwendig?

A1: Das XOR-Problem ist „nicht-linear trennbar.“ Das bedeutet, dass du keine einzige gerade Linie ziehen kannst, um die Eingaben, die zu einem Ausgang von 0 führen, von denen zu trennen, die zu einem Ausgang von 1 führen. Ein Perzeptron mit einer Schicht (ohne verborgene Schicht) kann nur linear trennbare Muster lernen. Eine verborgene Schicht ermöglicht es dem neuronalen Netzwerk, komplexere, nichtlineare Beziehungen zu lernen, indem die Eingabedaten in eine neue Repräsentation umgewandelt werden, die dann von der Ausgabeschicht linear getrennt werden kann.

F2: Was ist der Hauptunterschied zwischen der Verwendung von NumPy und Keras zur Erstellung neuronaler Netzwerke?

A2: NumPy bietet die grundlegenden Werkzeuge für numerische Berechnungen in Python, die es dir ermöglichen, neuronale Netzwerke von Grund auf zu implementieren, indem du manuell Matrizenmultiplikationen, Aktivierungsfunktionen und Rückpropagation behandelst. Das gibt dir tiefen Einblick in die zugrunde liegenden Mechanismen. Keras (auf TensorFlow basierend) ist eine hochgradige API, die einen Großteil dieser Komplexität abstrahiert. Es bietet vorgefertigte Schichten, Optimierer und Verlustfunktionen, was das Erstellen, Trainieren und Experimentieren mit komplexen Architekturen neuronaler Netzwerke, insbesondere für größere Datensätze und anspruchsvollere Modelle, erheblich schneller und einfacher macht. Während NumPy großartig für das Lernen der Grundlagen ist, wird Keras für praktische, reale Anwendungen bevorzugt.

F3: Kann ich ein vollwertiges, komplexes neuronales Netzwerk direkt in Scratch erstellen?

A3: Nein, Scratch ist nicht dafür ausgelegt, vollwertige, komplexe neuronale Netzwerke zu erstellen. Es fehlt die rechnerische Effizienz, mathematische Bibliotheken (wie NumPy) und fortgeschrittene Funktionen, die zum Trainieren großer Modelle mit vielen Schichten und Parametern erforderlich sind. Allerdings ist Scratch ein hervorragendes Werkzeug, um die grundlegenden Konzepte neuronaler Netzwerke zu visualisieren und zu verstehen, wie einzelne Neuronen funktionieren, wie Eingaben gewichtet werden und wie Aktivierungsfunktionen Entscheidungen treffen. Es ist ein fantastisches Bildungswerkzeug für Anfänger, um das Verständnis für „neuronale Netzwerke in Python in Scratch erstellen“ zu entwickeln, bevor sie den Code erkunden.

F4: Wie wichtig ist die Lernrate, und was passiert, wenn sie zu hoch oder zu niedrig ist?

A4: Die Lernrate ist entscheidend! Sie bestimmt die Schrittgröße, mit der die Gewichte des neuronalen Netzwerks während des Trainings aktualisiert werden.

• Zu Hoch: Wenn die Lernrate zu hoch ist, könnte das Netzwerk die optimalen Gewichte „überschießen“, was dazu führt, dass der Verlust wild oszilliert oder sogar divergiert (anstatt zu sinken, steigt er). Das Netzwerk könnte niemals zu einer guten Lösung konvergieren.
• Zu Niedrig: Wenn die Lernrate zu niedrig ist, lernt das Netzwerk sehr langsam. Das Training wird sehr lange dauern, und es könnte in einem „lokalen Minimum“ feststecken – eine suboptimale Lösung – bevor es das globale Optimum erreicht.

Einen angemessenen Lernrate zu finden, ist oft ein Prozess des Ausprobierens oder der Verwendung adaptiver Optimierer wie Adam, die die Lernrate während des Trainings automatisch anpassen.

🕒 Published: March 28, 2026