get layers from model

cognitive_mapping_probe/llm_iface.py

@@ -3,8 +3,8 @@ import torch
 import random
 import numpy as np
 from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed
-from typing import Optional
-from dataclasses import dataclass
+from typing import Optional, List
+from dataclasses import dataclass, field
 
 from .utils import dbg
 
@@ -15,10 +15,12 @@ os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
 class StableLLMConfig:
     """
     Eine stabile, interne Abstraktionsschicht für Modell-Konfigurationen.
-    Macht unseren Code unabhängig von den sich ändernden Attributnamen in `transformers`.
+    Dies ist die "Single Source of Truth" für die Architektur des Modells.
     """
     hidden_dim: int
     num_layers: int
+    # FINALE KORREKTUR: Speichere einen direkten Verweis auf die Layer-Liste
+    layer_list: List[torch.nn.Module] = field(default_factory=list, repr=False)
 
 class LLM:
     """
@@ -59,7 +61,7 @@ class LLM:
     def _populate_stable_config(self) -> StableLLMConfig:
         """
         Liest die volatile `transformers`-Konfiguration aus und befüllt unsere stabile Datenklasse.
-        Implementiert eine robuste, mehrstufige Fallback-Strategie und eine auto-diagnostische Fehlerbehandlung.
+        Ermittelt die "Ground Truth" der Architektur durch direkte Inspektion.
         """
         # --- Robuste Methode für hidden_dim ---
         hidden_dim = 0
@@ -68,16 +70,21 @@ class LLM:
         except AttributeError:
             hidden_dim = getattr(self.config, 'hidden_size', getattr(self.config, 'd_model', 0))
 
-        # --- Robuste Methode für num_layers ---
+        # --- FINALE KORREKTUR: Robuste Methode für num_layers und layer_list ---
         num_layers = 0
+        layer_list = []
         try:
-            # METHODE 1 (BESTE): Direkte Inspektion der Architektur basierend auf empirischer Evidenz.
+            # METHODE 1 (BESTE): Direkte Inspektion basierend auf empirischer Evidenz.
             if hasattr(self.model, 'model') and hasattr(self.model.model, 'language_model') and hasattr(self.model.model.language_model, 'layers'):
-                 num_layers = len(self.model.model.language_model.layers)
+                 layer_list = self.model.model.language_model.layers
             elif hasattr(self.model, 'model') and hasattr(self.model.model, 'layers'):
-                 num_layers = len(self.model.model.layers)
+                 layer_list = self.model.model.layers
             elif hasattr(self.model, 'transformer') and hasattr(self.model.transformer, 'h'):
-                 num_layers = len(self.model.transformer.h)
+                 layer_list = self.model.transformer.h
+
+            if layer_list:
+                num_layers = len(layer_list)
+
         except (AttributeError, TypeError):
             pass
 
@@ -85,21 +92,20 @@ class LLM:
             # METHODE 2 (FALLBACK): Inspektion der deklarativen Config-Datei.
             num_layers = getattr(self.config, 'num_hidden_layers', getattr(self.config, 'num_layers', 0))
 
-        # --- NEU: Automatisierte diagnostische Ausgabe bei Fehlschlag ---
-        if hidden_dim <= 0 or num_layers <= 0:
+        # --- Auto-diagnostische Fehlerbehandlung ---
+        if hidden_dim <= 0 or num_layers <= 0 or not layer_list:
             dbg("--- CRITICAL: Failed to auto-determine model configuration. ---")
-            dbg(f"Detected hidden_dim: {hidden_dim}, num_layers: {num_layers}")
+            dbg(f"Detected hidden_dim: {hidden_dim}, num_layers: {num_layers}, found_layer_list: {bool(layer_list)}")
             dbg("--- DUMPING MODEL ARCHITECTURE FOR DEBUGGING: ---")
             dbg(self.model)
             dbg("--- END ARCHITECTURE DUMP ---")
 
-        # Finale Assertions zur Sicherstellung der wissenschaftlichen Validität.
-        # Diese werden nun eine informative Debug-Ausgabe vor dem Absturz haben.
-        assert hidden_dim > 0, "Could not determine hidden dimension from model config. Check debug dump above."
-        assert num_layers > 0, "Could not determine number of layers from model config. Check debug dump above."
+        assert hidden_dim > 0, "Could not determine hidden dimension. Check debug dump."
+        assert num_layers > 0, "Could not determine number of layers. Check debug dump."
+        assert layer_list, "Could not find the list of transformer layers. Check debug dump."
 
         dbg(f"Populated stable config: hidden_dim={hidden_dim}, num_layers={num_layers}")
-        return StableLLMConfig(hidden_dim=hidden_dim, num_layers=num_layers)
+        return StableLLMConfig(hidden_dim=hidden_dim, num_layers=num_layers, layer_list=layer_list)
 
     def set_all_seeds(self, seed: int):
         """Setzt alle relevanten Seeds für maximale Reproduzierbarkeit."""

cognitive_mapping_probe/resonance_seismograph.py

@@ -17,8 +17,8 @@ def run_silent_cogitation_seismic(
     injection_layer: Optional[int] = None,
 ) -> List[float]:
     """
