Neuro-Symbolische KI: Das Beste aus zwei Welten verstehen und anwenden

[Evolution der KI-Ansätze]

[1950er] ────→ [1980er] ────→ [2000er] ────→ [Heute]
     │             │              │              │
Regelbasiert   Neuronale      Deep          Hybrid
  Logik         Netze        Learning      Ansätze
     │             │              │              │
     └───── [Entwicklung der KI-Systeme] ────────┘

[Traditionelle KI vs. Neuro-Symbolische KI]

Situation: "Kind läuft einem Ball nach"

[Neuronales Netz]      [Symbolische KI]       [Neuro-Symbolische KI]
       │                      │                         │
Erkennt: Kind, Ball     Regel: "Wenn Ball          Versteht:
Bewegungsmuster         rollt, könnte Kind          - Situation
                        folgen"                     - Motivation
       │                      │                     - Risiken
       └──────── [Kombiniertes Verständnis] ────────────┘

[Die zwei KI-Welten]

[Neuronale Netze] ────────────────── [Symbolische KI]
        │                                    │
    Mustererkennung                    Regelbasiert
    Lernt aus Daten                    Folgt Logik
    "Künstler"                         "Mathematiker"
        │                                    │
        └───── [Unterschiedliche Stärken] ───┘

[Funktionsweise Neuronales Netz]

Input ────→ [Versteckte Schichten] ────→ Output
  │              │    │    │              │
Bild         Merkmale    Muster        "Katze"
  │              │    │    │              │
  └─── [Automatisches Lernen aus Daten] ──┘

WENN Situation = "Schachmatt droht" DANN
   Suche_Ausweg
   WENN Ausweg_gefunden DANN
      Führe_Zug_aus
   SONST
      Gib_auf
END

[Symbolische KI-Struktur]

[Regeln] ────→ [Logische Verarbeitung] ────→ [Schlussfolgerung]
    │                    │                          │
IF-THEN            Regelanwendung              Ergebnis
Fakten             Deduktion                   Erklärung
    │                    │                          │
    └────── [Nachvollziehbare Entscheidungen] ──────┘

[Neuro-Symbolischer Hybridansatz]

[Neuronales Netz] ────→ [Hybridschicht] ────→ [Symbolische KI]
        │                     │                      │
  Erkennt Muster        Übersetzung           Wendet Regeln an
  "Sieht" Daten         Verbindung            Zieht Schlüsse
        │                     │                      │
        └───── [Intelligente Kombination] ───────────┘
                             │
                    [Bessere Ergebnisse]
                    • Versteht Kontext
                    • Erklärt Entscheidungen
                    • Lernt effizienter

[Eingangstür] ───→ [Bewegungsmelder] ───→ [Kamera]
      │                   │                  │
   geöffnet            Bewegung          Person
      └──────── [Mustererkennungsphase] ─────┘

WENN Tür_geöffnet UND Person_erkannt DANN
   # Neuronales Netz: Personenerkennung
   person_bekannt = prüfe_gesicht()
   
   # Symbolische Regeln
   IF person_bekannt:
      status = "Bewohner"
   ELIF uhrzeit zwischen 23:00 und 06:00:
      status = "Verdächtig"
   ELSE:
      status = "Prüfen"

[Situation] ────→ [Regelwerk] ──────→ [Aktion]
     │               │                  │
  Bewohner      Hausregeln           Tür öffnen
  Verdächtig    Sicherheit           Alarm
  Prüfen        Tageszeit            Nachfragen
     │               │                  │
     └─── [Intelligente Entscheidung] ──┘

[Hybrid-KI im Auto]

[Sensoren] ────→ [Verarbeitung] ────→ [Entscheidung]
     │               │                     │
Kameras         Erkennung:            Regelwerk:
Radar           • Fußgänger           • Verkehrsregeln
Lidar           • Schilder            • Sicherheitsabstand
     │               │                     │
     └──── [Sicheres autonomes Fahren] ────┘

[Hauptanwendungsbereiche]

[Medizin] ────→ [Industrie] ────→ [Alltag] ────→ [Forschung]
    │               │               │               │
