# 🧠 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:

```python
# 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

```python
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

```python
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

```python
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)
```python
[input_features, 64, 32, 1]  # 3-4 Schichten
```

### Mittlere Klassifizierung (Multi-class)
```python
[input_features, 128, 64, 32, num_classes]  # 4-5 Schichten
```

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

### Komplexe Muster
```python
[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:

```python
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

```python
# 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