NEURAL_NETWORK_GUIDE.md

🧠 Neuronales Netzwerk - Implementierungsanleitung

Überblick

Ein vollständiges Machine Learning System wurde zu enhanced_ml_learner.py hinzugefügt, das neuronale Netzwerke mit Neuronen in Schichten implementiert, die Gewichte und Verzerrungen aus Daten lernen.

Komponenten

1. NeuralLayer - Einzelne Neuronenschicht

Eine Schicht mit:

• Neuronen: Arrangiert in einer Dimension (output_size)
• Gewichte: W (input_size × output_size) - verbinden Eingaben mit Neuronen
• Verzerrungen: b (1 × output_size) - Offset für jedes Neuron
• Aktivierungsfunktionen: ReLU, Sigmoid, Tanh

Mathematik:

Output = Activation(Input · W + b)

2. SimpleNeuralNetwork - Mehrschichtiges Netzwerk

Ein komplettes Netzwerk mit:

• Multiple stacked layers
• Forward propagation (Eingabe → Schicht 1 → Schicht 2 → ... → Ausgabe)
• Backward propagation (Fehlergradienten rückwärts)
• Training mit SGD (Stochastic Gradient Descent)

Eigenschaften:

• Automatische Gewichtsinitialisierung (Xavier)
• Flexible Netzwerk-Architektur
• Speichern/Laden von Modellen
• Trainingshistorie tracking

3. EnhancedMLLearner Integration

Die Lernersystem wurde erweitert mit:

# Netzwerk erstellen
network = learner.create_neural_network(
    'task_name',
    [input_size, hidden1, hidden2, ..., output_size],
    learning_rate=0.01
)

# Trainieren
history = learner.train_neural_network(
    'task_name',
    X_train,  # Eingabedaten
    y_train,  # Ziel-Labels
    epochs=20,
    batch_size=32
)

# Vorhersagen
predictions = learner.predict_with_network(
    'task_name',
    X_test
)

# Evaluieren
results = learner.evaluate_network(
    'task_name',
    X_test,
    y_test
)

# Status
status = learner.get_network_status()

Beispiele

Beispiel 1: Set-Klassifizierung

import numpy as np
from enhanced_ml_learner import SimpleNeuralNetwork

# Erstelle Netzwerk
network = SimpleNeuralNetwork([10, 8, 4, 1], learning_rate=0.1)

# Trainingsdaten
X_train = np.random.randn(100, 10)
y_train = np.random.rand(100, 1)

# Trainiere
history = network.train(X_train, y_train, epochs=20)

# Vorhersage
predictions = network.predict(X_train[:5])
print(predictions)  # Form: (5, 1)

Beispiel 2: Mustererkennung mit Lerner

from enhanced_ml_learner import get_enhanced_ml_learner

learner = get_enhanced_ml_learner()

# Erstelle Netzwerk für Code-Qualitäts-Vorhersage
learner.create_neural_network('code_quality', [20, 16, 8, 1])

# Trainiere auf Features
X = np.random.randn(200, 20)
y = np.random.rand(200, 1)
learner.train_neural_network('code_quality', X, y, epochs=30)

# Mache Vorhersagen
X_test = np.random.randn(10, 20)
result = learner.predict_with_network('code_quality', X_test)
print(result['predictions'])

Beispiel 3: Feedback-basiertes Lernen

from enhanced_ml_learner import get_enhanced_ml_learner

learner = get_enhanced_ml_learner()

# Lerne aus vorhandenem Benutzer-Feedback
result = learner.learn_patterns_from_feedback('response_quality')
print(result['final_accuracy'])  # Trainings-Genauigkeit

Netzwerk-Architektur Empfehlungen

Kleine Klassifizierung (Binary)

[input_features, 64, 32, 1]  # 3-4 Schichten

Mittlere Klassifizierung (Multi-class)

[input_features, 128, 64, 32, num_classes]  # 4-5 Schichten

Regression

[input_features, 64, 32, 16, 1]  # Mehr versteckte Neuronen

Komplexe Muster

[input_features, 256, 128, 64, 32, 1]  # Tiefere Netzwerke

Hyperparameter-Anleitung

Parameter	Bereich	Empfohlen	Effekt
Learning Rate	0.001 - 0.1	0.01	Höher = schneller, aber weniger stabil
Epochs	10 - 100	20	Höher = besser trainiert, aber länger
Batch Size	8 - 64	32	Kleiner = leiser Training, aber langsamer
Hidden Units	4 - 512	input_size×0.5	Mehr = komplexer, aber overfitting risiko

Training-Tips

1. Daten normalisieren: Features sollten ~[−1, 1] oder [0, 1] sein
2. Epochen monitoren: Beobachte losses für Konvergenz
3. Genauigkeit prüfen: Achte auf Trainings- vs. Test-Genauigkeit
4. Learning rate adjusting: Wenn Loss stagniert, rate reduzieren
5. Modelle speichern: network.save_model('path.json')

Mathematische Details

Forward Propagation

z^l = a^(l-1) · W^l + b^l        (lineare Transformation)
a^l = σ(z^l)                      (Aktivierungsfunktion)

Loss (MSE)

L = (1/m) Σ (ŷ - y)²             (Mean Squared Error)

Backward Propagation

dL/dW = (1/m) · (a^(l-1))^T · dL/dz^l    (Gewichts-Gradient)
dL/db = (1/m) · Σ dL/dz^l                (Bias-Gradient)

Gewichts-Update

W := W - learning_rate · dL/dW
b := b - learning_rate · dL/db

Aktivierungsfunktionen

• ReLU: max(0, x) - Default für versteckte Schichten

  • Pros: Schnell, hilft gegen Vanishing Gradients
  • Cons: Dead ReLU Problem

• Sigmoid: 1/(1+e^(-x)) - Default für Output (Binary)

  • Pros: Output 0-1, interpretierbar
  • Cons: Vanishing Gradients bei extremen Werten

• Tanh: (e^x - e^(-x))/(e^x + e^(-x)) - Alternative

  • Pros: Output -1...1, symmetrisch
  • Cons: Ähnlich zu Sigmoid

Status und Metriken

Abrufen des gesamten Learning Status:

status = learner.get_overall_learning_status()
print(status['neural_networks'])
print(status['learning_metrics'])

Metriken include:

• context_awareness: 0-1 (Kontext-Qualität)
• python_quality: 0-1 (Code-Qualität)
• web_learning: 0-1 (Wissen aus Web)
• feedback_quality: 0-1 (Feedback-Qualität)
• neural_network_accuracy: 0-1 (NN-Genauigkeit)
• overall_improvement: 0-1 (Gesamt-Score)

Fehlerbehandlung

# Prüfe ob Netzwerk existiert
if not learner.neural_networks.get('my_network'):
    learner.create_neural_network('my_network', [10, 8, 1])

# Speichere Modell
try:
    network.save_model('models/my_network.json')
except Exception as e:
    print(f"Fehler beim Speichern: {e}")

Performance-Optimierung

1. Batch Processing: Größere Batches = schneller Training
2. GPU Support: Mit NumPy/TensorFlow für GPU-Training möglich
3. Feature Selection: Weniger Features = schneller Training
4. Model Pruning: Entferne kleine Gewichte nach Training
5. Quantization: Konvertiere zu lower precision (z.B. float32→float16)

Nächste Schritte

1. Test durchführen: python test_neural_network.py
2. Eigene Netzwerk-Architektur testen
3. Mit echten Daten trainieren
4. Modelle in Produktion deployen

---

Status: ✅ Vollständig funktional und integriert Letztes Update: 2026-03-07