Diagnostik      Fertigung       Smart Home      Wissenschaft
Therapie        Qualität        Assistenz       Entdeckung
Analyse         Wartung         Service         Innovation
    │               │               │               │
    └────── [Praktische Anwendungen im Einsatz] ────┘

[Medizinische Diagnose]

[Bildanalyse] ────→ [Symptomcheck] ─────────────→ [Diagnose]
      │                   │                            │
  MRT-Scans          Regelbasierte                 Erklärbare
  Röntgen            Überprüfung                   Diagnose
  Mikroskopie        von Symptomen                 mit Begründung
      │                   │                            │
      └─── [Präzise & nachvollziehbare Ergebnisse] ────┘

# Neuronales Netz analysiert Röntgenbild
anomalie = scan_analyse(röntgenbild)

# Hybride Verarbeitung
IF anomalie_gefunden:
    # Symbolische Regeln prüfen medizinische Richtlinien
    diagnose = prüfe_symptome(anomalie, patientendaten)
    behandlung = erstelle_therapieplan(diagnose)
    
    # Erklärung für Arzt und Patient
    zeige_begründung(diagnose, anomalie, behandlung)

[Smarte Fabrik]

[Sensoren] ────→ [Analyse] ───────────→ [Aktion]
    │               │                      │
Kameras         Erkennung:             • Wartung
Mikrofone       • Fehler               • Anpassung
Messgeräte      • Muster               • Alarm
    │               │                      │
    └── [Intelligente Qualitätskontrolle] ─┘

[Intelligentes Zuhause]

[Sensoren] ────→ [Verarbeitung] ────→ [Steuerung]
    │                │                     │
Bewegung         Erkennung:            Aktionen:
Temperatur       • Situation           • Heizung
Kameras          • Gewohnheiten        • Licht
    │                │                     │
    └─── [Komfort & Energieeffizienz] ─────┘

# Morgenroutine
WENN Zeit = "7:00" UND Wochentag = "Arbeitstag":
    # Neuronales Netz prüft Bewegungsmuster
    IF bewohner_wach():
        # Symbolische Regeln für Komfort
        temperatur = hole_wunschtemperatur()
        starte_kaffeemaschine()
        öffne_rollläden("langsam")
    ELSE:
        # Anpassung an tatsächliches Verhalten
        warte_auf_bewegung()

[Forschungsunterstützung]

[Datenanalyse] ────→ [Hypothesen] ────→ [Validierung]
       │                 │                    │
Mustererkennung     Regelbasierte        Überprüfung
in großen           Theoriebildung       durch beide
Datenmengen        und Vorhersagen      Systeme
       │                 │                    │
       └── [Beschleunigte Wissenschaft] ──────┘

# Neuronales Netz analysiert molekulare Strukturen
molekül_eigenschaften = analyse_struktur(neues_molekül)

# Hybride Verarbeitung für Drug Repurposing
IF ähnlichkeit_gefunden:
    # Symbolische Regeln prüfen medizinische Wirkungen
    mögliche_anwendungen = prüfe_wirkung(molekül_eigenschaften)
    nebenwirkungen = analysiere_risiken(molekül_eigenschaften)
    
    # Dokumentation der Schlussfolgerungen
    erstelle_forschungsbericht(mögliche_anwendungen, nebenwirkungen)

[Dein Weg zur Neuro-Symbolischen KI]

[Setup] ────→ [Erste Schritte] ──────────→ [Projekt] ────→ [Optimierung]
   │               │                          │                │
Tools          Hello World               Haustierpflege    Verbesserung
Python         Grundlagen                System           Best Practices
Bibliotheken   Übungen                   Entwicklung       Troubleshooting
   │               │                          │                │
   └────── [Praktische Erfahrung sammeln] ─────────────────────┘

# Für Windows:
# 1. Gehe zu python.org
# 2. Lade die neueste Version
# 3. Führe den Installer aus

# Für Linux:
sudo apt update
sudo apt install python3
sudo apt install python3-pip  # Paketmanager

# Überprüfe die Installation:
python3 --version

# Installiere alle benötigten Pakete
pip install tensorflow       # Für neuronale Netze
pip install numpy            # Für mathematische Operationen
pip install prolog           # Für symbolische Regeln
pip install opencv-python    # Für Bildverarbeitung