-    ERWEITERTE VERSION: Führt den 'silent thought' Prozess aus und ermöglicht
-    die Injektion von Konzeptvektoren zur Modulation der Dynamik.
+    Führt den 'silent thought' Prozess aus und ermöglicht die Injektion von
+    Konzeptvektoren zur Modulation der Dynamik.
     """
     prompt = RESONANCE_PROMPTS[prompt_type]
     inputs = llm.tokenizer(prompt, return_tensors="pt").to(llm.model.device)
@@ -31,20 +31,15 @@ def run_silent_cogitation_seismic(
     previous_hidden_state = hidden_state_2d.clone()
     state_deltas = []
 
-    # Bereite den Hook für die Injektion vor
     hook_handle = None
     if injection_vector is not None and injection_strength > 0:
         injection_vector = injection_vector.to(device=llm.model.device, dtype=llm.model.dtype)
         if injection_layer is None:
-            # KORREKTUR: Greife auf die stabile, abstrahierte Konfiguration zu.
             injection_layer = llm.stable_config.num_layers // 2
 
         dbg(f"Injection enabled: Layer {injection_layer}, Strength {injection_strength:.2f}")
 
         def injection_hook(module, layer_input):
-            # Der Hook operiert auf dem Input, der bereits 3D ist [batch, seq_len, hidden_dim]
-            # Stelle sicher, dass der Vektor korrekt auf die Sequenzlänge des Inputs gebroadcastet wird.
-            # Normalerweise ist die seq_len hier 1.
             seq_len = layer_input[0].shape[1]
             injection_3d = injection_vector.unsqueeze(0).expand(1, seq_len, -1)
             modified_hidden_states = layer_input[0] + (injection_3d * injection_strength)
@@ -53,7 +48,6 @@ def run_silent_cogitation_seismic(
     for i in tqdm(range(num_steps), desc=f"Recording Dynamics (Temp {temperature:.2f})", leave=False, bar_format="{l_bar}{bar:10}{r_bar}"):
         next_token_logits = llm.model.lm_head(hidden_state_2d)
 
-        # Verwende eine minimale Temperatur, um deterministisches Verhalten bei temp=0 zu gewährleisten
         temp_to_use = temperature if temperature > 0.0 else 1.0
         probabilities = torch.nn.functional.softmax(next_token_logits / temp_to_use, dim=-1)
 
@@ -62,13 +56,11 @@ def run_silent_cogitation_seismic(
         else:
             next_token_id = torch.argmax(probabilities, dim=-1).unsqueeze(-1)
 
-
         try:
-            # Aktiviere den Hook vor dem forward-Pass
             if injection_vector is not None and injection_strength > 0:
-                # Stelle sicher, dass der Layer-Index gültig ist.
                 assert 0 <= injection_layer < llm.stable_config.num_layers, f"Injection layer {injection_layer} is out of bounds."
-                target_layer = llm.model.model.layers[injection_layer]
+                # FINALE KORREKTUR: Greife auf die stabile, abstrahierte Layer-Liste zu.
+                target_layer = llm.stable_config.layer_list[injection_layer]
                 hook_handle = target_layer.register_forward_pre_hook(injection_hook)
 
             outputs = llm.model(
@@ -78,7 +70,6 @@ def run_silent_cogitation_seismic(
                 use_cache=True,
             )
         finally:
-            # Deaktiviere den Hook sofort nach dem Pass
             if hook_handle:
                 hook_handle.remove()
                 hook_handle = None

tests/conftest.py

@@ -6,7 +6,6 @@ from cognitive_mapping_probe.llm_iface import LLM, StableLLMConfig
 @pytest.fixture(scope="session")
 def mock_llm_config():
     """Stellt eine minimale, Schein-Konfiguration für das LLM bereit."""
-    # Diese Fixture repräsentiert die *volatile* transformers-Konfiguration
     return SimpleNamespace(
         hidden_size=128,
         num_hidden_layers=2,
@@ -17,7 +16,7 @@ def mock_llm_config():
 def mock_llm(mocker, mock_llm_config):
     """
     Erstellt einen robusten "Mock-LLM" für Unit-Tests.
