File size: 13,645 Bytes

d613ffd

# 📊 Neuronales Netzwerk - Visueller Überblick

## Netzwerk-Architektur Visualisierung

```

BEISPIEL 1: Einfaches Netzwerk für Regression

═══════════════════════════════════════════════



Input Layer          Hidden Layer 1       Hidden Layer 2       Output Layer

    (5)                  (8)                   (4)                 (1)



    x₁ ─┐              h₁₁                  o₁₁              ŷ (Vorhersage)

        │ ╱─┬──────→  h₁₂ ─┬──────→       o₁₂ ─┐

    x₂ ─┤  │           h₁₃  │               o₁₃  │

        │ ╱ │           h₁₄  │               o₁₄  ├─→ σ(z) ─→ ŷ

    x₃ ─┤  │ ╱─┬───→   h₁₅  │

        │    │   │       h₁₆  │

    x₄ ─┤   │ ╱─┤       h₁₇  │

        │       │         h₁₈ ─┤

    x₅ ─┴───┘   └─────────────┴─┘



    W₁ Gewichte: 5×8       W₂ Gewichte: 8×4      W₃ Gewichte: 4×1

    b₁ Bias: 8             b₂ Bias: 4            b₃ Bias: 1

```

### Mathematik dahinter:

```

Input:  [x₁, x₂, x₃, x₄, x₅]



Hidden 1:  h₁ = ReLU(x · W₁ + b₁)

Hidden 2:  h₂ = ReLU(h₁ · W₂ + b₂)

Output:    ŷ = Sigmoid(h₂ · W₃ + b₃)



Loss:      L = (ŷ - y)²

```

---

## BEISPIEL 2: Klassifizierung (3 Klassen)
═════════════════════════════════════════

```

Input Features (10)   → Hidden 1 (16) → Hidden 2 (8) → Output (3)



Input:                                              Klasse 1 (Katze)

  [f₁]                                        [o₁]

  [f₂]                                        [o₂]  → argmax → Vorhersage

  ...  ─→ W₁,b₁ → ReLU → W₂,b₂ → ReLU →    [o₃]

  [f₁₀]                                       

                                              (Prob. für jede Klasse)

```

---

## Trainings-Prozess Visualisierung

```

EPOCH 1: Loss = 0.85

  ┌─────────────────┐

  │ Batch 1 (16 Samples)

  │ Forward: Input → HiddenLayers → Output

  │ Loss: MSE(ŷ, y)

  │ Backward: ∂L/∂W berechnen

  │ Update: W := W - α × ∂L/∂W

  └─────────────────┘

  ┌─────────────────┐

  │ Batch 2 (16 Samples) 

  │ (wiederhole)

  └─────────────────┘

  ...



EPOCH 2: Loss = 0.72

  (Gewichte sind besser, Loss sinkt)



EPOCH 3: Loss = 0.65

  (Netzwerk lernt Muster)



EPOCH 20: Loss = 0.12  ← Gut trainiert! ✅

```

---

## Gewichte & Bias Learning

```

Initiale Gewichte (zufällig):

┌─────────────────────┐

│ W = [0.02, -0.15,   │

│      0.08,  0.11,   │  ← Random small values

│     -0.03,  0.04]   │

└─────────────────────┘



Nach Training (gelernt):

┌──────────────────────┐

│ W = [1.23, -2.15,    │

│      0.89,  1.51,    │  ← Großartig angepasst!

│     -0.73,  0.94]    │  Diese Gewichte erkennen

└──────────────────────┘     jetzt Muster!

```

---

## Forward & Backward Propagation Fluss

```

FORWARD PROPAGATION (Vorhersage):

═════════════════════════════════



        x (Input)

          ↓

    Layer 1: z₁ = x·W₁ + b₁

             a₁ = ReLU(z₁)

          ↓

    Layer 2: z₂ = a₁·W₂ + b₂

             a₂ = ReLU(z₂)

          ↓

    Layer 3: z₃ = a₂·W₃ + b₃

             ŷ = Sigmoid(z₃)

          ↓

         Loss: L = (ŷ - y)²



BACKWARD PROPAGATION (Lernen):

════════════════════════════════



         ∂L/∂ŷ  (Fehler an Output)

          ↑

    ∂L/∂z₃ (über sigmoid)

    ∂L/∂W₃ (Grad für W₃)

    ∂L/∂b₃ (Grad für b₃)

          ↑ 

    ∂L/∂a₂  (Error rückwärts)

    ∂L/∂z₂ (über ReLU)

    ∂L/∂W₂ (Grad für W₂)

    ∂L/∂b₂ (Grad für b₂)

          ↑

    ∂L/∂a₁  (Error rückwärts)

    ∂L/∂z₁ (über ReLU)

    ∂L/∂W₁ (Grad für W₁)

    ∂L/∂b₁ (Grad für b₁)



WEIGHT UPDATE:

W := W - learning_rate × ∂L/∂W

```

---

## Integration mit EnhancedMLLearner

```

┌──────────────────────────────────────────────┐

│      EnhancedMLLearner                       │

│                                              │

│  Integriert 5 Learning-Module:              │

│                                              │

│  1. Context Manager  ──────┐                │

│  2. Python Analyzer  ──────┤                │

│  3. Google Learner   ──────┼──→ Learning    │

│  4. Feedback Learner ──────┤    Insights    │

│  5. Neural Networks  ──────┘                │

│     ↓                                        │

│  📊 Learning Metrics:                       │

│     - context_awareness: 0.75               │

│     - python_quality: 0.82                  │

│     - web_learning: 0.68                    │

│     - feedback_quality: 0.91                │

│     - neural_network_accuracy: 0.87 ← NEW! │

│     - overall_improvement: 0.81             │

└──────────────────────────────────────────────┘

```