[Lernweg für Einsteiger]

[Basics] ────→ [Muster] ──────────→ [Regeln] ────→ [Kombination]
   │             │                     │                │
Python        Neuronale             Symbolische      Hybrid-
Grundlagen    Netze                 Logik            System
   │             │                    │                │
   └────── [Schrittweises Lernen] ─────────────────────┘

# Erstelle eine neue Datei: hello_ai.py
# Dies ist der einfachste Start in die KI-Welt

# 1. Einfache Mustererkennung
numbers = [1, 2, 3, 4, 5]
pattern = "steigend" if all(numbers[i] < numbers[i+1] 
          for i in range(len(numbers)-1)) else "keine Tendenz"

print(f"Erkanntes Muster: {pattern}")

# 2. Einfache Regel
if pattern == "steigend":
    print("Regel angewendet: Tendenz ist positiv!")

class SimpleHybridSystem:
    def __init__(self):
        # Speicher für Temperaturwerte (neuronaler Teil)
        self.temp_history = []
        
        # Regelwerk (symbolischer Teil)
        self.rules = {
            'kalt': {'aktion': 'heizen', 'grenze': 18},
            'warm': {'aktion': 'kühlen', 'grenze': 25}
        }
    
    def add_temperature(self, temp):
        """Neue Temperatur hinzufügen und analysieren"""
        self.temp_history.append(temp)
        return self.analyze_temperature(temp)
    
    def analyze_temperature(self, current_temp):
        """Kombiniert Mustererkennung mit Regeln"""
        # 1. Mustererkennung
        trend = self.get_trend()
        
        # 2. Regelanwendung
        if current_temp < self.rules['kalt']['grenze']:
            return f"Heizung an (Trend: {trend})"
        elif current_temp > self.rules['warm']['grenze']:
            return f"Kühlung an (Trend: {trend})"
        
        return f"Temperatur optimal (Trend: {trend})"
    
    def get_trend(self):
        """Einfache Mustererkennung"""
        if len(self.temp_history) < 3:
            return "noch unklar"
            
        last_temps = self.temp_history[-3:]
        if all(x < y for x, y in zip(last_temps, last_temps[1:])):
            return "steigend"
        if all(x > y for x, y in zip(last_temps, last_temps[1:])):
            return "fallend"
        return "stabil"

# Beispielnutzung
system = SimpleHybridSystem()
print(system.add_temperature(17))  # "Heizung an (Trend: noch unklar)"
print(system.add_temperature(19))  # "Temperatur optimal (Trend: noch unklar)"
print(system.add_temperature(22))  # "Temperatur optimal (Trend: steigend)"

[Haustierpflege-System Architektur]

[Kamera] ────→ [Erkennung] ────→ [Analyse] ────→ [Aktion]
    │              │               │               │
 Bilder      Neural Network    Regel-Engine    Fütterung
aufnehmen    erkennt Tier     prüft Zeit      Warnungen
    │              │               │               │
    └───── [Intelligente Entscheidungskette] ──────┘

# Erstelle die Projektordner
mkdir pet_care_system
cd pet_care_system

# Erstelle die Unterordner
mkdir data           # Für Trainingsdaten
mkdir models         # Für trainierte Modelle
mkdir rules          # Für Regelwerk
mkdir tests          # Für Testfälle

# Erstelle die Hauptdateien
touch main.py          # Hauptprogramm
touch pet_detector.py  # Neuronales Netz
touch care_rules.py    # Regelwerk

# pet_detector.py
import tensorflow as tf

class PetDetector:
    def __init__(self):
        # Einfaches CNN für Bildererkennung
        self.model = tf.keras.Sequential([
            # Bildeingang (64x64 Pixel, Farbbild)
            tf.keras.layers.Input(shape=(64, 64, 3)),
            
            # Erste Erkennungsschicht
            # Warum Conv2D? -> Erkennt Muster in Bildern
            tf.keras.layers.Conv2D(32, 3, activation='relu'),
            tf.keras.layers.MaxPooling2D(),
            
            # Zweite Erkennungsschicht
            tf.keras.layers.Conv2D(64, 3, activation='relu'),
            tf.keras.layers.MaxPooling2D(),
            
            # Bild in Zahlen umwandeln
            tf.keras.layers.Flatten(),
            
            # Entscheidungsschichten
            tf.keras.layers.Dense(64, activation='relu'),
            # Ausgabe: Hund=0, Katze=1
            tf.keras.layers.Dense(2, activation='softmax')
        ])

