Upload 5 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+model_with_qa.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,58 @@
----
-license: lgpl-3.0
----
+**Programmübersicht: DRLCogNet – Ein dynamisches, lernfähiges kognitives Netzwerk**
+
+DRLCogNet ist ein fortschrittliches Softwareprogramm, das ein dynamisches, sich selbst optimierendes kognitives Netzwerk simuliert. Es wurde entwickelt, um komplexe Informationen zu verarbeiten, Zusammenhänge zu erkennen und auf der Grundlage des Erlernten Entscheidungen zu treffen, die an menschliches Verhalten angelehnt sind. Das Programm vereint Methoden des Deep Reinforcement Learning, der Neurobiologie und der kognitiven Wissenschaft, um eine hochflexible und adaptive Intelligenz zu schaffen.
+
+**Kernfunktionen und Innovationen:**
+
+1.  **Dynamische Netzwerktopologie:**
+    *   **Anpassbare Struktur:** Das Netzwerk besteht aus miteinander verbundenen Knoten, die Kategorien und Fragen darstellen. Diese Verbindungen passen sich dynamisch an, basierend auf der Häufigkeit und Relevanz der Interaktionen.
+    *   **Causale Beziehungen:** DRLCogNet analysiert kausale Beziehungen zwischen den Knoten, was zu einem besseren Verständnis von Zusammenhängen und Abhängigkeiten führt.
+    *   **Erweiterbar:** Neue Kategorien und Fragen können jederzeit hinzugefügt werden, wodurch das Wissen des Netzwerks kontinuierlich erweitert wird.
+
+2.  **Fortgeschrittene Lernmechanismen:**
+    *   **Hebbsches Lernen:** Die Stärke der Verbindungen zwischen Knoten wird durch eine erweiterte Hebbsche Lernregel modifiziert. Verbindungen, die durch häufige Aktivierung gestärkt werden, werden stärker gewichtet, während inaktive Verbindungen mit der Zeit abgebaut werden (decay).
+    *   **Kontextabhängiges Lernen:** Das Lernen wird durch externe Faktoren und Kontexte beeinflusst, was zu einer adaptiveren Informationsverarbeitung führt.
+    *   **Emotionales Lernen:** Emotionale Zustände und Gewichtungen beeinflussen die Art und Weise, wie Informationen verarbeitet und Entscheidungen getroffen werden, wodurch ein realistischeres Verhaltensmodell entsteht.
+    *   **Sozialer Einfluss:** Das Netzwerk ist in der Lage, sozialen Einfluss zu simulieren, wodurch es sich an gruppenspezifisches Wissen und Präferenzen anpassen kann.
+
+3.  **Multilevel-Memory-System:**
+    *   **Kurz-, Mittel- und Langzeitgedächtnis:** Das System simuliert verschiedene Gedächtnisebenen, wobei Informationen dynamisch zwischen diesen Ebenen verschoben werden. Wichtige Informationen werden im Langzeitgedächtnis gespeichert, während unwichtige Details mit der Zeit verblassen.
+
+4.  **Kreative und kritische Denkprozesse:**
+    *   **Cortex Creativus:** Das System generiert neue Ideen, basierend auf den aktuellen Aktivierungszuständen des Netzwerks.
+    *   **Cortex Criticus:** Ideen werden bewertet und bewertet, wodurch eine Iteration zur Verbesserung und Optimierung der Lösungen ermöglicht wird.
+    *   **Simulatrix Neuralis:** Das System ist in der Lage, Szenarien zu simulieren, um verschiedene Resultate und Optionen zu bewerten.
+
+5.  **Benutzerfreundliche Schnittstelle:**
+    *   **Dashboard:** Ein interaktives Dashboard bietet einen visuellen Einblick in die Aktivierungshistorie, die Gedächtnisverteilung und die Netzwerktopologie.
+    *   **Einfache Bedienung:** Das Programm wurde mit einer einfachen Bedienung entwickelt, die auch für nicht-technische Benutzer geeignet ist.
+    *   **Anpassbare Parameter:** Parameter wie Lernrate, Verfallsrate, Belohnungsintervalle usw. können vom Benutzer angepasst werden.
+
+**Technische Details:**
+
+*   **Python-basiert:** Das Programm ist in Python geschrieben und nutzt verschiedene Bibliotheken, darunter Pandas, NumPy, NetworkX, Seaborn, PyTorch und Tkinter.
+*   **Datenverarbeitung:** Die Daten werden aus CSV-Dateien geladen und mit Methoden der Data-Science vorbereitet.
+*   **Modellspeicherung:** Das trainierte Modell kann gespeichert und geladen werden, was es ermöglicht, den Lernprozess kontinuierlich fortzusetzen.
+*   **Skalierbarkeit:** Mit der Dask-Bibliothek können große Datenmengen effizient verarbeitet werden.
+*   **Logging:** Ein umfassendes Logging-System dokumentiert alle relevanten Prozesse des Lernens und der Netzwerkaktivität.
+
+**Potenzielle Anwendungen:**
+
+*   **Personalisierte Bildung:** DRLCogNet könnte eingesetzt werden, um Lernplattformen zu entwickeln, die sich individuell an die Bedürfnisse und das Lerntempo der Schüler anpassen.
+*   **Kundenbetreuung:** Das System kann als Chatbot oder virtueller Assistent dienen, der Kundenanfragen versteht und auf der Basis seiner Erfahrungen adäquate Antworten gibt.
+*   **Entscheidungsfindung:** Die Analyse kausaler Beziehungen kann Unternehmen helfen, fundierte Entscheidungen zu treffen.
+*   **Medizinische Diagnose:** Durch die Analyse von Patientendaten kann DRLCogNet helfen, Muster zu erkennen, die bei der Diagnose von Krankheiten hilfreich sein können.
+*   **Forschung:** Das System kann als Forschungswerkzeug dienen, um das menschliche Denken und Verhalten zu simulieren und zu studieren.
+
+**Investitionspotenzial:**
+
+*   **Innovative Technologie:** DRLCogNet ist eine innovative Technologie mit erheblichem Marktpotenzial.
+*   **Anpassbarkeit:** Das System kann an unterschiedliche Anforderungen und Branchen angepasst werden.
+*   **Echtzeit-Lernen:** Das dynamische Lernen und die Anpassungsfähigkeit ermöglichen Echtzeit-Reaktionen auf Veränderungen.
+*   **Skalierbarkeit:** Das System kann auf großen Datensätzen trainiert werden.
+*   **Wachstumspotential:** Es gibt ein großes Wachstumspotential im Bereich der KI- und kognitiven Technologien.
+
+**Zusammenfassung:**
+
+DRLCogNet ist ein vielversprechendes Projekt, das durch seine innovative Technologie und die breiten Anwendungsbereiche hervorsticht. Es kombiniert bewährte und neuartige Ansätze, um eine dynamische, adaptive und lernfähige Intelligenz zu schaffen, die in vielen Branchen und Bereichen eingesetzt werden kann. Es bietet ein erhebliches Wachstumspotenzial und kann zu neuen Entwicklungen im Bereich der künstlichen Intelligenz führen.
+

doku.md