---

## Datenflusss-Diagramm

```

Benutzer Daten

    ↓

┌─────────────────────┐

│ Daten Vorbereitung  │

│ (Normalisierung)    │

└─────────────────────┘

    ↓

┌─────────────────────┐      ┌──────────────┐

│ Neural Network      │      │ Gewichte W   │

│ Training           │←────→│ Bias b       │

│                    │      │              │

│ Forward Pass        │      └──────────────┘

│ Backward Pass       │

│ Weight Update       │

└─────────────────────┘

    ↓

┌─────────────────────┐

│ Trainiertes Modell  │

│ (Gewichte gelernt)  │

└─────────────────────┘

    ↓

┌─────────────────────┐

│ Vorhersagen         │

│ auf neuen Daten     │

└─────────────────────┘

    ↓

 Ergebnisse

```

---

## Aktivierungsfunktionen Visualisierung

```

ReLU (Rectified Linear Unit):

────────────────────────────

       │     /

       │    /

  f(x) │   /

       │  /

       │_____  (nur ≥ 0)

   ────┼────── x

       │



SIGMOID:

────────

       │      ___

  f(x) │   _/

       │ /

   ____│__  (zwischen 0-1)

       │ \

   ────┼────── x

       │



TANH:

────

       │    

  f(x) │   /  ___

       │ _/

   ────┼──   (zwischen -1 to 1)

       │   \_

   ────┼────── x

```

---

## Loss-Verlauf während Training

```

Loss

│   Epoch 1

│ ▲ (Hoch - Netzwerk weiß noch wenig)

│  \

│   \  Epoch 5

│    \▼ (Sinkt - Lernen findet statt)

│     \

│      \

│       \  Epoch 15 (Konvergenz)

│        ▼_____ (Flach - gut trainiert!)

│              ────────

└─────────────────────────→ Epochs

  0    5    10    15    20

```

---

## Größe vs Komplexität

```

Einfaches Problem:                Komplexes Problem:

────────────────                 ─────────────────



Input → [Neuron] → Output        Input → [32] →[16] → Output

                                         ↓      ↓

Schnell zu trainieren            Langsamer, aber

Weniger Parameter                bessere Ergebnisse

Risiko: Underfitting             Mehr Parameter

                                 Risiko: Overfitting

```

---

## Batch Processing Visualisierung

```

Training Daten: 100 Samples, Batch Size: 32



EPOCH 1:

  Batch 1: Samples   1-32  → Forward/Backward → Update W

  Batch 2: Samples  33-64  → Forward/Backward → Update W

  Batch 3: Samples  65-96  → Forward/Backward → Update W

  Batch 4: Samples  97-100 → Forward/Backward → Update W

  

EPOCH 2:

  (Wiederhole mit Samples in neuer Reihenfolge)

```

---

## Konvergenzbeobachtung

```

GUTES TRAINING:              PROBLEMATISCHES TRAINING:

─────────────────            ──────────────────────



Loss                         Loss

  │                            │

  │ \                          │ /╲/╲  ← Oszillation

  │  \___                      │/────  (LR zu hoch)

  │      \___                  │

  │         \___               │ ─────  ← Stagnation

  │            └─              │ (LR zu niedrig/falsch)

  └──────────────→ Epochs      │

                               └──────────→ Epochs

```

---

## Parameter Beziehung

```

                    ┌─────────────────┐

                    │ Netzwerk Größe  │

                    │ (# of Neurons)  │

                    └────────┬────────┘

                             │

                    Größer = Komplexer

                             │

          ┌──────────────────┼──────────────────┐

          ▼                  ▼                  ▼

    Längeres              Overfitting          Bessere

    Training              Risiko               Accuracy

                          Höher

                             │

                    ┌─────────┴────────┐

                    │ Learning Rate    │

                    │ (Lerngeschw.)    │

                    └────────┬────────┘

                             │

                    Higher = Schneller

                             │

          ┌──────────────────┼──────────────────┐

          ▼                  ▼                  ▼

    Schneller            Oszilation            Kann divergieren

    Training             Risiko

                         Höher

```

---

## Metriken Dashboard

```

╔══════════════════════════════════════════════╗

║         NEURAL NETWORK STATUS                 ║

╠══════════════════════════════════════════════╣

║                                               ║

║  Network Name: response_quality              ║

║  Architecture: [12, 8, 4, 1]                 ║

║  Status: ✅ TRAINED                          ║

║                                               ║

║  Metrics:                                    ║

║  ├─ Training Loss: 0.0234  ✅ (Gut!)        ║

║  ├─ Test Accuracy: 88.5%   ✅ (Gut!)        ║

║  ├─ Epochs Trained: 25                      ║

║  ├─ Learning Rate: 0.05                     ║

║  └─ Model Size: 142 weights                 ║

║                                               ║

║  Last Updated: 2026-03-07 14:32:15           ║

║                                               ║

╚══════════════════════════════════════════════╝

```

---

## Checkliste für Debugging

```

❌ Training konvergiert nicht

   → Prüfe Daten-Normalisierung

   → Reduziere Learning Rate

   → Vergrößere Netzwerk



❌ Overfitting (Test << Training)

   → Verkleinere Netzwerk

   → Stoppe Training früher

   → Mehr Trainingsdaten



❌ Underfitting (Test ≈ Training, beide schlecht)

   → Vergrößere Netzwerk

   → Erhöhe Learning Rate

   → Trainiere länger



❌ Langsames Training

   → Kleinere Batch Size

   → Vereinfachere Netzwerk-Architektur

   → Weniger versteckte Schichten

```

---

**Visualisierungen erstellt:** 7. März 2026  
**Neural Network System:** ✅ Vollständig implementiert