Neuronale Netzwerke in Python & Scratch aufbauen: Eine unterhaltsame Einführung!

Ein einfaches neuronales Netzwerk in Python erstellen

Jetzt kommen wir zur Praxis. Wir werden Python verwenden, um ein Basis-neuronales Netzwerk zu erstellen. Dafür verwenden wir NumPy für numerische Operationen, das eine grundlegende Bibliothek für wissenschaftliches Rechnen in Python ist. Dies wird unser erster Schritt zur Erstellung von neuronalen Netzwerken in Python sein.

Richten Sie Ihre Umgebung ein

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

pip install numpy

Das Problem: Das XOR-Gatter

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

Wahrheitstabelle XOR:

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

Implementierung in Python: Ein neuronales Netzwerk mit zwei Schichten

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

import numpy as np

# Sigmoid-Aktivierungsfunktion und ihre 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]])

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

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

# Bias (optional, aber gute Praxis für komplexere Netzwerke)
# Um es zu vereinfachen, lassen wir in diesem einfachen Beispiel die expliziten Bias weg,
# und lassen die Gewichte vorerst die Verschiebung regeln.
# Für fortgeschrittenere Netzwerke sind Bias entscheidend.

learning_rate = 0.1
epochs = 10000

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

for epoch in range(epochs):
 # Rückpropagation
 # Ausgabe der verborgenen Schicht berechnen
 hidden_layer_input = np.dot(X, weights_input_hidden)
 hidden_layer_output = sigmoid(hidden_layer_input)

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

 # Rückpropagation
 # 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"Epochen {epoch}, Verlust : {loss:.4f}")

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

Den Python-Code verstehen

Lassen Sie uns den Python-Code zur Erstellung eines neuronalen Netzwerks in Python aufschlüsseln:

1. Funktionen `sigmoid` und `sigmoid_derivative`: Diese implementieren die Sigmoid-Aktivierungsfunktion und ihre Ableitung, die für die Rückpropagation entscheidend sind.
2. Datensätze `X` und `y`: Diese Datensätze repräsentieren unsere Eingaben und Ausgaben für das XOR-Problem.
3. Initialisierung der Gewichte: `weights_input_hidden` und `weights_hidden_output` werden mit zufälligen Werten initialisiert. Diese Zufälligkeit ist entscheidend, um zu verhindern, dass alle Neuronen dasselbe lernen.
4. `learning_rate`: Dies steuert, wie stark die Gewichte bei jedem Schritt des Trainings angepasst werden. Eine kleinere Lernrate bedeutet ein langsameres, aber potenziell stabileres Lernen.
5. `epochs`: Die Anzahl der Male, die das Netzwerk über den gesamten Trainingsdatensatz gehen wird.
6. Vorwärtspropagation:
   • Die Eingaben werden mit `weights_input_hidden` multipliziert, um `hidden_layer_input` zu erhalten.
   • `hidden_layer_input` wird durch die Funktion `sigmoid` 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 `predicted_output` zu erhalten.
7. Rückpropagation: Dies ist der Teil „Lernen“.
   • Fehlerberechnung: Wir finden die Differenz zwischen `y` (tatsächlicher Ausgabe) und `predicted_output`.
   • Delta der Ausgabeschicht: Dies ist der Fehler multipliziert mit der Ableitung der Sigmoid der vorhergesagten Ausgabe. Dies 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 die 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. Das ist der Kern, wie das Netzwerk lernt.

Nachdem Sie diesen Code ausgeführt haben, werden Sie sehen, dass der Verlust des Netzwerks im Laufe der Epochen abnimmt, und die `predicted_output` sollte sich den Werten von `y` (Wahrheitstabelle XOR) nähern, was ein erfolgreiches Lernen demonstriert. Dies ist ein grundlegendes Beispiel für die Erstellung von neuronalen Netzwerken in Python.

Die Konzepte der neuronalen Netzwerke mit Scratch visualisieren