@@ -0,0 +1,1286 @@
+# Code-Dokumentation
+
+## Einführung
+
+Dieses Dokument beschreibt den Code zur Verarbeitung und Simulation von Daten aus einer CSV-Datei, die in einem neuronalen Netzwerk verwendet werden. Der Code umfasst Funktionen zur Initialisierung des Netzwerks, zur Verarbeitung der CSV-Datei, zur Simulation des Lernprozesses und zur Speicherung und Laden des Modells.
+
+## Abhängigkeiten
+
+- `pandas`: Zur Verarbeitung von CSV-Dateien.
+- `numpy`: Für numerische Operationen.
+- `random`: Für zufällige Operationen.
+- `tqdm`: Für Fortschrittsanzeigen.
+- `tkinter`: Für die grafische Benutzeroberfläche.
+- `seaborn`: Für die Visualisierung.
+- `networkx`: Für die Erstellung und Analyse von Graphen.
+- `json`: Für die Speicherung und das Laden von Modellen.
+- `os`: Für Dateioperationen.
+- `time`: Für Zeitmessungen.
+- `torch`: Für neuronale Netzwerke.
+- `threading`: Für die Verwaltung von Threads.
+- `logging`: Für die Protokollierung.
+- `sqlite3`: Für die Verwendung von SQLite-Datenbanken.
+- `dask.dataframe`: Für die parallele Verarbeitung von Daten.
+
+## Konfiguration des Loggers
+
+```python
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+```
+
+## Globale Variablen
+
+- `initialized`: Überprüft, ob das Netzwerk initialisiert wurde.
+- `category_nodes`: Liste der Knoten im Netzwerk.
+- `questions`: Liste der Fragen.
+- `model_saved`: Schutzvariable, um zu überprüfen, ob das Modell gespeichert wurde.
+
+## Überprüfen, ob der Ordner existiert
+
+```python
+output_dir = "plots"
+if not os.path.exists(output_dir):
+    os.makedirs(output_dir)
+```
+
+## Funktionen
+
+### Funktion zum Aufteilen der CSV-Datei
+
+```python
+def split_csv(filename, chunk_size=1000, output_dir="data"):
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    chunk_iter = pd.read_csv(filename, chunksize=chunk_size)
+    for i, chunk in enumerate(chunk_iter):
+        chunk.to_csv(os.path.join(output_dir, f"data_part_{i}.csv"), index=False)
+        logging.info(f"Chunk {i} mit {len(chunk)} Zeilen gespeichert.")
+```
+
+### Verbesserung 1: Verstärkung der Verbindungen bei häufig gestellten Fragen
+
+```python
+def strengthen_question_connection(category_nodes, question, category):
+    category_node = next((node for node in category_nodes if node.label == category), None)
+    if category_node:
+        for conn in category_node.connections:
+            if conn.target_node.label == question:
+                old_weight = conn.weight
+                conn.weight += 0.1  # Verstärkung der Verbindung
+                conn.weight = np.clip(conn.weight, 0, 1.0)
+                logging.info(f"Verstärkte Verbindung für Frage '{question}' in Kategorie '{category}': {old_weight:.4f} -> {conn.weight:.4f}")
+```
+
+### Verbesserung 2: Erweiterte Hebb'sche Lernregel zur besseren Zuordnung von Fragen
+
+```python
+def enhanced_hebbian_learning(node, target_node, learning_rate=0.2, decay_factor=0.01):
+    old_weight = None
+    for conn in node.connections:
+        if conn.target_node == target_node:
+            old_weight = conn.weight
+            conn.weight += learning_rate * node.activation * target_node.activation
+            conn.weight = np.clip(conn.weight - decay_factor * conn.weight, 0, 1.0)
+            break
+
+    if old_weight is not None:
+        logging.info(f"Hebb'sches Lernen angewendet: Gewicht {old_weight:.4f} -> {conn.weight:.4f}")
+```
+
+### Verbesserung 3: Simulation der Frageverarbeitung im Netzwerk
+
+```python
+def simulate_question_answering(category_nodes, question, questions):
+    category = next((q['category'] for q in questions if q['question'] == question), None)
+    if not category:
+        logging.warning(f"Frage '{question}' nicht gefunden!")
+        return None
+
+    category_node = next((node for node in category_nodes if node.label == category), None)
+    if category_node:
+        propagate_signal(category_node, input_signal=0.9, emotion_weights={}, emotional_state=1.0)
+        activation = category_node.activation
+        if activation is None or activation <= 0:
+            logging.warning(f"Kategorie '{category}' hat eine ungültige Aktivierung: {activation}")
+            return 0.0  # Rückgabe von 0, falls die Aktivierung fehlschlägt
+        logging.info(f"Verarbeite Frage: '{question}' → Kategorie: '{category}' mit Aktivierung {activation:.4f}")
+        return activation  # Entfernte doppelte Logging-Ausgabe
+    else:
+        logging.warning(f"Kategorie '{category}' nicht im Netzwerk gefunden. Die Kategorie wird neu hinzugefügt!")
+        return 0.0
+```
+
+### Verbesserung 4: Finden der besten passenden Frage zur Benutzeranfrage
+
+```python
+def find_question_by_keyword(questions, keyword):
+    matching_questions = [q for q in questions if keyword.lower() in q['question'].lower()]
+    return matching_questions if matching_questions else None
+```
+
+### Verbesserung 5: Suche nach der ähnlichsten Frage basierend auf einfachen Ähnlichkeitsmetriken
+
+```python
+def find_similar_question(questions, query):
+    from difflib import get_close_matches
+    question_texts = [q['question'] for q in questions]
+    closest_matches = get_close_matches(query, question_texts, n=1, cutoff=0.6)
+
+    if closest_matches:
+        matched_question = next((q for q in questions if q['question'] == closest_matches[0]), None)
+        return matched_question
+    else:
+        return {"question": "Keine passende Frage gefunden", "category": "Unbekannt"}
+```
+
+### Verbesserung 6: Testfunktion zur Überprüfung des Modells
+
+```python
+def test_model(category_nodes, questions, query):
+    matched_question = find_question_by_keyword(questions, query)
+    if matched_question:
+        logging.info(f"Gefundene Frage: {matched_question[0]['question']} -> Kategorie: {matched_question[0]['category']}")
+        simulate_question_answering(category_nodes, matched_question[0]['question'], questions)
+    else:
+        logging.warning("Keine passende Frage gefunden.")
+
+    similarity_question = find_similar_question(questions, query)
+    logging.info(f"Ähnlichste Frage: {similarity_question['question']} -> Kategorie: {similarity_question['category']}")
+```
+
+### NetworkX-Funktionen für kausale Graphen
+
+```python
+def build_causal_graph(category_nodes):
+    G = nx.DiGraph()
+    for node in category_nodes:
+        G.add_node(node.label)
+        for conn in node.connections:
+            G.add_edge(node.label, conn.target_node.label, weight=conn.weight)
+    return G
+
+def analyze_causality_multiple(G, num_pairs=3):
+    if len(G.nodes) < 2:
+        logging.warning("Graph enthält nicht genügend Knoten für eine Analyse.")
+        return
+
+    for _ in range(num_pairs):
+        start_node, target_node = random.sample(G.nodes, 2)
+        logging.info(f"Analysiere kausale Pfade von '{start_node}' nach '{target_node}'")
+
+        try:
+            paths = list(nx.all_simple_paths(G, source=start_node, target=target_node))
+            if paths:
+                for path in paths:
+                    logging.info(f"Kausaler Pfad: {' -> '.join(path)}")
+            else:
+                logging.info(f"Kein Pfad gefunden von '{start_node}' nach '{target_node}'")
+        except nx.NetworkXNoPath:
+            logging.warning(f"Kein direkter Pfad zwischen '{start_node}' und '{target_node}' gefunden.")
+
+def analyze_node_influence(G):
+    influence_scores = nx.pagerank(G, alpha=0.85)
+    sorted_influences = sorted(influence_scores.items(), key=lambda x: x[1], reverse=True)
+    for node, score in sorted_influences:
+        logging.info(f"Knoten: {node}, Einfluss: {score:.4f}")
+```
+
+### Funktion für Interventionen basierend auf Pearl's Do-Operator
+
+```python
+def do_intervention(node, new_value):
+    logging.info(f"Intervention: Setze {node.label} auf {new_value}")
+    node.activation = new_value
+    for conn in node.connections:
+        conn.target_node.activation += node.activation * conn.weight
+```
+
+### Kontextabhängiges Lernen verstärken
+
+```python
+def contextual_causal_analysis(node, context_factors, learning_rate=0.1):
+    context_factor = context_factors.get(node.label, 1.0)
+    if node.activation > 0.8 and context_factor > 1.0:
+        logging.info(f"Kausale Beziehung verstärkt für {node.label} aufgrund des Kontextes.")
+        for conn in node.connections:
+            conn.weight += learning_rate * context_factor
+            conn.weight = np.clip(conn.weight, 0, 1.0)
+            logging.info(f"Gewicht aktualisiert: {node.label} → {conn.target_node.label}, Gewicht: {conn.weight:.4f}")
+```
+
+### PyTorch-Modell für kausale Inferenz
+
+```python
+class CausalInferenceNN(nn.Module):
+    def __init__(self):
+        super(CausalInferenceNN, self).__init__()
+        self.fc1 = nn.Linear(10, 20)
+        self.fc2 = nn.Linear(20, 1)
+
+    def forward(self, x):
+        x = torch.relu(self.fc1(x))
+        return self.fc2(x)
+```
+
+### Debugging-Funktion
+
+```python
+def debug_connections(category_nodes):
+    start_time = time.time()
+    for node in category_nodes:
+        logging.info(f"Knoten: {node.label}")
+        for conn in node.connections:
+            logging.info(f" Verbindung zu: {conn.target_node.label}, Gewicht: {conn.weight}")
+    end_time = time.time()
+    logging.info(f"debug_connections Ausführungszeit: {end_time - start_time:.4f} Sekunden")
+```
+
+### Hilfsfunktionen
+
+```python
+def sigmoid(x):
+    return 1 / (1 + np.exp(-x))
+
+def add_activation_noise(activation, noise_level=0.1):
+    noise = np.random.normal(0, noise_level)
+    return np.clip(activation + noise, 0.0, 1.0)
+
+def decay_weights(category_nodes, decay_rate=0.002, forgetting_curve=0.95):
+    for node in category_nodes:
+        for conn in node.connections:
+            conn.weight *= (1 - decay_rate) * forgetting_curve
+
+def reward_connections(category_nodes, target_category, reward_factor=0.1):
+    for node in category_nodes:
+        if node.label == target_category:
+            for conn in node.connections:
+                conn.weight += reward_factor
+                conn.weight = np.clip(conn.weight, 0, 1.0)
+
+def apply_emotion_weight(activation, category_label, emotion_weights, emotional_state=1.0):
+    emotion_factor = emotion_weights.get(category_label, 1.0) * emotional_state
+    return activation * emotion_factor
+
+def generate_simulated_answers(data, personality_distributions):
+    simulated_answers = []
+    for _, row in data.iterrows():
+        category = row['Kategorie']
+        mean = personality_distributions.get(category, 0.5)
+        simulated_answer = np.clip(np.random.normal(mean, 0.2), 0.0, 1.0)
+        simulated_answers.append(simulated_answer)
+    return simulated_answers
+
+def social_influence(category_nodes, social_network, influence_factor=0.1):
+    for node in category_nodes:
+        for conn in node.connections:
+            social_impact = sum([social_network.get(conn.target_node.label, 0)]) * influence_factor
+            conn.weight += social_impact
+            conn.weight = np.clip(conn.weight, 0, 1.0)
+
+def update_emotional_state(emotional_state, emotional_change_rate=0.02):
+    emotional_state += np.random.normal(0, emotional_change_rate)
+    return np.clip(emotional_state, 0.7, 1.5)
+
+def apply_contextual_factors(activation, node, context_factors):
+    context_factor = context_factors.get(node.label, 1.0)
+    return activation * context_factor * random.uniform(0.9, 1.1)
+
+def long_term_memory(category_nodes, long_term_factor=0.01):
+    for node in category_nodes:
+        for conn in node.connections:
+            conn.weight += long_term_factor * conn.weight
+            conn.weight = np.clip(conn.weight, 0, 1.0)
+
+def hebbian_learning(node, learning_rate=0.3, weight_limit=1.0, reg_factor=0.005):
+    for connection in node.connections:
+        old_weight = connection.weight
+        connection.weight += learning_rate * node.activation * connection.target_node.activation
+        connection.weight = np.clip(connection.weight, -weight_limit, weight_limit)
+        connection.weight -= reg_factor * connection.weight
+        node.activation_history.append(node.activation)  # Aktivierung speichern
+        connection.target_node.activation_history.append(connection.target_node.activation)
+        logging.info(f"Hebb'sches Lernen: Gewicht von {old_weight:.4f} auf {connection.weight:.4f} erhöht")
+```
+
+### Klassen für Netzwerkstruktur
+
+```python
+class Connection:
+    def __init__(self, target_node, weight=None):
+        self.target_node = target_node
+        self.weight = weight if weight is not None else random.uniform(0.1, 1.0)
+
+class Node:
+    def __init__(self, label):
+        self.label = label
+        self.connections = []
+        self.activation = 0.0
+        self.activation_history = []
+
+    def add_connection(self, target_node, weight=None):
+        self.connections.append(Connection(target_node, weight))
+
+    def save_state(self):
+        return {
+            "label": self.label,
+            "activation": self.activation,
+            "activation_history": self.activation_history,
+            "connections": [{"target": conn.target_node.label, "weight": conn.weight} for conn in self.connections]
+        }
+
+    @staticmethod
+    def load_state(state, nodes_dict):
+        node = Node(state["label"])
+        node.activation = state["activation"]
+        node.activation_history = state["activation_history"]
+        for conn_state in state["connections"]:
+            target_node = nodes_dict[conn_state["target"]]
+            connection = Connection(target_node, conn_state["weight"])
+            node.connections.append(connection)
+        return node
+
+class MemoryNode(Node):
+    def __init__(self, label, memory_type="short_term"):
+        super().__init__(label)
+        self.memory_type = memory_type
+        self.retention_time = {"short_term": 5, "mid_term": 20, "long_term": 100}[memory_type]
+        self.time_in_memory = 0
+
+    def decay(self, decay_rate, context_factors, emotional_state):
+        context_factor = context_factors.get(self.label, 1.0)
+        emotional_factor = emotional_state
+        for conn in self.connections:
+            if self.memory_type == "short_term":
+                conn.weight *= (1 - decay_rate * 2 * context_factor * emotional_factor)
+            elif self.memory_type == "mid_term":
+                conn.weight *= (1 - decay_rate * context_factor * emotional_factor)
+            elif self.memory_type == "long_term":
+                conn.weight *= (1 - decay_rate * 0.5 * context_factor * emotional_factor)
+
+    def promote(self, activation_threshold=0.7):
+        if len(self.activation_history) == 0:
+            return
+        if self.memory_type == "short_term" and np.mean(self.activation_history[-5:]) > activation_threshold:
+            self.memory_type = "mid_term"
+            self.retention_time = 20
+        elif self.memory_type == "mid_term" and np.mean(self.activation_history[-20:]) > activation_threshold:
+            self.memory_type = "long_term"
+            self.retention_time = 100
+
+class CortexCreativus(Node):
+    def __init__(self, label):
+        super().__init__(label)
+
+    def generate_new_ideas(self, category_nodes):
+        new_ideas = []
+        for node in category_nodes:
+            if node.activation > 0.5:
+                new_idea = f"New idea based on {node.label} with activation {node.activation}"
+                new_ideas.append(new_idea)
+        return new_ideas
+
+class SimulatrixNeuralis(Node):
+    def __init__(self, label):
+        super().__init__(label)
+
+    def simulate_scenarios(self, category_nodes):
+        scenarios = []
+        for node in category_nodes:
+            if node.activation > 0.5:
+                scenario = f"Simulated scenario based on {node.label} with activation {node.activation}"
+                scenarios.append(scenario)
+        return scenarios
+
+class CortexCriticus(Node):
+    def __init__(self, label):
+        super().__init__(label)
+
+    def evaluate_ideas(self, ideas):
+        evaluated_ideas = []
+        for idea in ideas:
+            evaluation_score = random.uniform(0, 1)
+            evaluation = f"Evaluated idea: {idea} - Score: {evaluation_score}"
+            evaluated_ideas.append(evaluation)
+        return evaluated_ideas
+
+class LimbusAffectus(Node):
+    def __init__(self, label):
+        super().__init__(label)
+
+    def apply_emotion_weight(self, ideas, emotional_state):
+        weighted_ideas = []
+        for idea in ideas:
+            weighted_idea = f"Emotionally weighted idea: {idea} - Weight: {emotional_state}"
+            weighted_ideas.append(weighted_idea)
+        return weighted_ideas
+
+class MetaCognitio(Node):
+    def __init__(self, label):
+        super().__init__(label)
+
+    def optimize_system(self, category_nodes):
+        for node in category_nodes:
+            node.activation *= random.uniform(0.9, 1.1)
+
+class CortexSocialis(Node):
+    def __init__(self, label):
+        super().__init__(label)
+
+    def simulate_social_interactions(self, category_nodes):
+        interactions = []
+        for node in category_nodes:
+            if node.activation > 0.5:
+                interaction = f"Simulated social interaction based on {node.label} with activation {node.activation}"
+                interactions.append(interaction)
+        return interactions
+
+def connect_new_brains_to_network(category_nodes, new_brains):
+    for brain in new_brains:
+        for node in category_nodes:
+            brain.add_connection(node)
+            node.add_connection(brain)
+```
+
+### Netzwerk-Initialisierung
+
+```python
+def initialize_quiz_network(categories):
+    try:
+        category_nodes = [Node(c) for c in categories]
+        for node in category_nodes:
+            for target_node in category_nodes:
+                if node != target_node:
+                    node.add_connection(target_node)
+                    logging.debug(f"Verbindung hinzugefügt: {node.label} → {target_node.label}")
+        debug_connections(category_nodes)
+        for node in category_nodes:
+            logging.info(f"Knoten erstellt: {node.label}")
+            for conn in node.connections:
+                logging.info(f"  → Verbindung zu {conn.target_node.label} mit Gewicht {conn.weight:.4f}")
+        return category_nodes
+    except Exception as e:
+        logging.error(f"Fehler bei der Netzwerk-Initialisierung: {e}")
+        return []
+```
+
+### Signalpropagation
+
+```python
+def propagate_signal(node, input_signal, emotion_weights, emotional_state=1.0, context_factors=None):
+    node.activation = add_activation_noise(sigmoid(input_signal * random.uniform(0.8, 1.2)))
+    node.activation_history.append(node.activation)  # Aktivierung speichern
+    node.activation = apply_emotion_weight(node.activation, node.label, emotion_weights, emotional_state)
+    if context_factors:
+        node.activation = apply_contextual_factors(node.activation, node, context_factors)
+    logging.info(f"Signalpropagation für {node.label}: Eingangssignal {input_signal:.4f}")
+    for connection in node.connections:
+        logging.info(f"  → Signal an {connection.target_node.label} mit Gewicht {connection.weight:.4f}")
+        connection.target_node.activation += node.activation * connection.weight
+
+def propagate_signal_with_memory(node, input_signal, category_nodes, memory_nodes, context_factors, emotional_state):
+    node.activation = add_activation_noise(sigmoid(input_signal))
+    node.activation_history.append(node.activation)
+    for connection in node.connections:
+        connection.target_node.activation += node.activation * connection.weight
+    for memory_node in memory_nodes:
+        memory_node.time_in_memory += 1
+        memory_node.promote()
+```
+
+### Simulation mit Anpassungen
+
+```python
+def simulate_learning(data, category_nodes, personality_distributions, epochs=1, learning_rate=0.8, reward_interval=5, decay_rate=0.002, emotional_state=1.0, context_factors=None):
+    if context_factors is None:
+        context_factors = {}
+
+    weights_history = {f"{node.label} → {conn.target_node.label}": [] for node in category_nodes for conn in node.connections}
+    activation_history = {node.label: [] for node in category_nodes}
+    question_nodes = []
+
+    for idx, row in data.iterrows():
+        q_node = Node(row['Frage'])
+        question_nodes.append(q_node)
+        category_label = row['Kategorie'].strip()
+        category_node = next((c for c in category_nodes if c.label == category_label), None)
+        if category_node:
+            q_node.add_connection(category_node)
+            logging.debug(f"Verbindung hinzugefügt: {q_node.label} → {category_node.label}")
+        else:
+            logging.warning(f"Warnung: Kategorie '{category_label}' nicht gefunden für Frage '{row['Frage']}'.")
+
+    emotion_weights = {category: 1.0 for category in data['Kategorie'].unique()}
+    social_network = {category: random.uniform(0.1, 1.0) for category in data['Kategorie'].unique()}
+
+    for epoch in range(epochs):
+        logging.info(f"\n--- Epoche {epoch + 1} ---")
+        simulated_answers = generate_simulated_answers(data, personality_distributions)
+
+        for node in category_nodes:
+            node.activation_sum = 0.0
+            node.activation_count = 0
+
+        for node in category_nodes:
+            propagate_signal(node, random.uniform(0.1, 0.9), emotion_weights, emotional_state, context_factors)
+            node.activation_history.append(node.activation)  # Aktivierung speichern
+
+        for idx, q_node in enumerate(question_nodes):
+            for node in category_nodes + question_nodes:
+                node.activation = 0.0
+            answer = simulated_answers[idx]
+            propagate_signal(q_node, answer, emotion_weights, emotional_state, context_factors)
+            q_node.activation_history.append(q_node.activation)  # Aktivierung speichern
+            hebbian_learning(q_node, learning_rate)
+
+            for node in category_nodes:
+                node.activation_sum += node.activation
+                if node.activation > 0:
+                    node.activation_count += 1
+
+            for node in category_nodes:
+                for conn in node.connections:
+                    weights_history[f"{node.label} → {conn.target_node.label}"].append(conn.weight)
+                    logging.debug(f"Gewicht aktualisiert: {node.label} → {conn.target_node.label}, Gewicht: {conn.weight}")
+
+            # Kausalitätsverstärkung anwenden
+            contextual_causal_analysis(q_node, context_factors, learning_rate)
+
+        for node in category_nodes:
+            if node.activation_count > 0:
+                mean_activation = node.activation_sum / node.activation_count
+                activation_history[node.label].append(mean_activation)
+                logging.info(f"Durchschnittliche Aktivierung für Knoten {node.label}: {mean_activation:.4f}")
+            else:
+                activation_history[node.label].append(0.0)
+                logging.info(f"Knoten {node.label} wurde in dieser Epoche nicht aktiviert.")
+
+        if (epoch + 1) % reward_interval == 0:
+            target_category = random.choice(data['Kategorie'].unique())
+            reward_connections(category_nodes, target_category=target_category)
+
+        decay_weights(category_nodes, decay_rate=decay_rate)
+        social_influence(category_nodes, social_network)
+
+    logging.info("Simulation abgeschlossen. Ergebnisse werden analysiert...")
+    return activation_history, weights_history
+```
+
+### Simulation mit mehrstufigem Gedächtnis
+
+```python
+def simulate_multilevel_memory(data, category_nodes, personality_distributions, epochs=1):
+    short_term_memory = [MemoryNode(c, "short_term") for c in category_nodes]
+    mid_term_memory = []
+    long_term_memory = []
+    memory_nodes = short_term_memory + mid_term_memory + long_term_memory
+    context_factors = {question: random.uniform(0.9, 1.1) for question in data['Frage'].unique()}
+    emotional_state = 1.0
+    for epoch in range(epochs):
+        logging.info(f"\n--- Epoche {epoch + 1} ---")
+        for node in short_term_memory:
+            input_signal = random.uniform(0.1, 1.0)
+            propagate_signal_with_memory(node, input_signal, category_nodes, memory_nodes, context_factors, emotional_state)
+        for memory_node in memory_nodes:
+            memory_node.decay(decay_rate=0.01, context_factors=context_factors, emotional_state=emotional_state)
+        for memory_node in memory_nodes:
+            memory_node.promote()
+        short_term_memory, mid_term_memory, long_term_memory = update_memory_stages(memory_nodes)
+        logging.info(f"Epoche {epoch + 1}: Kurzzeit {len(short_term_memory)}, Mittelzeit {len(mid_term_memory)}, Langzeit {len(long_term_memory)}")
+    return short_term_memory, mid_term_memory, long_term_memory
+
+def update_memory_stages(memory_nodes):
+    short_term_memory = [node for node in memory_nodes if node.memory_type == "short_term"]
+    mid_term_memory = [node for node in memory_nodes if node.memory_type == "mid_term"]
+    long_term_memory = [node for node in memory_nodes if node.memory_type == "long_term"]
+    return short_term_memory, mid_term_memory, long_term_memory
+```
+
+### Plot-Funktionen
+
+```python
+def plot_activation_history(activation_history, filename="activation_history.png"):
+    if not activation_history:
+        logging.warning("No activation history to plot")
+        return
+    plt.figure(figsize=(12, 8))
+    for label, activations in activation_history.items():
+        if len(activations) > 0:
+            plt.plot(range(1, len(activations) + 1), activations, label=label)
+    plt.title("Entwicklung der Aktivierungen während des Lernens")
+    plt.xlabel("Epoche")
+    plt.ylabel("Aktivierung")
+    plt.legend()
+    plt.grid(True)
+    plt.savefig(os.path.join(output_dir, filename), dpi=300, bbox_inches="tight")
+    plt.close()
+    logging.info(f"Plot gespeichert unter: {os.path.join(output_dir, filename)}")
+
+def plot_dynamics(activation_history, weights_history, filename="dynamics.png"):
+    if not weights_history:
+        logging.error("weights_history ist leer.")
+        return
+
+    plt.figure(figsize=(16, 12))
+    plt.subplot(2, 2, 1)
+    for label, activations in activation_history.items():
+        if len(activations) > 0:
+            plt.plot(range(1, len(activations) + 1), activations, label=label)
+    plt.title("Entwicklung der Aktivierungen während des Lernens")
+    plt.xlabel("Epoche")
+    plt.ylabel("Aktivierung")
+    plt.legend()
+    plt.grid(True)
+
+    plt.subplot(2, 2, 2)
+    for label, weights in weights_history.items():
+        if len(weights) > 0:
+            plt.plot(range(1, len(weights) + 1), weights, label=label, alpha=0.7)
+    plt.title("Entwicklung der Verbindungsgewichte während des Lernens")
+    plt.xlabel("Epoche")
+    plt.ylabel("Gewicht")
+    plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
+    plt.grid(True)
+
+    plt.savefig(os.path.join(output_dir, filename), dpi=300, bbox_inches="tight")
+    plt.close()
+    logging.info(f"Plot gespeichert unter: {os.path.join(output_dir, filename)}")
+
+def plot_memory_distribution(short_term_memory, mid_term_memory, long_term_memory, filename="memory_distribution.png"):
+    counts = [len(short_term_memory), len(mid_term_memory), len(long_term_memory)]
+    labels = ["Kurzfristig", "Mittelfristig", "Langfristig"]
+    plt.figure(figsize=(8, 6))
+    plt.bar(labels, counts, color=["red", "blue", "green"])
+    plt.title("Verteilung der Gedächtnisknoten")
+    plt.ylabel("Anzahl der Knoten")
+    plt.savefig(os.path.join(output_dir, filename), dpi=300, bbox_inches="tight")
+    plt.close()
+    logging.info(f"Plot gespeichert unter: {os.path.join(output_dir, filename)}")
+
+def plot_activation_heatmap(activation_history, filename="activation_heatmap.png"):
+    if not activation_history:
+        logging.warning("No activation history to plot")
+        return
+
+    min_length = min(len(activations) for activations in activation_history.values())
+    truncated_activations = {key: values[:min_length] for key, values in activation_history.items()}
+
+    plt.figure(figsize=(12, 8))
+    heatmap_data = np.array([activations for activations in truncated_activations.values()])
+
+    if heatmap_data.size == 0:
+        logging.error("Heatmap-Daten sind leer. Überprüfen Sie die Aktivierungshistorie.")
+        return
+
+    sns.heatmap(heatmap_data, cmap="YlGnBu", xticklabels=truncated_activations.keys(), yticklabels=False)
+    plt.title("Heatmap der Aktivierungswerte")
+    plt.xlabel("Kategorie")
+    plt.ylabel("Epoche")
+    plt.savefig(os.path.join(output_dir, filename), dpi=300, bbox_inches="tight")
+    plt.close()
+    logging.info(f"Plot gespeichert unter: {os.path.join(output_dir, filename)}")
+
+def plot_network_topology(category_nodes, new_brains, filename="network_topology.png"):
+    G = nx.DiGraph()
+    for node in category_nodes:
+        G.add_node(node.label)
+        for conn in node.connections:
+            G.add_edge(node.label, conn.target_node.label, weight=conn.weight)
+    for brain in new_brains:
+        G.add_node(brain.label, color='red')
+        for conn in brain.connections:
+            G.add_edge(brain.label, conn.target_node.label, weight=conn.weight)
+
+    pos = nx.spring_layout(G)
+    edge_labels = {(u, v): d['weight'] for u, v, d in G.edges(data=True)}
+    node_colors = [G.nodes[node].get('color', 'skyblue') for node in G.nodes()]
+
+    nx.draw(G, pos, with_labels=True, node_size=3000, node_color=node_colors, font_size=10, font_weight="bold", edge_color="gray")
+    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
+    plt.title("Netzwerktopologie")
+    plt.savefig(os.path.join(output_dir, filename), dpi=300, bbox_inches="tight")
+    plt.close()
+    logging.info(f"Plot gespeichert unter: {os.path.join(output_dir, filename)}")
+```
+
+### Modell speichern und laden
+
+```python
+def save_model(category_nodes, filename="model.json"):
+    model_data = {
+        "nodes": [node.save_state() for node in category_nodes]
+    }
+    with open(filename, "w") as file:
+        json.dump(model_data, file, indent=4)
+    logging.info(f"Modell gespeichert in {filename}")
+
+def save_model_with_questions_and_answers(category_nodes, questions, filename="model_with_qa.json"):
+    global model_saved
+    logging.info("Starte Speichern des Modells...")
+
+    # Überprüfen, ob Änderungen vorgenommen wurden
+    current_model_data = {
+        "nodes": [node.save_state() for node in category_nodes],
+        "questions": questions
+    }
+
+    if os.path.exists(filename):
+        try:
+            with open(filename, "r", encoding="utf-8") as file:
+                existing_model_data = json.load(file)
+                if existing_model_data == current_model_data:
+                    logging.info("Keine Änderungen erkannt, erneutes Speichern übersprungen.")
+                    return
+        except Exception as e:
+            logging.warning(f"Fehler beim Überprüfen des vorhandenen Modells: {e}")
+
+    # Speichern des aktualisierten Modells
+    try:
+        with open(filename, "w", encoding="utf-8") as file:
+            json.dump(current_model_data, file, indent=4)
+        logging.info(f"Modell erfolgreich gespeichert unter {filename}.")
+        model_saved = True  # Setze auf True nach erfolgreichem Speichern
+    except Exception as e:
+        logging.error(f"Fehler beim Speichern des Modells: {e}")
+
+def load_model_with_questions_and_answers(filename="model_with_qa.json"):
+    global initialized
+    if initialized:
+        logging.info("Modell bereits initialisiert.")
+        return None, None
+
+    if not os.path.exists(filename):
+        logging.warning(f"Datei {filename} nicht gefunden. Netzwerk wird initialisiert.")
+        return None, None
+
+    try:
+        with open(filename, "r", encoding="utf-8") as file:
+            model_data = json.load(file)
+
+        nodes_dict = {node_data["label"]: Node(node_data["label"]) for node_data in model_data["nodes"]}
+
+        for node_data in model_data["nodes"]:
+            node = nodes_dict[node_data["label"]]
+            node.activation = node_data.get("activation", 0.0)
+            for conn_state in node_data["connections"]:
+                target_node = nodes_dict.get(conn_state["target"])
+                if target_node:
+                    node.add_connection(target_node, conn_state["weight"])
+
+        questions = model_data.get("questions", [])
+        logging.info(f"Modell geladen mit {len(nodes_dict)} Knoten und {len(questions)} Fragen")
+        initialized = True
+        return list(nodes_dict.values()), questions
+
+    except json.JSONDecodeError as e:
+        logging.error(f"Fehler beim Parsen der JSON-Datei: {e}")
+        return None, None
+```
+
+### Fragen aktualisieren
+
+```python
+def update_questions_with_answers(filename="model_with_qa.json"):
+    with open(filename, "r") as file:
+        model_data = json.load(file)
+
+    for question in model_data["questions"]:
+        if "answer" not in question:
+            question["answer"] = input(f"Gib die Antwort für: '{question['question']}': ")
+
+    with open(filename, "w") as file:
+        json.dump(model_data, file, indent=4)
+    logging.info(f"Fragen wurden mit Antworten aktualisiert und gespeichert in {filename}")
+```
+
+### Beste Antwort finden
+
+```python
+def find_best_answer(category_nodes, questions, query):
+    matched_question = find_similar_question(questions, query)
+    if matched_question:
+        logging.info(f"Gefundene Frage: {matched_question['question']} -> Kategorie: {matched_question['category']}")
+        answer = matched_question.get("answer", "Keine Antwort verfügbar")
+        logging.info(f"Antwort: {answer}")
+        return answer
+    else:
+        logging.warning("Keine passende Frage gefunden.")
+        return None
+```
+
+### Dashboard erstellen
+
+```python
+def create_dashboard(category_nodes, activation_history, short_term_memory, mid_term_memory, long_term_memory):
+    root = tk.Tk()
+    root.title("Psyco Dashboard")
+
+    # Anzeige der Aktivierungshistorie
+    activation_frame = ttk.Frame(root, padding="10")
+    activation_frame.pack(fill=tk.BOTH, expand=True)
+    activation_label = ttk.Label(activation_frame, text="Aktivierungshistorie")
+    activation_label.pack()
+    if activation_history:
+        for label, activations in activation_history.items():
+            fig, ax = plt.subplots()
+            ax.plot(range(1, len(activations) + 1), activations)
+            ax.set_title(label)
+            canvas = FigureCanvasTkAgg(fig, master=activation_frame)
+            canvas.draw()
+            canvas.get_tk_widget().pack()
+    else:
+        no_data_label = ttk.Label(activation_frame, text="Keine Aktivierungshistorie verfügbar.")
+        no_data_label.pack()
+
+    # Anzeige der Gedächtnisverteilung
+    memory_frame = ttk.Frame(root, padding="10")
+    memory_frame.pack(fill=tk.BOTH, expand=True)
+    memory_label = ttk.Label(memory_frame, text="Gedächtnisverteilung")
+    memory_label.pack()
+    memory_counts = [len(short_term_memory), len(mid_term_memory), len(long_term_memory)]
+    labels = ["Kurzfristig", "Mittelfristig", "Langfristig"]
+    fig, ax = plt.subplots()
+    ax.bar(labels, memory_counts, color=["red", "blue", "green"])
+    ax.set_title("Verteilung der Gedächtnisknoten")
+    ax.set_ylabel("Anzahl der Knoten")
+    canvas = FigureCanvasTkAgg(fig, master=memory_frame)
+    canvas.draw()
+    canvas.get_tk_widget().pack()
+
+    # Anzeige der Netzwerktopologie
+    topology_frame = ttk.Frame(root, padding="10")
+    topology_frame.pack(fill=tk.BOTH, expand=True)
+    topology_label = ttk.Label(topology_frame, text="Netzwerktopologie")
+    topology_label.pack()
+    G = nx.DiGraph()
+    for node in category_nodes:
+        G.add_node(node.label)
+        for conn in node.connections:
+            G.add_edge(node.label, conn.target_node.label, weight=conn.weight)
+    pos = nx.spring_layout(G)
+    edge_labels = {(u, v): d['weight'] for u, v, d in G.edges(data=True)}
+    node_colors = ['skyblue' for _ in G.nodes()]
+    fig, ax = plt.subplots()
+    nx.draw(G, pos, with_labels=True, node_size=3000, node_color=node_colors, font_size=10, font_weight="bold", edge_color="gray", ax=ax)
+    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, ax=ax)
+    ax.set_title("Netzwerktopologie")
+    canvas = FigureCanvasTkAgg(fig, master=topology_frame)
+    canvas.draw()
+    canvas.get_tk_widget().pack()
+
+    # Anzeige der Heatmap der Aktivierungswerte
+    heatmap_frame = ttk.Frame(root, padding="10")
+    heatmap_frame.pack(fill=tk.BOTH, expand=True)
+    heatmap_label = ttk.Label(heatmap_frame, text="Heatmap der Aktivierungswerte")
+    heatmap_label.pack()
+    if activation_history:
+        min_length = min(len(activations) for activations in activation_history.values())
+        truncated_activations = {key: values[:min_length] for key, values in activation_history.items()}
+        heatmap_data = np.array([activations for activations in truncated_activations.values()])
+        if heatmap_data.size > 0:
+            fig, ax = plt.subplots()
+            sns.heatmap(heatmap_data, cmap="YlGnBu", xticklabels=truncated_activations.keys(), yticklabels=False, ax=ax)
+            ax.set_title("Heatmap der Aktivierungswerte")
+            ax.set_xlabel("Kategorie")
+            ax.set_ylabel("Epoche")
+            canvas = FigureCanvasTkAgg(fig, master=heatmap_frame)
+            canvas.draw()
+            canvas.get_tk_widget().pack()
+        else:
+            no_data_label = ttk.Label(heatmap_frame, text="Heatmap-Daten sind leer. Überprüfen Sie die Aktivierungshistorie.")
+            no_data_label.pack()
+    else:
+        no_data_label = ttk.Label(heatmap_frame, text="Keine Aktivierungshistorie verfügbar.")
+        no_data_label.pack()
+
+    root.mainloop()
+```
+
+### CSV-Datei verarbeiten
+
+```python
+def process_csv_in_chunks(filename, chunk_size=10000):
+    global category_nodes, questions
+    logging.info(f"Beginne Verarbeitung der Datei: {filename}")
+
+    try:
+        # Test, ob die Datei existiert
+        if not os.path.exists(filename):
+            logging.error(f"Datei {filename} nicht gefunden.")
+            return None
+
+        all_chunks = []
+        for chunk in pd.read_csv(filename, chunksize=chunk_size, encoding="utf-8", on_bad_lines='skip'):
+            logging.info(f"Chunk mit {len(chunk)} Zeilen gelesen.")
+            if 'Frage' not in chunk.columns or 'Kategorie' not in chunk.columns or 'Antwort' not in chunk.columns:
+                logging.error("CSV-Datei enthält nicht die erwarteten Spalten: 'Frage', 'Kategorie', 'Antwort'")
+                return None
+
+            all_chunks.append(chunk)
+
+        data = pd.concat(all_chunks, ignore_index=True)
+        logging.info(f"Alle Chunks erfolgreich verarbeitet. Gesamtzeilen: {len(data)}")
+
+        return data
+
+    except pd.errors.EmptyDataError:
+        logging.error("CSV-Datei ist leer.")
+    except pd.errors.ParserError as e:
+        logging.error(f"Parsing-Fehler in CSV-Datei: {e}")
+    except Exception as e:
+        logging.error(f"Unerwarteter Fehler beim Verarbeiten der Datei: {e}")
+
+    return None
+```
+
+### Einzelne Einträge verarbeiten
+
+```python
+def process_single_entry(question, category, answer):
+    global category_nodes, questions
+
+    # Sicherstellen, dass die globalen Variablen initialisiert sind
+    if category_nodes is None:
+        category_nodes = []
+        logging.warning("Kategorie-Knotenliste war None, wurde nun initialisiert.")
+
+    if questions is None:
+        questions = []
+        logging.warning("Fragenliste war None, wurde nun initialisiert.")
+
+    # Überprüfen, ob die Kategorie bereits vorhanden ist
+    if not any(node.label == category for node in category_nodes):
+        category_nodes.append(Node(category))
+        logging.info(f"Neue Kategorie '{category}' dem Netzwerk hinzugefügt.")
+
+    # Frage, Kategorie und Antwort zur Liste hinzufügen
+    questions.append({"question": question, "category": category, "answer": answer})
+    logging.info(f"Neue Frage hinzugefügt: '{question}' -> Kategorie: '{category}'")
+```
+
+### CSV-Datei mit Dask verarbeiten
+
+```python
+def process_csv_with_dask(filename, chunk_size=10000):
+    try:
+        ddf = dd.read_csv(filename, blocksize=chunk_size)
+        ddf = ddf.astype({'Kategorie': 'category'})
+
+        for row in ddf.itertuples(index=False, name=None):
+            process_single_entry(row[0], row[1], row[2])
+
+        logging.info("Alle Chunks erfolgreich mit Dask verarbeitet.")
+    except Exception as e:
+        logging.error(f"Fehler beim Verarbeiten der Datei mit Dask: {e}")
+```
+
+### In SQLite speichern
+
+```python
+def save_to_sqlite(filename, db_name="dataset.db"):
+    conn = sqlite3.connect(db_name)
+    chunk_iter = pd.read_csv(filename, chunksize=10000)
+    for chunk in chunk_iter:
+        chunk.to_sql("qa_data", conn, if_exists="append", index=False)
+        logging.info(f"Chunk mit {len(chunk)} Zeilen gespeichert.")
+    conn.close()
+    logging.info("CSV-Daten wurden erfolgreich in SQLite gespeichert.")
+```
+
+### Aus SQLite laden
+
+```python
+def load_from_sqlite(db_name="dataset.db"):
+    conn = sqlite3.connect(db_name)
+    query = "SELECT Frage, Kategorie, Antwort FROM qa_data"
+    data = pd.read_sql_query(query, conn)
+    conn.close()
+    return data
+```
+
+### Teilmodell speichern
+
+```python
+def save_partial_model(filename="partial_model.json"):
+    model_data = {
+        "nodes": [node.save_state() for node in category_nodes],
+        "questions": questions
+    }
+    with open(filename, "w") as file:
+        json.dump(model_data, file, indent=4)
+    logging.info("Teilmodell gespeichert.")
+```
+
+### CSV-Datei faul laden
+
+```python
+def lazy_load_csv(filename, chunk_size=10000):
+    for chunk in pd.read_csv(filename, chunksize=chunk_size):
+        for _, row in chunk.iterrows():
+            yield row['Frage'], row['Kategorie'], row['Antwort']
+```
+
+### Hauptfunktion
+
+```python
+def main():
+    start_time = time.time()
+    category_nodes, questions = load_model_with_questions_and_answers("model_with_qa.json")
+
+    if category_nodes is None:
+        csv_file = "data.csv"
+        data = process_csv_in_chunks(csv_file)
+        if data is None:
+            logging.error("Fehler beim Laden der CSV-Datei.")
+            return
+
+        if len(data) > 1000:
+            logging.info("Datei hat mehr als 1000 Zeilen. Aufteilen in kleinere Dateien...")
+            split_csv(csv_file)
+
+            # Verarbeite jede aufgeteilte Datei
+            data_dir = "data"
+            for filename in os.listdir(data_dir):
+                if filename.endswith(".csv"):
+                    file_path = os.path.join(data_dir, filename)
+                    logging.info(f"Verarbeite Datei: {file_path}")
+
+                    data = process_csv_in_chunks(file_path)
+                    if data is None:
+                        logging.error("Fehler beim Laden der CSV-Datei.")
+                        return
+
+                    categories = data['Kategorie'].unique()
+                    category_nodes = initialize_quiz_network(categories)
+                    questions = [{"question": row['Frage'], "category": row['Kategorie'], "answer": row['Antwort']} for _, row in data.iterrows()]
+
+                    personality_distributions = {category: random.uniform(0.5, 0.8) for category in [node.label for node in category_nodes]}
+                    activation_history, weights_history = simulate_learning(data, category_nodes, personality_distributions)
+
+                    save_model_with_questions_and_answers(category_nodes, questions)
+        else:
+            logging.info("Datei hat weniger als 1000 Zeilen. Keine Aufteilung erforderlich.")
+            categories = data['Kategorie'].unique()
+            category_nodes = initialize_quiz_network(categories)
+            questions = [{"question": row['Frage'], "category": row['Kategorie'], "answer": row['Antwort']} for _, row in data.iterrows()]
+
+            personality_distributions = {category: random.uniform(0.5, 0.8) for category in [node.label for node in category_nodes]}
+            activation_history, weights_history = simulate_learning(data, category_nodes, personality_distributions)
+
+            save_model_with_questions_and_answers(category_nodes, questions)
+
+    end_time = time.time()
+    logging.info(f"Simulation abgeschlossen. Gesamtdauer: {end_time - start_time:.2f} Sekunden")
+```
+
+### Simulation aus der GUI starten
+
+```python
+def run_simulation_from_gui(learning_rate, decay_rate, reward_interval, epochs):
+    global model_saved
+    model_saved = False  # Erzwinge das Speichern nach dem Training
+
+    start_time = time.time()
+    csv_file = "data.csv"
+
+    category_nodes, questions = load_model_with_questions_and_answers("model_with_qa.json")
+
+    if category_nodes is None:
+        data = process_csv_in_chunks(csv_file)
+        if not isinstance(data, pd.DataFrame):
+            logging.error("Fehler beim Laden der CSV-Datei. Erwarteter DataFrame wurde nicht zurückgegeben.")
+            return
+
+        if len(data) > 1000:
+            logging.info("Datei hat mehr als 1000 Zeilen. Aufteilen in kleinere Dateien...")
+            split_csv(csv_file)
+
+            # Verarbeite jede aufgeteilte Datei
+            data_dir = "data"
+            for filename in os.listdir(data_dir):
+                if filename.endswith(".csv"):
+                    file_path = os.path.join(data_dir, filename)
+                    logging.info(f"Verarbeite Datei: {file_path}")
+
+                    data = process_csv_in_chunks(file_path)
+                    if not isinstance(data, pd.DataFrame):
+                        logging.error("Fehler beim Laden der CSV-Datei. Erwarteter DataFrame wurde nicht zurückgegeben.")
+                        return
+
+                    categories = data['Kategorie'].unique()
+                    category_nodes = initialize_quiz_network(categories)
+                    questions = [{"question": row['Frage'], "category": row['Kategorie'], "answer": row['Antwort']} for _, row in data.iterrows()]
+
+                    personality_distributions = {category: random.uniform(0.5, 0.8) for category in [node.label for node in category_nodes]}
+                    activation_history, weights_history = simulate_learning(
+                        data, category_nodes, personality_distributions,
+                        epochs=int(epochs),
+                        learning_rate=float(learning_rate),
+                        reward_interval=int(reward_interval),
+                        decay_rate=float(decay_rate)
+                    )
+
+                    save_model_with_questions_and_answers(category_nodes, questions)
+        else:
+            logging.info("Datei hat weniger als 1000 Zeilen. Keine Aufteilung erforderlich.")
+            categories = data['Kategorie'].unique()
+            category_nodes = initialize_quiz_network(categories)
+            questions = [{"question": row['Frage'], "category": row['Kategorie'], "answer": row['Antwort']} for _, row in data.iterrows()]
+
+            personality_distributions = {category: random.uniform(0.5, 0.8) for category in [node.label for node in category_nodes]}
+            activation_history, weights_history = simulate_learning(
+                data, category_nodes, personality_distributions,
+                epochs=int(epochs),
+                learning_rate=float(learning_rate),
+                reward_interval=int(reward_interval),
+                decay_rate=float(decay_rate)
+            )
+
+            save_model_with_questions_and_answers(category_nodes, questions)
+    else:
+        data = process_csv_in_chunks(csv_file)
+        if not isinstance(data, pd.DataFrame):
+            logging.error("Fehler beim Laden der CSV-Datei. Erwarteter DataFrame wurde nicht zurückgegeben.")
+            return
+
+        logging.info(f"Anzahl der Zeilen in der geladenen CSV: {len(data)}")
+
+        personality_distributions = {category: random.uniform(0.5, 0.8) for category in [node.label for node in category_nodes]}
+
+        activation_history, weights_history = simulate_learning(
+            data, category_nodes, personality_distributions,
+            epochs=int(epochs),
+            learning_rate=float(learning_rate),
+            reward_interval=int(reward_interval),
+            decay_rate=float(decay_rate)
+        )
+
+        save_model_with_questions_and_answers(category_nodes, questions)
+
+    end_time = time.time()
+    logging.info(f"Simulation abgeschlossen. Gesamtdauer: {end_time - start_time:.2f} Sekunden")
+    messagebox.showinfo("Ergebnis", f"Simulation abgeschlossen! Dauer: {end_time - start_time:.2f} Sekunden")
+```
+
+### Netzwerk asynchron initialisieren
+
+```python
+def async_initialize_network():
+    global category_nodes, questions, model_saved
+    logging.info("Starte Initialisierung des Netzwerks...")
+
+    category_nodes, questions = load_model_with_questions_and_answers("model_with_qa.json")
+
+    if category_nodes is None:
+        category_nodes = []
+        logging.warning("Keine gespeicherten Kategorien gefunden. Neues Netzwerk wird erstellt.")
+        model_saved = False  # Zurücksetzen der Speicher-Flagge
+
+    if questions is None:
+        questions = []
+        logging.warning("Keine gespeicherten Fragen gefunden. Neues Fragen-Array wird erstellt.")
+        model_saved = False  # Zurücksetzen der Speicher-Flagge
+
+    if not category_nodes:
+        csv_file = "data.csv"
+        data = process_csv_in_chunks(csv_file)
+        if isinstance(data, pd.DataFrame):
+            if len(data) > 1000:
+                logging.info("Datei hat mehr als 1000 Zeilen. Aufteilen in kleinere Dateien...")
+                split_csv(csv_file)
+
+                # Verarbeite jede aufgeteilte Datei
+                data_dir = "data"
+                for filename in os.listdir(data_dir):
+                    if filename.endswith(".csv"):
+                        file_path = os.path.join(data_dir, filename)
+                        logging.info(f"Verarbeite Datei: {file_path}")
+
+                        data = process_csv_in_chunks(file_path)
+                        if isinstance(data, pd.DataFrame):
+                            categories = data['Kategorie'].unique()
+                            category_nodes = initialize_quiz_network(categories)
+                            questions = [{"question": row['Frage'], "category": row['Kategorie'], "answer": row['Antwort']} for _, row in data.iterrows()]
+                            logging.info("Netzwerk aus CSV-Daten erfolgreich erstellt.")
+                            model_saved = False  # Zurücksetzen der Speicher-Flagge
+            else:
+                logging.info("Datei hat weniger als 1000 Zeilen. Keine Aufteilung erforderlich.")
+                categories = data['Kategorie'].unique()
+                category_nodes = initialize_quiz_network(categories)
+                questions = [{"question": row['Frage'], "category": row['Kategorie'], "answer": row['Antwort']} for _, row in data.iterrows()]
+                logging.info("Netzwerk aus CSV-Daten erfolgreich erstellt.")
+                model_saved = False  # Zurücksetzen der Speicher-Flagge
+        else:
+            logging.error("Fehler beim Laden der CSV-Daten. Netzwerk konnte nicht initialisiert werden.")
+            return
+
+    save_model_with_questions_and_answers(category_nodes, questions)
+    logging.info("Netzwerk erfolgreich initialisiert.")
+```
+
+### GUI starten
+
+```python
+def start_gui():
+    def start_simulation():
+        try:
+            threading.Thread(target=run_simulation_from_gui, args=(0.8, 0.002, 5, 10), daemon=True).start()
+            messagebox.showinfo("Info", "Simulation gestartet!")
+            logging.info("Simulation gestartet")
+        except Exception as e:
+            logging.error(f"Fehler beim Start der Simulation: {e}")
+            messagebox.showerror("Fehler", f"Fehler: {e}")
+
+    root = tk.Tk()
+    root.title("DRLCogNet GUI")
+    root.geometry("400x300")
+
+    header_label = tk.Label(root, text="Simulationseinstellungen", font=("Helvetica", 16))
+    header_label.pack(pady=10)
+
+    start_button = tk.Button(root, text="Simulation starten", command=start_simulation)
+    start_button.pack(pady=20)
+
+    root.mainloop()
+```
+
+### Hauptprogramm
+
+```python
+if __name__ == "__main__":
+    # Starte die Initialisierung in einem Thread
+    threading.Thread(target=async_initialize_network, daemon=True).start()
+    start_gui()
+```
+
+## Fragen zur Datenbank (SQLite)
+
+### Wird die Datenbank im Arbeitsspeicher erstellt?
+
+Ja, die SQLite-Datenbank wird im Arbeitsspeicher erstellt, wenn die Funktion `save_to_sqlite` aufgerufen wird. Diese Funktion erstellt eine SQLite-Datenbankdatei (standardmäßig `dataset.db`), die im Arbeitsspeicher gespeichert wird, wenn Sie sie nicht an einem anderen Ort speichern.
+
+### Wie wird die Datenbank erstellt?
+
+Die Datenbank wird erstellt, indem eine Verbindung zur SQLite-Datenbank hergestellt wird. Wenn die Datei `dataset.db` nicht existiert, wird sie erstellt. Anschließend werden die Daten aus der CSV-Datei in Chunks gelesen und in die Tabelle `qa_data` der SQLite-Datenbank gespeichert.
+
+### Wie werden die Daten in die Datenbank geladen?
+
+Die Daten werden in Chunks aus der CSV-Datei gelesen und in die Tabelle `qa_data` der SQLite-Datenbank gespeichert. Die Funktion `to_sql` von Pandas wird verwendet, um die Daten in die Datenbank zu schreiben.
+
+### Wie werden die Daten aus der Datenbank geladen?
+
+Die Daten werden aus der Datenbank geladen, indem eine Verbindung zur SQLite-Datenbank hergestellt und eine SQL-Abfrage ausgeführt wird, um die Daten aus der Tabelle `qa_data` zu lesen. Die Funktion `read_sql_query` von Pandas wird verwendet, um die Daten in einen Pandas-DataFrame zu laden.
+
+### Beispielcode zur Verwendung der Datenbank
+
+```python
+# Daten in die Datenbank speichern
+save_to_sqlite("data.csv")
+
+# Daten aus der Datenbank laden
+data = load_from_sqlite()
+```
+
+## Fazit
+
+Diese Dokumentation bietet eine umfassende Übersicht über den Code und die Verwendung der SQLite-Datenbank zur Speicherung und zum Laden von Daten. Der Code ist modular aufgebaut und ermöglicht die Verarbeitung und Simulation von Daten aus einer CSV-Datei in einem neuronalen Netzwerk. Die SQLite-Datenbank wird im Arbeitsspeicher erstellt und ermöglicht die effiziente Speicherung und das Laden von Daten.

