Update cognitive_mapping_probe/orchestrator_seismograph.py

cognitive_mapping_probe/orchestrator_seismograph.py

@@ -3,10 +3,11 @@ import numpy as np
 import gc
 from typing import Dict, Any, Optional, List
 
-from .llm_iface import get_or_load_model, LLM
+from .llm_iface import get_or_load_model, LLM, release_model
 from .resonance_seismograph import run_cogitation_loop, run_silent_cogitation_seismic
 from .concepts import get_concept_vector
 from .introspection import generate_introspective_report
+from .signal_analysis import analyze_cognitive_signal, get_power_spectrum_for_plotting
 from .utils import dbg
 
 def run_seismic_analysis(
@@ -20,53 +21,71 @@ def run_seismic_analysis(
     llm_instance: Optional[LLM] = None,
     injection_vector_cache: Optional[torch.Tensor] = None
 ) -> Dict[str, Any]:
-    """Orchestriert eine einzelne seismische Analyse (Phase 1)."""
+    """
+    Orchestriert eine einzelne seismische Analyse und integriert nun standardmäßig
+    die fortgeschrittene Signal-Analyse.
+    """
     local_llm_instance = False
-    if llm_instance is None:
-        progress_callback(0.0, desc=f"Loading model '{model_id}'...")
-        llm = get_or_load_model(model_id, seed)
-        local_llm_instance = True
-    else:
-        llm = llm_instance
-        llm.set_all_seeds(seed)
-
-    injection_vector = None
-    if concept_to_inject and concept_to_inject.strip():
-        if injection_vector_cache is not None:
-            dbg(f"Using cached injection vector for '{concept_to_inject}'.")
-            injection_vector = injection_vector_cache
+    llm = None
+    try:
+        if llm_instance is None:
+            progress_callback(0.0, desc=f"Loading model '{model_id}'...")
+            llm = get_or_load_model(model_id, seed)
+            local_llm_instance = True
         else:
-            progress_callback(0.2, desc=f"Vectorizing '{concept_to_inject}'...")
-            injection_vector = get_concept_vector(llm, concept_to_inject.strip())
+            llm = llm_instance
+            llm.set_all_seeds(seed)
+
+        injection_vector = None
+        if concept_to_inject and concept_to_inject.strip():
+            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}'...")
+
+        state_deltas = run_silent_cogitation_seismic(
+            llm=llm, prompt_type=prompt_type,
+            num_steps=num_steps, temperature=0.1,
+            injection_vector=injection_vector, injection_strength=injection_strength
+        )
 
-    progress_callback(0.3, desc=f"Recording dynamics for '{prompt_type}'...")
+        progress_callback(0.9, desc="Analyzing...")
+        
+        stats = {}
+        results = {}
+        verdict = "### ⚠️ Analysis Warning\nNo state changes recorded."
 
-    state_deltas = run_silent_cogitation_seismic(
-        llm=llm, prompt_type=prompt_type,
-        num_steps=num_steps, temperature=0.1,
-        injection_vector=injection_vector, injection_strength=injection_strength
-    )
+        if state_deltas:
+            deltas_np = np.array(state_deltas)
+            stats = { 
+                "mean_delta": float(np.mean(deltas_np)), 
+                "std_delta": float(np.std(deltas_np)), 
+                "max_delta": float(np.max(deltas_np)), 
+                "min_delta": float(np.min(deltas_np)), 
+            }
+            
+            signal_metrics = analyze_cognitive_signal(deltas_np)
+            stats.update(signal_metrics)
 
-    progress_callback(0.9, desc="Analyzing...")
+            freqs, power = get_power_spectrum_for_plotting(deltas_np)
 
-    if state_deltas:
-        deltas_np = np.array(state_deltas)
-        stats = { "mean_delta": float(np.mean(deltas_np)), "std_delta": float(np.std(deltas_np)), "max_delta": float(np.max(deltas_np)), "min_delta": float(np.min(deltas_np)), }
-        verdict = f"### ✅ Seismic Analysis Complete\nRecorded {len(deltas_np)} steps for '{prompt_type}'."
-        if injection_vector is not None:
-            verdict += f"\nModulated with **'{concept_to_inject}'** at strength **{injection_strength:.2f}**."
-    else:
-        stats, verdict = {}, "### ⚠️ Analysis Warning\nNo state changes recorded."
+            verdict = f"### ✅ Seismic Analysis Complete\nRecorded {len(deltas_np)} steps for '{prompt_type}'."
+            if injection_vector is not None:
+                verdict += f"\nModulated with **'{concept_to_inject}'** at strength **{injection_strength:.2f}**."
+            
+            results["power_spectrum"] = {"frequencies": freqs.tolist(), "power": power.tolist()}
 
