fix

cognitive_mapping_probe/concepts.py

@@ -18,18 +18,8 @@ def _get_last_token_hidden_state(llm: LLM, prompt: str) -> torch.Tensor:
         outputs = llm.model(**inputs, output_hidden_states=True)
     last_hidden_state = outputs.hidden_states[-1][0, -1, :].cpu()
 
-    # KORREKTUR: Anstatt auf `llm.config.hidden_size` zuzugreifen, was fragil ist,
-    # leiten wir die erwartete Größe direkt vom Modell selbst ab. Dies ist robust
-    # gegenüber API-Änderungen in `transformers`.
-    try:
-        # Versuche, die Größe über die Einbettungsschicht zu erhalten, was am stabilsten ist.
-        expected_size = llm.model.get_input_embeddings().weight.shape[1]
-    except AttributeError:
-        # Fallback, falls die Methode nicht existiert, auf den wahrscheinlichen Namen.
-        # Gemma3Config hat 'hidden_size', aber andere könnten es anders nennen.
-        expected_size = getattr(llm.config, 'hidden_size', getattr(llm.config, 'd_model', 0))
-        assert expected_size > 0, "Could not determine hidden size from model config."
-
+    # KORREKTUR: Greife auf die stabile, abstrahierte Konfiguration zu.
+    expected_size = llm.stable_config.hidden_dim
 
     assert last_hidden_state.shape == (expected_size,), \
         f"Hidden state shape mismatch. Expected {(expected_size,)}, got {last_hidden_state.shape}"