gradio_app.py

@@ -0,0 +1,161 @@
+import logging
+import gradio as gr
+import time
+import json
+
+from main import (
+    load_model_with_questions_and_answers,
+    simulate_question_answering,
+    find_similar_question
+)
+
+# Deaktiviere alle Logging-Ausgaben außer kritischen Fehlern
+logging.getLogger().setLevel(logging.CRITICAL)
+
+# Modell laden
+category_nodes, questions = load_model_with_questions_and_answers("model_with_qa.json")
+
+def test_model_with_answers(category_nodes, questions, query):
+    """
+    Testet das Modell mit einer Abfrage und gibt die gefundene Frage, Antwort und Gewichtung zurück.
+
+    Args:
+        category_nodes (list): Liste der Kategorie-Knoten.
+        questions (list): Liste der Fragen.
+        query (str): Die Abfrage, nach der gesucht werden soll.
+
+    Returns:
+        tuple: Die gefundene Frage, Antwort und Gewichtung.
+    """
+    # Suche nach der ähnlichsten Frage im Modell
+    matched_question = find_similar_question(questions, query)
+
+    if matched_question and matched_question.get('question') != "Keine passende Frage gefunden":
+        answer = matched_question.get('answer', 'Keine Antwort verfügbar')
+
+        # Simulation der Fragebeantwortung (Gewichtung/Aktivierung)
+        activation = simulate_question_answering(category_nodes, matched_question['question'], questions)
+
+        # Rückgabe der relevanten Informationen
+        return f"Frage: \"{query}\"", f"Antwort: \"{answer}\"", f"Gewichtung: {activation:.2f}"
+    else:
+        # Falls keine passende Frage gefunden wurde
+        return f"Frage: \"{query}\"", "Antwort: \"Keine passende Frage gefunden\"", "Gewichtung: 0.00"
+
+def measure_response_time(func, *args, **kwargs):
+    """
+    Misst die Zeit, die eine Funktion benötigt, um ausgeführt zu werden, und gibt die Ergebnisse zusammen mit der Zeit zurück.
+
+    Args:
+        func (callable): Die auszuführende Funktion.
+        *args: Positionsargumente für die Funktion.
+        **kwargs: Schlüsselwortargumente für die Funktion.
+
+    Returns:
+        tuple: Die Ergebnisse der Funktion und die verstrichene Zeit in Millisekunden.
+    """
+    start_time = time.time()
+    result = func(*args, **kwargs)
+    end_time = time.time()
+    elapsed_time = (end_time - start_time) * 1000  # Umwandlung in Millisekunden
+    return result, elapsed_time
+
+def extract_questions_and_answers_from_json(input_json, output_txt):
+    """
+    Extrahiert Fragen und Antworten aus einer JSON-Datei und schreibt sie in eine Textdatei.
+
+    Args:
+        input_json (str): Der Pfad zur Eingabe-JSON-Datei.
+        output_txt (str): Der Pfad zur Ausgabe-Textdatei.
+    """
+    try:
+        with open(input_json, mode='r', encoding='utf-8') as jsonfile, open(output_txt, mode='w', encoding='utf-8') as txtfile:
+            data = json.load(jsonfile)
+            questions = data.get('questions', [])
+            for question in questions:
+                q = question.get('question', '')
+                a = question.get('answer', '')
+                if q and a:
+                    txtfile.write(f'"question": "{q}",\n')
+                    txtfile.write(f'"answer": "{a}"\n\n')
+        print(f"Fragen und Antworten wurden erfolgreich in {output_txt} geschrieben.")
+    except FileNotFoundError:
+        print(f"Die Datei {input_json} wurde nicht gefunden.")
+    except json.JSONDecodeError:
+        print(f"Fehler beim Parsen der JSON-Datei {input_json}.")
+    except Exception as e:
+        print(f"Ein Fehler ist aufgetreten: {e}")
+
+def load_questions_and_answers(file_path):
+    """
+    Lädt Fragen und Antworten aus einer Textdatei.
+
+    Args:
+        file_path (str): Der Pfad zur Textdatei.
+
+    Returns:
+        str: Der Inhalt der Textdatei.
+    """
+    try:
+        with open(file_path, mode='r', encoding='utf-8') as file:
+            content = file.read()
+        return content
+    except FileNotFoundError:
+        return "Datei nicht gefunden."
+    except Exception as e:
+        return f"Fehler beim Lesen der Datei: {e}"
+
+# Gradio-Interface
+def gradio_interface(query):
+    """
+    Gradio-Schnittstelle zur Verarbeitung der Benutzerabfrage.
+
+    Args:
+        query (str): Die Abfrage des Benutzers.
+
+    Returns:
+        tuple: Die gefundene Frage, Antwort, Gewichtung und die verstrichene Zeit in Millisekunden.
+    """
+    if category_nodes and questions:
+        result, elapsed_time = measure_response_time(test_model_with_answers, category_nodes, questions, query)
+        return *result, f"Reaktionszeit: {elapsed_time:.2f} ms"
+    else:
+        logging.critical("Kein Modell gefunden.")
+        return "Fehler", "Kein Modell geladen.", "0.00", "Reaktionszeit: 0.00 ms"
+
+# Pfade zu den Dateien
+input_json = 'model_with_qa.json'
+output_txt = 'questions_and_answers.txt'
+
+# Extrahiere Fragen und Antworten aus der JSON-Datei und speichere sie in der Textdatei
+extract_questions_and_answers_from_json(input_json, output_txt)
+
+# Lade die Fragen und Antworten aus der Textdatei
+questions_and_answers_content = load_questions_and_answers(output_txt)
+
+# Erstelle das Gradio-Interface
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=gr.Textbox(label="Frage eingeben", placeholder="Stellen Sie eine Frage..."),
+    outputs=[
+        gr.Textbox(label="Frage"),
+        gr.Textbox(label="Antwort"),
+        gr.Textbox(label="Gewichtung"),
+        gr.Textbox(label="Reaktionszeit")
+    ],
+    title="Frage-Antwort-Modell",
+    description="Stellen Sie eine Frage, und das Modell wird versuchen, eine passende Antwort mit Gewichtung zu finden."
+)
+
+# Füge ein aufklappbares Ausgabefenster hinzu, das die Liste der Fragen und Antworten anzeigt
+with gr.Blocks() as demo:
+    gr.Markdown("## Frage-Antwort-Modell")
+    with gr.Row():
+        with gr.Column():
+            iface.render()
+        with gr.Column():
+            gr.Markdown("### Fragen und Antworten")
+            gr.Textbox(value=questions_and_answers_content, lines=20, label="Fragen und Antworten", interactive=False)
+
+# Starte das Gradio-Interface
+demo.launch()