# care_rules.py
from datetime import datetime, time

class PetCareRules:
    def __init__(self):
        # Fütterungszeiten für verschiedene Tierarten
        self.feeding_schedule = {
            'dog': [
                time(8, 0),   # 8:00 Uhr
                time(18, 0)   # 18:00 Uhr
            ],
            'cat': [
                time(7, 0),   # 7:00 Uhr
                time(15, 0),  # 15:00 Uhr
                time(22, 0)   # 22:00 Uhr
            ]
        }
        
        # Portionsgrößen und weitere Pflegeregeln
        self.care_rules = {
            'dog': {
                'portion_size': 200,  # Gramm
                'water_check': 4,     # Mal pro Tag
                'walk_times': 3       # Spaziergänge
            },
            'cat': {
                'portion_size': 100,  # Gramm
                'water_check': 2,     # Mal pro Tag
                'litter_check': 2     # Mal täglich
            }
        }
    
    def check_feeding_time(self, pet_type, current_time):
        """Prüft, ob jetzt Fütterungszeit ist"""
        # Wandle current_time in time-Objekt um
        check_time = current_time.time()
        
        # Prüfe, ob aktuelle Zeit nahe an Fütterungszeit
        for feed_time in self.feeding_schedule[pet_type]:
            # 15 Minuten Toleranz
            if self._is_time_close(check_time, feed_time):
                return True
        return False
    
    def _is_time_close(self, time1, time2, tolerance_minutes=15):
        """Hilfsfunktion: Prüft ob zwei Zeiten nah beieinander liegen"""
        # Zeitdifferenz in Minuten
        t1_mins = time1.hour * 60 + time1.minute
        t2_mins = time2.hour * 60 + time2.minute
        return abs(t1_mins - t2_mins) <= tolerance_minutes

# main.py
from datetime import datetime
from pet_detector import PetDetector
from care_rules import PetCareRules
import cv2

class SmartPetCare:
    def __init__(self):
        # Initialisiere beide Komponenten
        self.detector = PetDetector()
        self.rules = PetCareRules()
        
        # Aktivitätsprotokoll
        self.activity_log = []
    
    def process_image(self, image):
        """Hauptfunktion: Verarbeitet ein Bild und trifft Entscheidungen"""
        current_time = datetime.now()
        
        # 1. Neuronales Netz: Tiererkennung
        pet_type = self.detect_pet(image)
        
        # 2. Regelwerk: Pflegeentscheidungen
        care_actions = self.apply_care_rules(pet_type, current_time)
        
        # 3. Protokollierung
        self.log_activity(pet_type, care_actions, current_time)
        
        return care_actions
    
    def detect_pet(self, image):
        """Bildanalyse durch neuronales Netz"""
        # Bild vorverarbeiten
        processed_image = self.preprocess_image(image)
        # Vorhersage machen
        prediction = self.detector.model.predict(processed_image)
        # Ergebnis interpretieren (0=Hund, 1=Katze)
        return 'dog' if prediction[0][0] > 0.5 else 'cat'
    
    def apply_care_rules(self, pet_type, current_time):
        """Regelbasierte Entscheidungsfindung"""
        actions = []
        
        # Fütterungscheck
        if self.rules.check_feeding_time(pet_type, current_time):
            portion = self.rules.care_rules[pet_type]['portion_size']
            actions.append(f"Fütterung: {portion}g")
        
        # Weitere Pflegechecks
        if pet_type == 'dog':
            actions.append("Wassernapf prüfen")
            if current_time.hour in [8, 12, 17]:  # Typische Gassi-Zeiten
                actions.append("Spaziergang fällig")
        elif pet_type == 'cat':
            if len(self.activity_log) % 5 == 0:  # Regelmäßiger Check
                actions.append("Katzenklo prüfen")
        
        return actions