Die abstrakten Mathematik zu verstehen, kann schwierig sein. Hier kommt Scratch ins Spiel! Auch wenn Sie kein komplexes neuronales Netzwerk direkt in Scratch erstellen können, können Sie interaktive Simulationen erstellen, die grundlegende Konzepte wie Neuronen, Gewichte und Aktivierungen demonstrieren. Dies hilft, das Verständnis von „ein neuronales Netzwerk in Python in Scratch zu erstellen“ zu festigen, indem es eine visuelle Analogie bietet.

Warum Scratch für neuronale Netzwerke?

• Visuelles Feedback: Sehen Sie, wie die Eingaben die Ausgaben in Echtzeit beeinflussen.
• Interaktives Lernen: Manipulieren Sie direkt die „Gewichte“ und „Bias“.
• Vereinfachte Komplexität: Konzentrieren Sie sich auf ein Konzept gleichzeitig.
• Begeisternd: Macht das Lernen unterhaltsam und zugänglich.

Ein einzelnes „Neuronen“ in Scratch erstellen

Lassen Sie uns ein einzelnes Neuron simulieren, das zwei Eingaben entgegennimmt, sie mit Gewichten multipliziert, addiert und einen einfachen Schwellenwert anwendet (wie eine Treppen-Aktivierungsfunktion). Dies ist eine hervorragende Möglichkeit, einen Perzeptron zu visualisieren, die einfachste Form eines neuronalen Netzwerks.

Scratch-Projektidee: ein „Entscheidungsneuron“