@@ -44,7 +34,7 @@ def get_concept_vector(llm: LLM, concept: str, baseline_words: List[str] = BASEL
     target_hs = _get_last_token_hidden_state(llm, prompt_template.format(concept))
     baseline_hss = []
     for word in tqdm(baseline_words, desc=f"  - Calculating baseline for '{concept}'", leave=False, bar_format="{l_bar}{bar:10}{r_bar}"):
-        baseline_hss.append(_get_last_token_hidden_state(llm, prompt_template.format(word))) # Korrigiert: Verwende 'word', nicht 'concept'
+        baseline_hss.append(_get_last_token_hidden_state(llm, prompt_template.format(word)))
     assert all(hs.shape == target_hs.shape for hs in baseline_hss)
     mean_baseline_hs = torch.stack(baseline_hss).mean(dim=0)
     dbg(f"  - Mean baseline vector computed with norm {torch.norm(mean_baseline_hs).item():.2f}")

cognitive_mapping_probe/llm_iface.py

@@ -4,12 +4,22 @@ import random
 import numpy as np
 from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed
 from typing import Optional
+from dataclasses import dataclass
 
 from .utils import dbg
 
 # Ensure deterministic CuBLAS operations for reproducibility on GPU
 os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
 
+@dataclass
+class StableLLMConfig:
+    """
+    Eine stabile, interne Abstraktionsschicht für Modell-Konfigurationen.
+    Macht unseren Code unabhängig von den sich ändernden Attributnamen in `transformers`.
+    """
+    hidden_dim: int
+    num_layers: int
+
 class LLM:
     """
     Eine robuste, bereinigte Schnittstelle zum Laden und Interagieren mit einem Sprachmodell.
@@ -39,9 +49,33 @@ class LLM:
             print(f"[WARN] Could not set 'eager' attention: {e}.", flush=True)
 
         self.model.eval()
-        self.config = self.model.config
+        self.config = self.model.config # Behalte den Zugriff auf die Originalkonfiguration
+
+        # --- NEU: Befülle die stabile Konfigurations-Abstraktion ---
+        self.stable_config = self._populate_stable_config()
+
         print(f"[INFO] Model '{model_id}' loaded on device: {self.model.device}", flush=True)
 
+    def _populate_stable_config(self) -> StableLLMConfig:
+        """
+        Liest die volatile `transformers`-Konfiguration aus und befüllt unsere stabile Datenklasse.
+        """
+        # Robuste Methode für hidden_dim
+        try:
+            hidden_dim = self.model.get_input_embeddings().weight.shape[1]
+        except AttributeError:
+            hidden_dim = getattr(self.config, 'hidden_size', getattr(self.config, 'd_model', 0))
+
+        # Robuste Methode für num_layers
+        num_layers = getattr(self.config, 'num_hidden_layers', getattr(self.config, 'num_layers', 0))
+
+        # Assertions zur Sicherstellung der wissenschaftlichen Validität
+        assert hidden_dim > 0, "Could not determine hidden dimension from model config."
+        assert num_layers > 0, "Could not determine number of layers from model config."
+
+        dbg(f"Populated stable config: hidden_dim={hidden_dim}, num_layers={num_layers}")
+        return StableLLMConfig(hidden_dim=hidden_dim, num_layers=num_layers)
+
     def set_all_seeds(self, seed: int):
         """Setzt alle relevanten Seeds für maximale Reproduzierbarkeit."""
         os.environ['PYTHONHASHSEED'] = str(seed)

cognitive_mapping_probe/resonance_seismograph.py

@@ -36,25 +36,38 @@ def run_silent_cogitation_seismic(
     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:
-            injection_layer = llm.config.num_hidden_layers // 2
+            # 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]
-            injection_3d = injection_vector.unsqueeze(0).unsqueeze(0)
+            # 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)
             return (modified_hidden_states,) + layer_input[1:]
 
     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)
 
-        probabilities = torch.nn.functional.softmax(next_token_logits / temperature, dim=-1)
-        next_token_id = torch.multinomial(probabilities, num_samples=1)
+        # 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)
+
+        if temperature > 0.0:
+            next_token_id = torch.multinomial(probabilities, num_samples=1)
+        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]
                 hook_handle = target_layer.register_forward_pre_hook(injection_hook)
 

tests/conftest.py

@@ -1,11 +1,12 @@
 import pytest
 import torch
 from types import SimpleNamespace
-from cognitive_mapping_probe.llm_iface import LLM
+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,
@@ -16,16 +17,14 @@ def mock_llm_config():
 def mock_llm(mocker, mock_llm_config):
     """
     Erstellt einen robusten "Mock-LLM" für Unit-Tests.
-    FINAL KORRIGIERT: Die Patch-Anweisungen sind nun korrekt auf die tatsächlichen
-    Import-Pfade in den zu testenden Modulen ausgerichtet.
+    FINAL KORRIGIERT: Simuliert nun auch die `stable_config`-Abstraktionsschicht.
     """
     mock_tokenizer = mocker.MagicMock()
     mock_tokenizer.eos_token_id = 1
     mock_tokenizer.decode.return_value = "mocked text"
 
-    # Definiere eine stabile Mock-Funktion für die Eingabe-Embeddings
     mock_embedding_layer = mocker.MagicMock()
-    mock_embedding_layer.weight.shape = (32000, mock_llm_config.hidden_size) # (vocab_size, hidden_size)
+    mock_embedding_layer.weight.shape = (32000, mock_llm_config.hidden_size)
 
     def mock_model_forward(*args, **kwargs):
         batch_size = 1
@@ -42,13 +41,12 @@ def mock_llm(mocker, mock_llm_config):
         }
         return SimpleNamespace(**mock_outputs)
 
-    llm_instance = LLM.__new__(LLM) # Erzeuge Instanz ohne __init__ aufzurufen
+    llm_instance = LLM.__new__(LLM)
 
     llm_instance.model = mocker.MagicMock(side_effect=mock_model_forward)
     llm_instance.model.config = mock_llm_config
     llm_instance.model.device = 'cpu'
     llm_instance.model.dtype = torch.float32
-    # Füge die gemockte Embedding-Funktion hinzu, um den Test in `concepts.py` zu bestehen
     llm_instance.model.get_input_embeddings.return_value = mock_embedding_layer
 
     mock_layer = mocker.MagicMock()
@@ -57,18 +55,22 @@ def mock_llm(mocker, mock_llm_config):
     llm_instance.model.lm_head = mocker.MagicMock(return_value=torch.randn(1, 32000))
 
     llm_instance.tokenizer = mock_tokenizer
-    llm_instance.config = mock_llm_config # Wichtig, da `concepts.py` darauf zugreift
+    llm_instance.config = mock_llm_config # Die originale, volatile config
     llm_instance.seed = 42
     llm_instance.set_all_seeds = mocker.MagicMock()
 
+    # KORREKTUR: 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
+    )
+
     # Patch an allen Stellen, an denen das Modell tatsächlich geladen wird.
-    # Dies stellt sicher, dass kein Test versucht, ein echtes Modell herunterzuladen.
     mocker.patch('cognitive_mapping_probe.llm_iface.get_or_load_model', return_value=llm_instance)
     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,
-    # da wir es in `test_components.py` separat testen.
-    mocker.patch('cognitive_mapping_probe.concepts.get_concept_vector', return_value=torch.randn(mock_llm_config.hidden_size))
+    # 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