[Warum wir testen]

[Sicherheit] ────→ [Zuverlässigkeit] ────→ [Vertrauen]
      │                   │                    │
  Keine             System arbeitet        Nutzer können
  Fehler bei        wie geplant           sich verlassen
  der Fütterung                           auf System
      │                   │                    │
      └────── [Garantierte Funktionalität] ────┘

# tests/test_components.py
import unittest
from datetime import datetime, time

class TestPetCareSystem(unittest.TestCase):
    def setUp(self):
        """
        Wird vor jedem Test ausgeführt
        Wie das Aufbauen eines Labors vor einem Experiment
        """
        self.rules = PetCareRules()
        self.detector = PetDetector()
    
    def test_feeding_times(self):
        """
        Prüft, ob das System die Fütterungszeiten richtig erkennt
        Dies ist wichtig, damit kein Tier zu spät gefüttert wird
        """
        # Wir erstellen eine Testzeit: 8:00 Uhr morgens
        # (Typische Zeit für die erste Fütterung)
        test_time = datetime.strptime("08:00", "%H:%M")
        
        # Jetzt prüfen wir, ob das System diese Zeit als
        # Fütterungszeit für einen Hund erkennt
        is_feeding_time = self.rules.check_feeding_time('dog', test_time)
        
        # assertTrue prüft, ob etwas wahr ist
        # Wenn nicht, gibt es eine Fehlermeldung
        self.assertTrue(
            is_feeding_time,
            "Fehler: Hundefütterung um 8:00 wurde nicht erkannt!"
        )

def test_complete_workflow():
    """
    Testet den kompletten Arbeitsablauf des Systems
    von der Bilderkennung bis zur Entscheidungsfindung
    """
    # 1. System vorbereiten
    print("System wird gestartet...")
    pet_care = SmartPetCare()
    
    # 2. Testbild laden
    print("Lade Testbild eines Hundes am Morgen...")
    test_image = cv2.imread('tests/test_images/dog_morning.jpg')
    
    # 3. Systemtest durchführen
    print("Führe Analyse durch...")
    current_time = datetime.strptime("08:00", "%H:%M")
    actions = pet_care.process_image(test_image)
    
    # 4. Ergebnisse ausgeben und prüfen
    print("\nErkannte Aktionen:")
    for action in actions:
        print(f"✓ {action}")
        
    # 5. Erklärung der Ergebnisse
    print("\nWarum diese Aktionen?")
    print("- 8:00 Uhr ist Fütterungszeit für Hunde")
    print("- Morgens wird immer der Wassernapf kontrolliert")
    print("- Die Morgenstunde ist ideal für einen Spaziergang")

[Fehlerbehandlung]

[Problem] ────→ [Diagnose] ────→ [Lösung] ────→ [Prävention]
     │             │               │               │
Erkennen       Verstehen        Beheben         Vorbeugen
Was passiert?  Warum?           Wie lösen?      Wie vermeiden?
     │             │               │               │
     └────── [Systematische Problemlösung] ────────┘

# Häufige Fehlersituation
prediction = detector.predict(image)
print(f"Erkennungsrate: {prediction[0] * 100}%")  # Zeigt: 35%

# Bildvorverarbeitung verbessern
def preprocess_image(image):
    """
    Bereitet Bilder für bessere Erkennung vor
    """
    # 1. Größe anpassen
    image = cv2.resize(image, (64, 64))
    
    # 2. Helligkeit korrigieren
    lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
    l, a, b = cv2.split(lab)
    clahe = cv2.createCLAHE(clipLimit=3.0)
    cl = clahe.apply(l)
    
    # 3. Bild schärfen
    sharpened = cv2.filter2D(image, -1, np.array([[-1,-1,-1],
                                                 [-1, 9,-1],
                                                 [-1,-1,-1]]))
    return sharpened

# Problematischer Code
if current_time == feeding_time:  # Zu strikt!
    feed_pet()