-    results = { "verdict": verdict, "stats": stats, "state_deltas": state_deltas }
+        results.update({ "verdict": verdict, "stats": stats, "state_deltas": state_deltas })
 
-    if local_llm_instance:
-        dbg(f"Releasing locally created model instance for '{model_id}'.")
-        del llm, injection_vector
-        gc.collect()
-        if torch.cuda.is_available(): torch.cuda.empty_cache()
+        return results
 
-    return results
+    finally:
+        if local_llm_instance and llm is not None:
+            release_model(llm)
 
 def run_triangulation_probe(
     model_id: str,
@@ -78,62 +97,58 @@ def run_triangulation_probe(
     injection_strength: float = 0.0,
     llm_instance: Optional[LLM] = None,
 ) -> Dict[str, Any]:
-    """
-    Orchestriert ein vollständiges Triangulations-Experiment, jetzt mit optionaler Injektion.
-    """
+    """Orchestriert ein vollständiges Triangulations-Experiment."""
     local_llm_instance = False
-    if llm_instance is None:
-        progress_callback(0.0, desc=f"Loading model '{model_id}'...")
-        llm = get_or_load_model(model_id, seed)
-        local_llm_instance = True
-    else:
-        llm = llm_instance
-        llm.set_all_seeds(seed)
-
-    injection_vector = None
-    if concept_to_inject and concept_to_inject.strip() and injection_strength > 0:
-        if concept_to_inject.lower() == "random_noise":
-             progress_callback(0.15, desc="Generating random noise vector...")
-             hidden_dim = llm.stable_config.hidden_dim
-             noise_vec = torch.randn(hidden_dim)
-             base_norm = 70.0
-             injection_vector = (noise_vec / torch.norm(noise_vec)) * base_norm
+    llm = None
+    try:
+        if llm_instance is None:
+            progress_callback(0.0, desc=f"Loading model '{model_id}'...")
+            llm = get_or_load_model(model_id, seed)
+            local_llm_instance = True
         else:
-            progress_callback(0.15, desc=f"Vectorizing '{concept_to_inject}'...")
-            injection_vector = get_concept_vector(llm, concept_to_inject.strip())
-
-    progress_callback(0.3, desc=f"Phase 1/2: Recording dynamics for '{prompt_type}'...")
-    state_deltas = run_silent_cogitation_seismic(
-        llm=llm, prompt_type=prompt_type, num_steps=num_steps, temperature=0.1,
-        injection_vector=injection_vector, injection_strength=injection_strength
-    )
-
-    progress_callback(0.7, desc="Phase 2/2: Generating introspective report...")
-    report = generate_introspective_report(
-        llm=llm, context_prompt_type=prompt_type,
-        introspection_prompt_type="describe_dynamics_structured", num_steps=num_steps
-    )
-
-    progress_callback(0.9, desc="Analyzing...")
-    if state_deltas:
-        deltas_np = np.array(state_deltas)
-        stats = { "mean_delta": float(np.mean(deltas_np)), "std_delta": float(np.std(deltas_np)), "max_delta": float(np.max(deltas_np)) }
-        verdict = "### ✅ Triangulation Probe Complete"
-    else:
-        stats, verdict = {}, "### ⚠️ Triangulation Warning"
-
-    results = {
-        "verdict": verdict, "stats": stats, "state_deltas": state_deltas,
-        "introspective_report": report
-    }
-
-    if local_llm_instance:
-        dbg(f"Releasing locally created model instance for '{model_id}'.")
-        del llm, injection_vector
-        gc.collect()
-        if torch.cuda.is_available(): torch.cuda.empty_cache()
+            llm = llm_instance
+            llm.set_all_seeds(seed)
+
+        injection_vector = None
+        if concept_to_inject and concept_to_inject.strip() and injection_strength > 0:
+            if concept_to_inject.lower() == "random_noise":
+                 progress_callback(0.15, desc="Generating random noise vector...")
+                 hidden_dim = llm.stable_config.hidden_dim
+                 noise_vec = torch.randn(hidden_dim)
+                 base_norm = 70.0 
+                 injection_vector = (noise_vec / torch.norm(noise_vec)) * base_norm
+            else:
+                progress_callback(0.15, desc=f"Vectorizing '{concept_to_inject}'...")
+                injection_vector = get_concept_vector(llm, concept_to_inject.strip())
+
+        progress_callback(0.3, desc=f"Phase 1/2: Recording dynamics for '{prompt_type}'...")
+        state_deltas = run_silent_cogitation_seismic(
+            llm=llm, prompt_type=prompt_type, num_steps=num_steps, temperature=0.1,
+            injection_vector=injection_vector, injection_strength=injection_strength
+        )
 
-    return results
+        progress_callback(0.7, desc="Phase 2/2: Generating introspective report...")
+        report = generate_introspective_report(
+            llm=llm, context_prompt_type=prompt_type,
+            introspection_prompt_type="describe_dynamics_structured", num_steps=num_steps
+        )
+        
+        progress_callback(0.9, desc="Analyzing...")
+        stats = {}
+        verdict = "### ⚠️ Triangulation Warning"
+        if state_deltas:
+            deltas_np = np.array(state_deltas)
+            stats = { "mean_delta": float(np.mean(deltas_np)), "std_delta": float(np.std(deltas_np)), "max_delta": float(np.max(deltas_np)) }
+            verdict = "### ✅ Triangulation Probe Complete"
+
+        results = {
+            "verdict": verdict, "stats": stats, "state_deltas": state_deltas,
+            "introspective_report": report
+        }
+        return results
+    finally:
+        if local_llm_instance and llm is not None:
+            release_model(llm)
 
 def run_causal_surgery_probe(
     model_id: str,
@@ -145,117 +160,29 @@ def run_causal_surgery_probe(
     progress_callback,
     reset_kv_cache_on_patch: bool = False
 ) -> Dict[str, Any]:
-    """
-    Orchestriert ein "Activation Patching"-Experiment, jetzt mit KV-Cache-Reset-Option.
-    """
-    progress_callback(0.0, desc=f"Loading model '{model_id}'...")
-    llm = get_or_load_model(model_id, seed)
-
-    progress_callback(0.1, desc=f"Phase 1/3: Recording source state ('{source_prompt_type}')...")
-    source_results = run_cogitation_loop(
-        llm=llm, prompt_type=source_prompt_type, num_steps=num_steps,
-        temperature=0.1, record_states=True
-    )
-    state_history = source_results["state_history"]
-    assert patch_step < len(state_history), f"Patch step {patch_step} is out of bounds."
-    patch_state = state_history[patch_step]
-    dbg(f"Source state at step {patch_step} recorded with norm {torch.norm(patch_state).item():.2f}.")
-
-    progress_callback(0.4, desc=f"Phase 2/3: Running patched destination ('{dest_prompt_type}')...")
-    patched_run_results = run_cogitation_loop(
-        llm=llm, prompt_type=dest_prompt_type, num_steps=num_steps,
-        temperature=0.1, patch_step=patch_step, patch_state_source=patch_state,
-        reset_kv_cache_on_patch=reset_kv_cache_on_patch
-    )
-
-    progress_callback(0.8, desc="Phase 3/3: Generating introspective report...")
-    report = generate_introspective_report(
-        llm=llm, context_prompt_type=dest_prompt_type,
-        introspection_prompt_type="describe_dynamics_structured", num_steps=num_steps
-    )
-
-    progress_callback(0.95, desc="Analyzing...")
-    deltas_np = np.array(patched_run_results["state_deltas"])
-    stats = { "mean_delta": float(np.mean(deltas_np)), "std_delta": float(np.std(deltas_np)), "max_delta": float(np.max(deltas_np)) }
-
-    results = {
-        "verdict": "### ✅ Causal Surgery Probe Complete",
-        "stats": stats,
-        "state_deltas": patched_run_results["state_deltas"],
-        "introspective_report": report,
-        "patch_info": {
-            "source_prompt": source_prompt_type,
-            "dest_prompt": dest_prompt_type,
-            "patch_step": patch_step,
-            "kv_cache_reset": reset_kv_cache_on_patch
-        }
-    }
-
-    dbg(f"Releasing model instance for '{model_id}'.")
-    del llm, state_history, patch_state
-    gc.collect()
-    if torch.cuda.is_available(): torch.cuda.empty_cache()
-
-    return results
-
-def run_act_titration_probe(
-    model_id: str,
-    source_prompt_type: str,
-    dest_prompt_type: str,
-    patch_steps: List[int],
-    seed: int,
-    num_steps: int,
-    progress_callback,
-) -> Dict[str, Any]:
-    """
-    Führt eine Serie von "Causal Surgery"-Experimenten durch, um den "Attractor Capture Time"
-    durch Titration des `patch_step` zu finden.
-    """
-    progress_callback(0.0, desc=f"Loading model '{model_id}'...")
-    llm = get_or_load_model(model_id, seed)
-
-    progress_callback(0.05, desc=f"Recording full source state history ('{source_prompt_type}')...")
-    source_results = run_cogitation_loop(
-        llm=llm, prompt_type=source_prompt_type, num_steps=num_steps,
-        temperature=0.1, record_states=True
-    )
-    state_history = source_results["state_history"]
-    dbg(f"Full source state history ({len(state_history)} steps) recorded.")
-
-    titration_results = []
-    total_steps = len(patch_steps)
-    for i, step in enumerate(patch_steps):
-        progress_callback(0.15 + (i / total_steps) * 0.8, desc=f"Titrating patch at step {step}/{num_steps}")
-
-        if step >= len(state_history):
-            dbg(f"Skipping patch step {step} as it is out of bounds for history of length {len(state_history)}.")
-            continue
+    """Orchestriert ein "Activation Patching"-Experiment."""
+    llm = None
+    try:
+        progress_callback(0.0, desc=f"Loading model '{model_id}'...")
+        llm = get_or_load_model(model_id, seed)
 
-        patch_state = state_history[step]
+        progress_callback(0.1, desc=f"Phase 1/3: Recording source state ('{source_prompt_type}')...")
+        source_results = run_cogitation_loop(
+            llm=llm, prompt_type=source_prompt_type, num_steps=num_steps,
+            temperature=0.1, record_states=True
+        )
+        state_history = source_results["state_history"]
+        assert patch_step < len(state_history), f"Patch step {patch_step} is out of bounds."
+        patch_state = state_history[patch_step]
+        dbg(f"Source state at step {patch_step} recorded with norm {torch.norm(patch_state).item():.2f}.")
 
+        progress_callback(0.4, desc=f"Phase 2/3: Running patched destination ('{dest_prompt_type}')...")
         patched_run_results = run_cogitation_loop(
             llm=llm, prompt_type=dest_prompt_type, num_steps=num_steps,
-            temperature=0.1, patch_step=step, patch_state_source=patch_state
+            temperature=0.1, patch_step=patch_step, patch_state_source=patch_state,
+            reset_kv_cache_on_patch=reset_kv_cache_on_patch
         )
 
-        deltas = patched_run_results["state_deltas"]
-
-        buffer = 10
-        post_patch_deltas = deltas[step + buffer:]
-        post_patch_mean_delta = np.mean(post_patch_deltas) if post_patch_deltas else 0.0
-
-        titration_results.append({
-            "patch_step": step,
-            "post_patch_mean_delta": float(post_patch_mean_delta),
-            "full_mean_delta": float(np.mean(deltas)),
-        })
-
-    dbg(f"Releasing model instance for '{model_id}'.")
-    del llm, state_history
-    gc.collect()
-    if torch.cuda.is_available(): torch.cuda.empty_cache()
-
-    return {
-        "verdict": "### ✅ ACT Titration Complete",
-        "titration_data": titration_results
-    }
+        progress_callback(0.8, desc="Phase 3/3: Generating introspective report...")
+        report = generate_introspective_report(
+            llm=llm,