Stellen Sie sich ein Neuron vor, das entscheidet, ob Sie „Hinausgehen“ sollten, 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` (Schieberegler, Bereich 0-1)
   • `Input_Warm` (Schieberegler, Bereich 0-1)
   • `Weight_Sunny` (Schieberegler, Bereich -2 bis 2)
   • `Weight_Warm` (Schieberegler, Bereich -2 bis 2)
   • `Bias` (Schieberegler, Bereich -2 bis 2)
   • `Weighted_Sum`
   • `Output_Decision` (wird 0 oder 1 sein)
2. Sprites erstellen:
   • Ein Sprite „Neuron“ (ein Kreis)
   • Ein Sprite „Ausgabe“ (zum Beispiel ein glückliches Gesicht für „Hinausgehen“, ein trauriges Gesicht für „Drinnen bleiben“)
3. Neuron-Sprite-Skript:

   
    wenn die grüne Flagge geklickt wird
    immer
    setze Weighted_Sum auf (Input_Sunny * Weight_Sunny) + (Input_Warm * Weight_Warm) + Bias
    wenn Weighted_Sum > 0 dann
    setze Output_Decision auf 1 // Hinausgehen
    sonst
    setze Output_Decision auf 0 // Drinnen bleiben
    ende
    ende
    

4. Ausgabe-Sprite-Skript:

   
    wenn die grüne Flagge geklickt wird
    immer
    wenn Output_Decision = 1 dann
    wechsle zu Kostüm [Glückliches Gesicht]
    sage "Lass uns nach draußen gehen!" für 2 Sekunden
    sonst
    wechsle zu Kostüm [Trauriges Gesicht]
    sage "Heute drinnen bleiben." für 2 Sekunden
    ende
    ende
    

In Scratch experimentieren

Nachdem Sie dies in Scratch gebaut haben, spielen Sie mit den Schiebereglern:

• Ändern Sie `Weight_Sunny` und `Weight_Warm`: Wie verändert sich die Entscheidung „Hinausgehen“, wenn ein Gewicht ansteigt?
• Bias anpassen: Wie beeinflusst der Bias den Schwellenwert? Können Sie dazu bringen, dass das Neuron immer entscheidet, hinauszugehen, auch wenn es weder sonnig noch warm ist? Oder dass es immer drinnen bleibt?
• Beobachten Sie `Weighted_Sum`: Sehen Sie, wie sich das mit verschiedenen Eingaben und Gewichten ändert.

Dieses einfache Scratch-Projekt veranschaulicht lebhaft die grundlegenden Mechanismen: Eingaben, Gewichte, Summe und Aktivierungsfunktion (Schwellenwert). Es ist ein hervorragendes visuelles Hilfsmittel, um die Verbindung „ein neuronales Netzwerk in Python in Scratch erstellen“ zu verstehen, insbesondere den Teil „Scratch“ für das konzeptionelle Verständnis.

Ihr Wissen erweitern: Nächste Schritte in Python

Obwohl unser einfaches Python-Beispiel ein ausgezeichneter Ausgangspunkt ist, verwenden echte neuronale Netzwerke fortschrittlichere Bibliotheken und Techniken. Hier sind einige Richtungen, die Sie erkunden können, nachdem Sie die Grundlagen der Erstellung von neuronalen Netzwerken in Python gemeistert haben:

TensorFlow und Keras

Diese sind leistungsstarke und widely genutzt Bibliotheken zum Erstellen und Trainieren von neuronalen Netzwerken. Keras, insbesondere, bietet ein High-Level-API, das das Erstellen komplexer Modelle viel einfacher macht als mit reinem NumPy. Sie definieren die Schichten, Aktivierungsfunktionen und kompilieren Ihr Modell in wenigen Zeilen Code.

# Beispiel mit Keras (vereinfacht)
from tensorflow import keras
from tensorflow.keras import layers

# Modell definieren
model = 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
])

# Modell kompilieren
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

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

# Vorhersagen machen
predictions = model.predict(X)
print("Keras Vorhersagen:\n", predictions.round())

Verschiedene Aktivierungsfunktionen

Experimentieren Sie mit ReLU, Leaky ReLU, Tanh und anderen Aktivierungsfunktionen. Jede hat ihre Stärken und Schwächen, je nach Problem.

Mehr Schichten und Neuronen

Bauen Sie tiefere Netzwerke (mehr verborgene Schichten) und breitere Netzwerke (mehr Neuronen pro Schicht), um komplexere Probleme zu bearbeiten. Seien Sie sich des Überanpassens bewusst, bei dem das Netzwerk die Trainingsdaten zu gut lernt und schlecht bei neuen und ungesehenen Daten abschneidet.

Verlustfunktionen und Optimierer

Erforschen Sie verschiedene Verlustfunktionen (z.B. Mittlere Quadratische Fehler, Kategorische Kreuzentropie) und Optimierer (z.B. Adam, SGD mit Momentum). Dies hat einen erheblichen Einfluss auf die Effizienz und Geschwindigkeit des Lernens Ihres Netzwerks.

Reale Daten

Gehen Sie über XOR hinaus. Arbeiten Sie mit Datensätzen von scikit-learn (z.B. Iris, Wine) oder öffentlich verfügbaren Datensätzen wie MNIST zur Bildklassifikation. Hier zeigt sich die Kraft der Erstellung von neuronalen Netzwerken in Python wirklich.

Fazit

Sie haben einen bedeutenden ersten Schritt in die Welt der KI gemacht, indem Sie ein neuronales Netzwerk verstanden und implementiert haben. Von den grundlegenden Konzepten der Neuronen, Gewichte und Aktivierungsfunktionen bis hin zu einer praktischen Umsetzung in Python für das XOR-Problem und sogar einer visuellen Simulation in Scratch haben Sie nun ein gutes Verständnis. Der Weg, ein neuronales Netzwerk in Python in Scratch zu erstellen, geht nicht nur um das Programmieren; es geht darum, Intuition zu entwickeln und zu verstehen, wie diese intelligenten Systeme lernen.

Denken Sie daran, KI ist ein iterativer Prozess. Experimentieren Sie weiter, lernen Sie weiter und scheuen Sie sich nicht davor, Dinge zu zerbrechen und sie wieder aufzubauen. Die Fähigkeiten, die Sie hier erlernt haben, sind übertragbar und werden eine solide Grundlage für komplexere Projekte im maschinellen Lernen bilden. Viel Spaß beim Programmieren!

FAQ

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

A1: Das XOR-Problem ist „nicht-linear trennbar.“ Das bedeutet, dass Sie keine einzige gerade Linie ziehen können, um die Eingaben, die ein Ergebnis von 0 ergeben, von denen zu trennen, die ein Ergebnis von 1 ergeben. Ein Perzeptron mit einer einzigen Schicht (ohne verborgene Schicht) kann nur linear trennbare Muster lernen. Eine verborgene Schicht ermöglicht es dem neuronalen Netzwerk, komplexere und nicht-lineare Beziehungen zu erlernen, indem die Eingabedaten in eine neue Darstellung transformiert werden, die dann von der Ausgabeschicht linear getrennt werden kann.

Q2: Was ist der Hauptunterschied zwischen der Verwendung von NumPy und Keras zur Erstellung von neuronalen Netzwerken?

A2: NumPy bietet die grundlegenden Werkzeuge für numerische Berechnungen in Python, sodass Sie neuronale Netzwerke handwerklich implementieren können, indem Sie manuell Matrixmultiplikationen, Aktivierungsfunktionen und Rückpropagation verwalten. Dies gibt Ihnen ein tiefes Verständnis der zugrunde liegenden Mechanismen. Keras (basiert auf TensorFlow) ist eine High-Level-API, die einen großen Teil dieser Komplexität abstrahiert. Es bietet vordefinierte Schichten, Optimierer und Verlustfunktionen, was das Erstellen, Trainieren und Experimentieren mit komplexen Architekturen von neuronalen Netzwerken, insbesondere für größere Datensätze und anspruchsvollere Modelle, erheblich schneller und einfacher macht. Während NumPy gut ist, um die Grundlagen zu erlernen, wird Keras für praktische Anwendungen in der realen Welt bevorzugt.

Q3: Kann ich ein komplettes und komplexes neuronales Netzwerk direkt in Scratch erstellen?

A3 : Nein, Scratch ist nicht dafür konzipiert, vollständige und komplexe neuronale Netzwerke zu erstellen. Es fehlt an Rechenleistung, mathematischen Bibliotheken (wie NumPy) und den fortgeschrittenen Funktionen, die erforderlich sind, um große Modelle mit vielen Schichten und Parametern zu trainieren. Dennoch ist Scratch ein hervorragendes Werkzeug, um die grundlegenden Konzepte von neuronalen Netzwerken zu visualisieren und zu verstehen, wie beispielsweise die Funktionsweise einzelner Neuronen, wie die Eingaben gewichtet werden und wie Aktivierungsfunktionen Entscheidungen treffen. Es ist ein fantastisches Bildungswerkzeug für Anfänger, um das Verständnis hinter „ein neuronales Netzwerk in Python in Scratch erstellen“ zu erfassen, bevor man den Code erkundet.

Q4 : Was ist die Bedeutung der Lernrate, und was passiert, wenn sie zu hoch oder zu niedrig ist?

A4 : Die Lernrate ist entscheidend! Sie bestimmt die Größe der Schritte, mit denen 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 „übersteuern“, was zu wilden Schwankungen des Verlusts oder sogar zu einer Divergenz (Anstieg statt Abnahme) führen könnte. 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 viel Zeit in Anspruch nehmen, und es könnte in einem „lokalen Minimum“ steckenbleiben – einer suboptimalen Lösung – bevor es das globale Optimum erreicht.

Eine geeignete Lernrate zu finden, ist oft ein Prozess des Ausprobierens oder durch die Verwendung von adaptiven Optimierern wie Adam, die die Lernrate während des Trainings automatisch anpassen.

🕒 Published: March 30, 2026