def is_feeding_time(current_time, scheduled_time, tolerance_minutes=15):
    """
    Prüft Fütterungszeit mit Toleranz
    
    Warum tolerance_minutes=15?
    - Gibt Flexibilität im Alltag
    - Verhindert verpasste Fütterungen
    - Berücksichtigt reale Bedingungen
    """
    time_diff = abs(current_time - scheduled_time).total_seconds() / 60
    return time_diff <= tolerance_minutes

[Typische Integrationsprobleme]

[Neuronales Netz] ⚠️ [Datenübergabe]    ⚠️ [Regelwerk]
        │                  │                  │
     Formatprobleme   Datentypkonflikte  Regelkonflikte
        │                  │                  │
        └─── [Häufige Stolperstellen] ────────┘

class SystemCheck:
    def __init__(self):
        self.checks = []
    
    def run_diagnostics(self):
        """
        Führt systematische Systemprüfung durch
        Erklärt jeden Schritt für besseres Verständnis
        """
        print("Starte Systemdiagnose...")
        
        # 1. Prüfe Bildverarbeitung
        print("Prüfe Bildverarbeitung...")
        if self.test_image_processing():
            print("✓ Bildverarbeitung OK")
        
        # 2. Prüfe Regelwerk
        print("Prüfe Regelwerk...")
        if self.test_rule_engine():
            print("✓ Regelwerk OK")
        
        # 3. Prüfe Integration
        print("Prüfe Gesamtsystem...")
        if self.test_integration():
            print("✓ Integration OK")

[Optimierungsbereiche]

[Performance] ────→ [Zuverlässigkeit] ────→ [Wartbarkeit]
      │                    │                     │
Schnellere             Bessere               Einfachere
Verarbeitung           Ergebnisse            Wartung
      │                    │                     │
      └────── [Kontinuierliche Verbesserung] ────┘

# config.py - Zentrale Konfiguration
class Config:
    """
    Alle wichtigen Einstellungen an einem Ort
    Warum? -> Einfacher zu ändern und zu verwalten
    """
    # Bildverarbeitung
    IMAGE_SIZE = (64, 64)
    COLOR_CHANNELS = 3
    
    # Zeiteinstellungen
    FEEDING_TOLERANCE = 15  # Minuten
    
    # Systemeinstellungen
    DEBUG_MODE = True
    LOG_LEVEL = 'INFO'

# Verwendung im Hauptprogramm
from config import Config

def process_image(image):
    """
    Verarbeitet Bilder nach konfigurierten Standards
    """
    # Größenanpassung gemäß Konfiguration
    resized = cv2.resize(image, Config.IMAGE_SIZE)
    return resized

# logger.py
import logging

def setup_logging():
    """
    Richtet ein übersichtliches Logging-System ein
    Warum? -> Hilft bei der Fehlersuche und Überwachung
    """
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(levelname)s - %(message)s',
        handlers=[
            logging.FileHandler('system.log'),
            logging.StreamHandler()  # Ausgabe auch in Konsole
        ]
    )

# Beispiel für gutes Logging
def process_pet_image(image):
    """
    Verarbeitet ein Haustierbild mit ausführlichem Logging
    """
    logging.info("Starte Bildverarbeitung")
    
    try:
        result = detector.predict(image)
        logging.info(f"Erkennung erfolgreich: {result}")
    except Exception as e:
        logging.error(f"Fehler bei Erkennung: {str(e)}")
        raise

[Performance-Verbesserung]

[Analyse] ────→ [Optimierung] ────→ [Validierung]
    │              │                     │
Finde         Verbessere            Überprüfe
Bottlenecks   kritische Stellen     Ergebnisse
    │              │                     │
    └────── [Systematische Optimierung] ─┘

# Vor der Optimierung
def process_images(image_list):
    """
    Verarbeitet eine Liste von Bildern
    Warum verbessern? -> Zu langsam bei vielen Bildern
    """
    results = []
    for image in image_list:
        result = process_single_image(image)
        results.append(result)
    return results

# Nach der Optimierung
from concurrent.futures import ThreadPoolExecutor

def process_images_optimized(image_list):
    """
    Verarbeitet Bilder parallel
    Warum? -> Schneller durch gleichzeitige Verarbeitung
    """
    with ThreadPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(process_single_image, image_list))
    return results