model_with_qa.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34eacbaffd1e18ea850939abb13fb2e1f798e363ace16d70d3adf235dc2f8c20
+size 11131278

warum.md

@@ -0,0 +1,25 @@
+**Meine Motivation hinter DRLCogNet: Eine KI gegen den Strom**
+
+Ich habe diese KI, die ich DRLCogNet (Deep Reinforcement Learning Cognitive Network) nenne, mit einer tiefen Skepsis gegenüber dem etablierten Paradigma der KI-Entwicklung entworfen. Es schien mir nicht richtig, dass der Zugang zu leistungsfähiger KI von gigantischen Investitionen in Hardware und komplexen, ressourcenintensiven Modellen abhängen sollte. Die gängige Praxis, KI-Modelle an strenge Normen anzupassen, erschien mir einschränkend und wenig förderlich für echte Innovation.
+
+Mein Forschungsdrang war getrieben von der Frage: Gibt es eine Alternative? Kann KI auch anders funktionieren, ohne die astronomischen Kosten und den Ressourcenverbrauch, die oft damit einhergehen? Diese Frage hat mich dazu gebracht, die Grenzen des Bekannten zu verlassen und eine neue Richtung einzuschlagen.
+
+**DRLCogNet: Mein Anti-Establishment-Ansatz**
+
+DRLCogNet ist nicht nur ein weiteres KI-Modell; es ist ein Ergebnis meines Bestrebens, konventionelle Denkweisen zu überwinden. Anstatt einfach den etablierten Pfaden zu folgen, habe ich mich entschieden,:
+
+*   **Netzwerkstrukturen zu erforschen:** Ich wollte ein Netzwerk entwickeln, das auf einfachen Knoten und Verbindungen basiert, die in der Lage sind, komplexe kognitive Prozesse zu simulieren.
+*   **Innovative Lernmechanismen zu implementieren:** DRLCogNet lernt durch Hebb'sches Lernen und weitere an den Neurowissenschaften angelehnten Lernalgorithmen, die ich an meine Bedürfnisse angepasst habe.
+*   **Kausale Beziehungen zu untersuchen:** Es war mein Ziel, ein System zu schaffen, das nicht nur Muster erkennt, sondern auch die zugrundeliegenden Ursache-Wirkungs-Beziehungen versteht.
+*   **Emotionen und Kontext zu integrieren:** Ich wollte, dass DRLCogNet nicht nur Daten verarbeitet, sondern auch auf Emotionen und Kontextfaktoren reagieren kann, um eine menschlichere Form der Intelligenz anzustreben.
+*   **Visualisierung und Interpretierbarkeit zu ermöglichen:** Anstatt ein schwarzer Kasten zu sein, sollte DRLCogNet Einblicke in seine eigenen Prozesse ermöglichen, um seine Entscheidungen nachvollziehbar zu machen.
+
+**Das Ergebnis: Eine KI die anders denkt**
+
+Das Ergebnis meiner Arbeit ist DRLCogNet, eine KI, die sich bewusst vom Standard abhebt. Es ist ein Netzwerk, das sich durch seine Anpassungsfähigkeit, seine Fähigkeit zu kausalem Denken und seine Berücksichtigung von Kontext und Emotionen auszeichnet. Es ist der Beweis dafür, dass es möglich ist, leistungsfähige KI-Systeme zu entwickeln, die nicht zwangsläufig auf teure Hardware und eine massive Datenverarbeitung angewiesen sind.
+
+DRLCogNet ist ein Schritt auf dem Weg zu einer KI, die nicht nur intelligent, sondern auch zugänglicher, effizienter und transparenter ist. Ich bin stolz darauf, dieses Projekt vorzustellen, und hoffe, dass es die Grenzen dessen, was in der KI-Entwicklung möglich ist, erweitert.
+
+*   **Die kontinuierliche Weiterentwicklung:** Man Drang nach mehr wird mich sicherlich dazu bringen DRLCogNet kontinuierlich zu verbessern und zu erweitern.
+
+