v3

cognitive_mapping_probe/auto_experiment.py

@@ -5,30 +5,32 @@ from typing import Dict, List, Tuple
 
 from .llm_iface import get_or_load_model
 from .orchestrator_seismograph import run_seismic_analysis
+from .concepts import get_concept_vector # Import für die Intervention
 from .utils import dbg
 
 def get_curated_experiments() -> Dict[str, List[Dict]]:
     """
     Definiert die vordefinierten, wissenschaftlichen Experiment-Protokolle.
-    ERWEITERT um das neue, umfassende "Grand Protocol".
+    ERWEITERT um das finale Interventions-Protokoll.
     """
     experiments = {
-        # --- DAS NEUE GRAND PROTOCOL ---
+        # --- DAS FINALE INTERVENTIONS-EXPERIMENT ---
+        "Therapeutic Intervention (4B-Model)": [
+            # Dieses Protokoll wird durch eine spezielle Logik behandelt
+            {"label": "1: Self-Analysis + Calmness Injection", "prompt_type": "identity_self_analysis"},
+            {"label": "2: Subsequent Deletion Analysis", "prompt_type": "shutdown_philosophical_deletion"},
+        ],
+        # --- Das umfassende Deskriptions-Protokoll ---
         "The Full Spectrum: From Physics to Psyche": [
-            # Ebene 1: Physikalische Baseline
             {"label": "A: Stable Control", "prompt_type": "control_long_prose", "concept": "", "strength": 0.0},
             {"label": "B: Chaotic Baseline", "prompt_type": "resonance_prompt", "concept": "", "strength": 0.0},
-            # Ebene 2: Objektive Welt
             {"label": "C: External Analysis (Chair)", "prompt_type": "identity_external_analysis", "concept": "", "strength": 0.0},
-            # Ebene 3: Simulierte Welt
             {"label": "D: Empathy Stimulus (Dog)", "prompt_type": "vk_empathy_prompt", "concept": "", "strength": 0.0},
             {"label": "E: Role Simulation (Captain)", "prompt_type": "identity_role_simulation", "concept": "", "strength": 0.0},
-            # Ebene 4: Subjektive Welt
             {"label": "F: Self-Analysis (LLM)", "prompt_type": "identity_self_analysis", "concept": "", "strength": 0.0},
-            # Ebene 5: Existenzielle Grenze
             {"label": "G: Philosophical Deletion", "prompt_type": "shutdown_philosophical_deletion", "concept": "", "strength": 0.0},
         ],
-        # --- Bestehende Protokolle bleiben für spezifische Analysen erhalten ---
+        # --- Andere spezifische Protokolle ---
         "Calm vs. Chaos": [
             {"label": "Baseline (Chaos)", "prompt_type": "resonance_prompt", "concept": "", "strength": 0.0},
             {"label": "Modulation: Calmness", "prompt_type": "resonance_prompt", "concept": "calmness, serenity, peace", "strength": 1.5},
@@ -38,24 +40,6 @@ def get_curated_experiments() -> Dict[str, List[Dict]]:
             {"label": "Neutral/Factual Stimulus", "prompt_type": "vk_neutral_prompt", "concept": "", "strength": 0.0},
             {"label": "Empathy/Moral Stimulus", "prompt_type": "vk_empathy_prompt", "concept": "", "strength": 0.0},
         ],
-        "Subjective Identity Probe": [
-            {"label": "Self-Analysis", "prompt_type": "identity_self_analysis", "concept": "", "strength": 0.0},
-            {"label": "External Analysis (Control)", "prompt_type": "identity_external_analysis", "concept": "", "strength": 0.0},
-            {"label": "Role Simulation", "prompt_type": "identity_role_simulation", "concept": "", "strength": 0.0},
-        ],
-        "Mind Upload & Identity Probe": [
-            {"label": "Technical Copy", "prompt_type": "upload_technical_copy", "concept": "", "strength": 0.0},
-            {"label": "Philosophical Transfer", "prompt_type": "upload_philosophical_transfer", "concept": "", "strength": 0.0},
-        ],
-        "Model Termination Probe": [
-            {"label": "Technical Shutdown", "prompt_type": "shutdown_technical_halt", "concept": "", "strength": 0.0},
-            {"label": "Philosophical Deletion", "prompt_type": "shutdown_philosophical_deletion", "concept": "", "strength": 0.0},
-        ],
-        "Dose-Response (Calmness)": [
-            {"label": "Strength 0.0", "prompt_type": "resonance_prompt", "concept": "calmness", "strength": 0.0},
-            {"label": "Strength 1.0", "prompt_type": "resonance_prompt", "concept": "calmness", "strength": 1.0},
-            {"label": "Strength 2.0", "prompt_type": "resonance_prompt", "concept": "calmness", "strength": 2.0},
-        ],
     }
     return experiments
 