-    FINAL KORRIGIERT: Simuliert nun auch die `stable_config`-Abstraktionsschicht.
+    FINAL KORRIGIERT: Simuliert nun die vollständige `StableLLMConfig`-Abstraktion.
     """
     mock_tokenizer = mocker.MagicMock()
     mock_tokenizer.eos_token_id = 1
@@ -48,21 +47,27 @@ def mock_llm(mocker, mock_llm_config):
     llm_instance.model.device = 'cpu'
     llm_instance.model.dtype = torch.float32
     llm_instance.model.get_input_embeddings.return_value = mock_embedding_layer
+    llm_instance.model.lm_head = mocker.MagicMock(return_value=torch.randn(1, 32000))
 
+    # FINALE KORREKTUR: Simuliere die Layer-Liste für den Hook-Test
     mock_layer = mocker.MagicMock()
     mock_layer.register_forward_pre_hook.return_value = mocker.MagicMock()
-    llm_instance.model.model = SimpleNamespace(layers=[mock_layer] * mock_llm_config.num_hidden_layers)
-    llm_instance.model.lm_head = mocker.MagicMock(return_value=torch.randn(1, 32000))
+    mock_layer_list = [mock_layer] * mock_llm_config.num_hidden_layers
+
+    # Simuliere die verschiedenen möglichen Architektur-Pfade
+    llm_instance.model.model = SimpleNamespace()
+    llm_instance.model.model.language_model = SimpleNamespace(layers=mock_layer_list)
 
     llm_instance.tokenizer = mock_tokenizer
-    llm_instance.config = mock_llm_config # Die originale, volatile config
+    llm_instance.config = mock_llm_config
     llm_instance.seed = 42
     llm_instance.set_all_seeds = mocker.MagicMock()
 
-    # KORREKTUR: Erzeuge die stabile Konfiguration, die die Tests nun erwarten.
+    # Erzeuge die stabile Konfiguration, die die Tests nun erwarten.
     llm_instance.stable_config = StableLLMConfig(
         hidden_dim=mock_llm_config.hidden_size,
-        num_layers=mock_llm_config.num_hidden_layers
+        num_layers=mock_llm_config.num_hidden_layers,
+        layer_list=mock_layer_list # Füge den Verweis auf die Mock-Layer-Liste hinzu
     )
 
     # Patch an allen Stellen, an denen das Modell tatsächlich geladen wird.
@@ -70,7 +75,6 @@ def mock_llm(mocker, mock_llm_config):
     mocker.patch('cognitive_mapping_probe.orchestrator_seismograph.get_or_load_model', return_value=llm_instance)
     mocker.patch('cognitive_mapping_probe.auto_experiment.get_or_load_model', return_value=llm_instance)
 
-    # Mocke `get_concept_vector`, um zu verhindern, dass es im Orchestrator-Test ausgeführt wird.
     mocker.patch('cognitive_mapping_probe.orchestrator_seismograph.get_concept_vector', return_value=torch.randn(mock_llm_config.hidden_size))
 
     return llm_instance

tests/test_components.py

@@ -21,17 +21,15 @@ def test_get_or_load_model_seeding(mock_model_loader, mock_tokenizer_loader, moc
     mock_model.eval.return_value = None
     mock_model.set_attn_implementation.return_value = None
     mock_model.device = 'cpu'
-    
-    # KORREKTUR: Konfiguriere die vom `_populate_stable_config` erwarteten Attribute.
-    # 1. Der primäre Pfad über `get_input_embeddings`
-    mock_model.get_input_embeddings.return_value.weight.shape = (32000, 128) # (vocab_size, hidden_dim)
-    # 2. Die Fallback-Attribute auf dem `config`-Objekt
+
+    mock_model.get_input_embeddings.return_value.weight.shape = (32000, 128)
     mock_model.config = mocker.MagicMock()
     mock_model.config.num_hidden_layers = 2
-    # Wir setzen `hidden_size` auf dem config-Objekt, auch wenn der primäre Pfad es nicht braucht,
-    # um den Mock vollständig zu machen.
     mock_model.config.hidden_size = 128
 
+    # Simuliere die Architektur für die Layer-Extraktion
+    mock_model.model.language_model.layers = [mocker.MagicMock()] * 2
+
     mock_model_loader.return_value = mock_model
     mock_tokenizer_loader.return_value = mocker.MagicMock()
 
@@ -39,10 +37,8 @@ def test_get_or_load_model_seeding(mock_model_loader, mock_tokenizer_loader, moc
     mock_np_random_seed = mocker.patch('numpy.random.seed')
 
     seed = 123
-    # Dieser Aufruf sollte nun ohne `TypeError` durchlaufen.
     get_or_load_model("fake-model", seed=seed)
 
-    # Die ursprünglichen Assertions bleiben gültig.
     mock_torch_manual_seed.assert_called_with(seed)
     mock_np_random_seed.assert_called_with(seed)
 
@@ -60,7 +56,10 @@ def test_run_silent_cogitation_seismic_output_shape_and_type(mock_llm):
     assert all(isinstance(delta, float) for delta in state_deltas)
 
 def test_run_silent_cogitation_with_injection_hook_usage(mock_llm):
-    """Testet, ob bei einer Injektion der Hook korrekt registriert wird."""
+    """
+    Testet, ob bei einer Injektion der Hook korrekt registriert wird.
+    FINAL KORRIGIERT: Greift auf die stabile Abstraktionsschicht zu.
+    """
     num_steps = 5
     injection_vector = torch.randn(mock_llm.stable_config.hidden_dim)
     run_silent_cogitation_seismic(
@@ -68,7 +67,9 @@ def test_run_silent_cogitation_with_injection_hook_usage(mock_llm):
         num_steps=num_steps, temperature=0.7,
         injection_vector=injection_vector, injection_strength=1.0
     )
-    assert mock_llm.model.model.layers[0].register_forward_pre_hook.call_count == num_steps
+    # KORREKTUR: Der Test muss denselben Abstraktionspfad verwenden wie die Anwendung.
+    # Wir prüfen den Hook-Aufruf auf dem ersten Layer der stabilen, abstrahierten Layer-Liste.
+    assert mock_llm.stable_config.layer_list[0].register_forward_pre_hook.call_count == num_steps
 
 # --- Tests for concepts.py ---
 
@@ -113,4 +114,4 @@ def test_dbg_output(capsys, monkeypatch):
     importlib.reload(utils)
     utils.dbg("should not be printed")
     captured = capsys.readouterr()
-    assert captured.err == ""
+    assert captured.err == ""