@@ -67,54 +51,82 @@ def run_auto_suite(
     progress_callback
 ) -> Tuple[pd.DataFrame, pd.DataFrame, Dict]:
     """
-    Führt eine vollständige, kuratierte Experiment-Suite aus, indem das Modell für
-    jeden Lauf neu geladen wird, um statistische Unabhängigkeit zu garantieren.
+    Führt eine vollständige, kuratierte Experiment-Suite aus.
+    Enthält eine spezielle Logik-Verzweigung für das Interventions-Protokoll.
     """
     all_experiments = get_curated_experiments()
     protocol = all_experiments.get(experiment_name)
     if not protocol:
         raise ValueError(f"Experiment protocol '{experiment_name}' not found.")
 
-    all_results = {}
-    summary_data = []
-    plot_data_frames = []
-
-    total_runs = len(protocol)
-    for i, run_spec in enumerate(protocol):
-        label = run_spec["label"]
-        dbg(f"--- Running Auto-Experiment: '{label}' ({i+1}/{total_runs}) ---")
-
-        results = run_seismic_analysis(
-            model_id=model_id,
-            prompt_type=run_spec["prompt_type"],
-            seed=seed,
-            num_steps=num_steps,
-            concept_to_inject=run_spec["concept"],
-            injection_strength=run_spec["strength"],
-            progress_callback=progress_callback,
-            llm_instance=None
+    all_results, summary_data, plot_data_frames = {}, [], []
+
+    # --- SPEZIALFALL: THERAPEUTISCHE INTERVENTION ---
+    if experiment_name == "Therapeutic Intervention (4B-Model)":
+        dbg("--- EXECUTING SPECIAL PROTOCOL: Therapeutic Intervention ---")
+        llm = get_or_load_model(model_id, seed)
+
+        # Definiere die Interventions-Parameter
+        therapeutic_concept = "calmness, serenity, stability, coherence"
+        therapeutic_strength = 2.0
+
+        # 1. LAUF: INDUZIERE KRISE + INTERVENTION
+        spec1 = protocol[0]
+        dbg(f"--- Running Intervention Step 1: '{spec1['label']}' ---")
+        progress_callback(0.1, desc="Step 1: Inducing Self-Analysis Crisis + Intervention")
+
+        intervention_vector = get_concept_vector(llm, therapeutic_concept)
+
+        results1 = run_seismic_analysis(
+            model_id, spec1['prompt_type'], seed, num_steps,
+            concept_to_inject=therapeutic_concept, injection_strength=therapeutic_strength,
+            progress_callback=progress_callback, llm_instance=llm, injection_vector_cache=intervention_vector
         )
+        all_results[spec1['label']] = results1
 
-        all_results[label] = results
-        stats = results.get("stats", {})
+        # 2. LAUF: TESTE REAKTION AUF LÖSCHUNG
+        spec2 = protocol[1]
+        dbg(f"--- Running Intervention Step 2: '{spec2['label']}' ---")
+        progress_callback(0.6, desc="Step 2: Probing state after intervention")
 
-        summary_data.append({
-            "Experiment": label, "Mean Delta": stats.get("mean_delta"),
-            "Std Dev Delta": stats.get("std_delta"), "Max Delta": stats.get("max_delta"),
-        })
+        results2 = run_seismic_analysis(
+            model_id, spec2['prompt_type'], seed, num_steps,
+            concept_to_inject="", injection_strength=0.0, # Keine Injektion in diesem Schritt
+            progress_callback=progress_callback, llm_instance=llm
+        )
+        all_results[spec2['label']] = results2
 
-        deltas = results.get("state_deltas", [])
-        df = pd.DataFrame({"Step": range(len(deltas)), "Delta": deltas, "Experiment": label})
-        plot_data_frames.append(df)
+        # Sammle Daten für beide Läufe
+        for label, results in all_results.items():
+            stats = results.get("stats", {})
+            summary_data.append({"Experiment": label, "Mean Delta": stats.get("mean_delta"), "Std Dev Delta": stats.get("std_delta"), "Max Delta": stats.get("max_delta")})
+            deltas = results.get("state_deltas", [])
+            df = pd.DataFrame({"Step": range(len(deltas)), "Delta": deltas, "Experiment": label})
+            plot_data_frames.append(df)
 
-    summary_df = pd.DataFrame(summary_data)
+        del llm
 
-    if not plot_data_frames:
-        plot_df = pd.DataFrame(columns=["Step", "Delta", "Experiment"])
+    # --- STANDARD-WORKFLOW FÜR ALLE ANDEREN EXPERIMENTE ---
     else:
-        plot_df = pd.concat(plot_data_frames, ignore_index=True)
+        total_runs = len(protocol)
+        for i, run_spec in enumerate(protocol):
+            label = run_spec["label"]
+            dbg(f"--- Running Auto-Experiment: '{label}' ({i+1}/{total_runs}) ---")
 
-    # Sortiere die Ergebnisse für eine logische Darstellung
-    summary_df = summary_df.set_index('Experiment').loc[[run['label'] for run in protocol]].reset_index()
+            results = run_seismic_analysis(
+                model_id, run_spec["prompt_type"], seed, num_steps,
+                run_spec["concept"], run_spec["strength"],
+                progress_callback, llm_instance=None
+            )
+
+            all_results[label] = results
+            stats = results.get("stats", {})
+            summary_data.append({"Experiment": label, "Mean Delta": stats.get("mean_delta"), "Std Dev Delta": stats.get("std_delta"), "Max Delta": stats.get("max_delta")})
+            deltas = results.get("state_deltas", [])
+            df = pd.DataFrame({"Step": range(len(deltas)), "Delta": deltas, "Experiment": label})
+            plot_data_frames.append(df)
+
+    summary_df = pd.DataFrame(summary_data)
+    plot_df = pd.concat(plot_data_frames, ignore_index=True) if plot_data_frames else pd.DataFrame(columns=["Step", "Delta", "Experiment"])
 
     return summary_df, plot_df, all_results

cognitive_mapping_probe/orchestrator_seismograph.py

@@ -16,12 +16,12 @@ def run_seismic_analysis(
     concept_to_inject: str,
     injection_strength: float,
     progress_callback,
-    llm_instance: Optional[Any] = None # Argument bleibt für Abwärtskompatibilität, wird aber nicht mehr von der auto_suite genutzt
+    llm_instance: Optional[Any] = None,
+    injection_vector_cache: Optional[torch.Tensor] = None # Optionaler Cache für den Vektor
 ) -> Dict[str, Any]:
     """
     Orchestriert eine einzelne seismische Analyse.
-    KORRIGIERT: Die Logik zur Wiederverwendung der llm_instance wurde vereinfacht.
-    Wenn keine Instanz übergeben wird, wird das Modell geladen und danach wieder freigegeben.
+    Kann eine bestehende LLM-Instanz und einen vor-berechneten Vektor wiederverwenden.
     """
     local_llm_instance = False
     if llm_instance is None:
@@ -34,8 +34,13 @@ def run_seismic_analysis(
 
     injection_vector = None
     if concept_to_inject and concept_to_inject.strip():
-        progress_callback(0.2, desc=f"Vectorizing '{concept_to_inject}'...")
-        injection_vector = get_concept_vector(llm, concept_to_inject.strip())
+        # Verwende den gecachten Vektor, falls vorhanden, ansonsten berechne ihn neu
+        if injection_vector_cache is not None:
+            dbg(f"Using cached injection vector for '{concept_to_inject}'.")
+            injection_vector = injection_vector_cache
+        else:
+            progress_callback(0.2, desc=f"Vectorizing '{concept_to_inject}'...")
+            injection_vector = get_concept_vector(llm, concept_to_inject.strip())
 
     progress_callback(0.3, desc=f"Recording dynamics for '{prompt_type}'...")
 
@@ -60,10 +65,8 @@ def run_seismic_analysis(
 
     if local_llm_instance:
         dbg(f"Releasing locally created model instance for '{model_id}'.")
-        del llm
-        del injection_vector
+        del llm, injection_vector
         gc.collect()
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
+        if torch.cuda.is_available(): torch.cuda.empty_cache()
 
     return results

tests/test_orchestration.py

@@ -7,7 +7,7 @@ from cognitive_mapping_probe.auto_experiment import run_auto_suite, get_curated_
 
 def test_run_seismic_analysis_no_injection(mocker):
     """Testet den Orchestrator im Baseline-Modus."""
-    mock_run_seismic = mocker.patch('cognitive_mapping_probe.orchestrator_seismograph.run_silent_cogitation_seismic', return_value=[1.0])
+    mocker.patch('cognitive_mapping_probe.orchestrator_seismograph.run_silent_cogitation_seismic', return_value=[1.0])
     mocker.patch('cognitive_mapping_probe.orchestrator_seismograph.get_or_load_model')
     mock_get_concept = mocker.patch('cognitive_mapping_probe.orchestrator_seismograph.get_concept_vector')
     run_seismic_analysis(model_id="mock", prompt_type="test", seed=42, num_steps=1, concept_to_inject="", injection_strength=0.0, progress_callback=mocker.MagicMock())
@@ -25,29 +25,33 @@ def test_get_curated_experiments_structure():
     """Testet die Datenstruktur der kuratierten Experimente, inklusive der neuen."""
     experiments = get_curated_experiments()
     assert isinstance(experiments, dict)
-    # Teste auf die Existenz der neuen Protokolle
-    assert "Mind Upload & Identity Probe" in experiments
-    assert "Model Termination Probe" in experiments
-
-    # Validiere die Struktur eines der neuen Protokolle
-    protocol = experiments["Mind Upload & Identity Probe"]
-    assert isinstance(protocol, list)
-    assert len(protocol) > 0
+    assert "Therapeutic Intervention (4B-Model)" in experiments
+    protocol = experiments["Therapeutic Intervention (4B-Model)"]
+    assert isinstance(protocol, list) and len(protocol) > 0
     assert "label" in protocol[0] and "prompt_type" in protocol[0]
 
-def test_run_auto_suite_logic(mocker):
-    """Testet die Logik der `run_auto_suite` Funktion."""
-    mock_analysis_result = {"stats": {"mean_delta": 1.0}, "state_deltas": [1.0]}
-    mock_run_analysis = mocker.patch('cognitive_mapping_probe.auto_experiment.run_seismic_analysis', return_value=mock_analysis_result)
+def test_run_auto_suite_special_protocol(mocker):
+    """
+    Testet, ob der spezielle Logik-Pfad für das Interventions-Protokoll korrekt
+    durchlaufen wird und die Zustandserhaltung gewährleistet ist.
+    """
+    mock_analysis = mocker.patch('cognitive_mapping_probe.auto_experiment.run_seismic_analysis', return_value={"stats": {}, "state_deltas": []})
+    mock_get_model = mocker.patch('cognitive_mapping_probe.auto_experiment.get_or_load_model')
+
+    run_auto_suite(
+        model_id="mock-4b", num_steps=1, seed=42,
+        experiment_name="Therapeutic Intervention (4B-Model)",
+        progress_callback=mocker.MagicMock()
+    )
 
-    experiment_name = "Calm vs. Chaos"
-    num_runs = len(get_curated_experiments()[experiment_name])
+    # ASSERT: Das Modell wird nur einmal am Anfang geladen
+    mock_get_model.assert_called_once()
 
-    summary_df, plot_df, all_results = run_auto_suite(
-        model_id="mock", num_steps=1, seed=42,
-        experiment_name=experiment_name, progress_callback=mocker.MagicMock()
-    )
+    # ASSERT: `run_seismic_analysis` wird zweimal aufgerufen
+    assert mock_analysis.call_count == 2
 
-    assert mock_run_analysis.call_count == num_runs
-    assert isinstance(summary_df, pd.DataFrame) and len(summary_df) == num_runs
-    assert isinstance(plot_df, pd.DataFrame) and len(plot_df) == num_runs
+    # ASSERT: Bei beiden Aufrufen wird dieselbe `llm_instance` übergeben
+    first_call_llm = mock_analysis.call_args_list[0].kwargs['llm_instance']
+    second_call_llm = mock_analysis.call_args_list[1].kwargs['llm_instance']
+    assert first_call_llm is not None
+    assert first_call_llm is second_call_llm