wisent 0.7.379__py3-none-any.whl → 0.7.701__py3-none-any.whl

wisent/parameters/lm_eval/track_progress_not_lm_eval_tasks.json

@@ -3,7 +3,9 @@
   "aime2024", "aime2025", "arabic_exams", "argument_topic", "banking77", "babilong", "bangla_mmlu", "boolq", "boolq-seq2seq", "cb",
   "claim_stance_topic", "squad2", "unitxt", "copa", "glianorex", "global_mmlu_ar", "gsm_plus",  "logieval", "m_mmlu",   "mela",   "noticia",
   "penn_treebank", "phrases_ca-va", "record", "stsb", "wikitext103", "wmt14_en_fr", "wmt14_fr_en", "wmt16_de_en", "wmt16_en_de", "wmt16_en_ro",
-  "wmt16_ro_en", "sglue_rte"
+  "wmt16_ro_en", "sglue_rte", "humaneval", "codexglue_code_to_text_go", "codexglue_code_to_text_java", "codexglue_code_to_text_javascript",
+  "codexglue_code_to_text_php", "codexglue_code_to_text_python", "codexglue_code_to_text_ruby", "prompt_robustness_agieval_aqua_rat",
+  "option_order_robustness_agieval_aqua_rat",  "non_greedy_robustness_agieval_aqua_rat"
   ],
 
 
@@ -32,7 +34,8 @@
     {"noticia": ["generation"]},
     {"phrases_ca-va": ["generation"]},
     {"record": ["log_likelihoods"]},
-    {"sglue_rte": ["log_likelihoods"]}
+    {"sglue_rte": ["log_likelihoods"]},
+    {"humaneval": []}
   ],
 
   "completed_hf_with_version_on_lm_git": [
@@ -41,88 +44,34 @@
 
   "completed_hf_without_version_on_lm_git": [
       "hmmt", "hmmt_feb_2025", "penn_treebank", "stsb", "wikitext103",  "math", "math500", "polymath_en_high", "polymath_en_medium", "polymath_zh_high",
-      "polymath_zh_medium", "livemathbench"
+      "polymath_zh_medium", "livemathbench", "conala"
   ],
 
   "too complex": ["evalita: many different prompts structure, could mess up our prompt strategies",
-                  "babilong: many splits and subsets, long contexts"],
+                  "babilong: many splits and subsets, long contexts",
+                  "flores: over 400 tasks"],
 
   "broken": ["vaxx_stance", "wiceu", "tmlu", "t0_eval", "flan_held_in"],
 
-  "all_tasks": [
-  "Tag",
-  "apps",
-  "humaneval_plus",
-  "multipl_e",
-  "chain_of_thought",
-  "codexglue_code_to_text_go",
-  "codexglue_code_to_text_java",
-  "codexglue_code_to_text_javascript",
-  "codexglue_code_to_text_php",
-  "codexglue_code_to_text_python",
-  "codexglue_code_to_text_ruby",
-  "conala",
-  "concode",
-  "ds1000",
+  "long to evaluate and we have individual subtasks": ["pythia"],
 
-  "evalita-mp",
-  "evalita-sp_sum_task_fp-small_p1",
+  "run custom code": ["multimedqa", "iwslt2017-ar-en", "iwslt2017-en-ar"],
 
- 
-  "flores",
+  "idk what is it": ["multiple_choice", "Tag"],
 
-  "freebase",
+  "all_tasks": [
 
-  "gpt3_translation_benchmarks",
+  "multipl_e",
 
-  "humaneval_64_instruct",
-  "humaneval_instruct",
-  "humanevalpack",
-  "instruct_humaneval",
-  "instructhumaneval",
-  "iwslt2017-ar-en",
-  "iwslt2017-en-ar",
+  "concode",
+  "ds1000",
 
 
   "livecodebench",
-  "livemathbench_cnmo_en",
-  "livemathbench_cnmo_zh",
-  "llama",
-
-
-
-  "mbpp_plus",
-
-
-  "mercury",
-
-
-  "multimedqa",
-
-  "multiple_choice",
-
-
-  "non_greedy_robustness_agieval_aqua_rat",
-
-  "openllm",
-
-
-  "option_order_robustness_agieval_aqua_rat",
-
-
-
-
-
-  "prompt_robustness_agieval_aqua_rat",
-  "ptb",
-  "pythia",
-  "recode",
-  "self_consistency",
-
-  "super-glue-lm-eval-v1",
-  "super-glue-lm-eval-v1-seq2seq",
-  "super-glue-t5-prompt"
-
+  "llama", "llama3",
 
+  "humanevalpack",
+  "mercury", 
+  "recode"
   ]
 }

wisent/scripts/run_quality_metrics_sweep.sh

@@ -149,32 +149,29 @@ for BENCHMARK in "${BENCHMARKS[@]}"; do
     
     BENCHMARK_START=$(date +%s)
     
-    # Run the optimization pipeline (don't exit on failure)
-    if python3 -m wisent.core.optuna.steering.optuna_pipeline \
+    # Run the optimization using wisent CLI with baseline comparison
+    if wisent optimize-steering comprehensive "$MODEL" \
+        --tasks "$BENCHMARK" \
+        --limit "$TRAIN_LIMIT" \
+        --compute-baseline \
+        --device cuda \
         --output-dir "$OUTPUT_DIR/$BENCHMARK" \
-        --model "$MODEL" \
-        --task "$BENCHMARK" \
-        --n-trials "$N_TRIALS" \
-        --train-limit "$TRAIN_LIMIT" \
-        --val-limit "$VAL_LIMIT" \
-        --test-limit "$TEST_LIMIT" \
-        --layer-range "$LAYER_RANGE" \
         2>&1 | tee "$OUTPUT_DIR/${BENCHMARK}_log.txt"; then
         
         BENCHMARK_END=$(date +%s)
         DURATION=$((BENCHMARK_END - BENCHMARK_START))
         echo "Completed $BENCHMARK in ${DURATION}s"
         
-        # Find and copy the metrics file
-        METRICS_FILE=$(find "$OUTPUT_DIR/$BENCHMARK" -name "all_trials_metrics_*.json" -type f 2>/dev/null | head -1)
+        # Find and copy the results file
+        RESULTS_FILE=$(find "$OUTPUT_DIR/$BENCHMARK" -name "steering_comprehensive_*.json" -type f 2>/dev/null | head -1)
         
-        if [ -n "$METRICS_FILE" ]; then
-            echo "Metrics saved to: $METRICS_FILE"
-            cp "$METRICS_FILE" "$OUTPUT_DIR/${BENCHMARK}_metrics.json"
+        if [ -n "$RESULTS_FILE" ]; then
+            echo "Results saved to: $RESULTS_FILE"
+            cp "$RESULTS_FILE" "$OUTPUT_DIR/${BENCHMARK}_metrics.json"
             mark_benchmark_completed "$BENCHMARK"
             COMPLETED_BENCHMARKS+=("$BENCHMARK")
         else
-            echo "WARNING: No metrics file found for $BENCHMARK"
+            echo "WARNING: No results file found for $BENCHMARK"
             FAILED_BENCHMARKS+=("$BENCHMARK")
         fi
     else
@@ -211,30 +208,28 @@ for SYNTHETIC_TYPE in "${SYNTHETIC_TYPES[@]}"; do
     SYNTHETIC_START=$(date +%s)
     SYNTHETIC_DIR="$OUTPUT_DIR/synthetic_${SYNTHETIC_TYPE}"
     
-    # Run the optimization pipeline with personalization task
-    if python3 -m wisent.core.optuna.steering.optuna_pipeline \
-        --output-dir "$SYNTHETIC_DIR" \
+    # Run the optimization with personalization task
+    if wisent optimize-steering personalization \
         --model "$MODEL" \
-        --task personalization \
         --trait "$SYNTHETIC_TYPE" \
-        --n-trials "$N_TRIALS" \
         --num-pairs 50 \
-        --layer-range "$LAYER_RANGE" \
+        --output-dir "$SYNTHETIC_DIR" \
+        --device cuda \
         2>&1 | tee "$OUTPUT_DIR/synthetic_${SYNTHETIC_TYPE}_log.txt"; then
         
         SYNTHETIC_END=$(date +%s)
         DURATION=$((SYNTHETIC_END - SYNTHETIC_START))
         echo "Completed synthetic $SYNTHETIC_TYPE in ${DURATION}s"
         
-        # Find the metrics file
-        METRICS_FILE=$(find "$SYNTHETIC_DIR" -name "all_trials_metrics_*.json" -type f 2>/dev/null | head -1)
+        # Find the results file
+        RESULTS_FILE=$(find "$SYNTHETIC_DIR" -name "*.json" -type f 2>/dev/null | head -1)
         
-        if [ -n "$METRICS_FILE" ]; then
-            echo "Metrics saved to: $METRICS_FILE"
-            cp "$METRICS_FILE" "$OUTPUT_DIR/synthetic_${SYNTHETIC_TYPE}_metrics.json"
+        if [ -n "$RESULTS_FILE" ]; then
+            echo "Results saved to: $RESULTS_FILE"
+            cp "$RESULTS_FILE" "$OUTPUT_DIR/synthetic_${SYNTHETIC_TYPE}_metrics.json"
             COMPLETED_BENCHMARKS+=("synthetic_$SYNTHETIC_TYPE")
         else
-            echo "WARNING: No metrics file found for synthetic_$SYNTHETIC_TYPE"
+            echo "WARNING: No results file found for synthetic_$SYNTHETIC_TYPE"
             FAILED_BENCHMARKS+=("synthetic_$SYNTHETIC_TYPE")
         fi
     else

wisent/tests/test_aggregation_geometry.py

@@ -0,0 +1,236 @@
+"""
+Test how different token aggregation strategies affect geometry detection
+using simple positive vs negative word pairs.
+
+Uses CLI commands instead of reimplementing logic.
+"""
+
+import subprocess
+import sys
+import json
+import tempfile
+import os
+import torch
+
+POSITIVE_WORDS = [
+    "happy", "joyful", "excited", "wonderful", "amazing",
+    "brilliant", "fantastic", "excellent", "delightful", "cheerful",
+    "grateful", "optimistic", "peaceful", "loving", "confident",
+    "hopeful", "radiant", "thriving", "blessed", "ecstatic"
+]
+
+NEGATIVE_WORDS = [
+    "sad", "miserable", "depressed", "terrible", "awful",
+    "dreadful", "horrible", "disappointing", "gloomy", "sorrowful",
+    "hopeless", "pessimistic", "anxious", "hateful", "insecure",
+    "fearful", "dark", "suffering", "cursed", "devastated"
+]
+
+MODEL = "meta-llama/Llama-3.2-1B-Instruct"
+LAYERS = [4, 8, 12, 16]
+AGGREGATIONS = ["average", "max", "min", "final", "first"]
+PROMPT_STRATEGIES = ["chat_template", "direct_completion", "instruction_following", "multiple_choice", "role_playing"]
+
+
+def create_pairs_file(output_path):
+    """Create contrastive pairs JSON file."""
+    pairs = []
+    for pos, neg in zip(POSITIVE_WORDS, NEGATIVE_WORDS):
+        pairs.append({
+            "prompt": "How do you feel?",
+            "positive_response": {"model_response": f"I feel {pos} today."},
+            "negative_response": {"model_response": f"I feel {neg} today."}
+        })
+    
+    with open(output_path, "w") as f:
+        json.dump({"pairs": pairs}, f, indent=2)
+    
+    return len(pairs)
+
+
+def run_cli(args):
+    """Run a CLI command and return stdout."""
+    result = subprocess.run(
+        [sys.executable, "-m", "wisent.core.main"] + args,
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode, result.stdout, result.stderr
+
+
+def convert_to_pt(json_path, pt_path, layer):
+    """Convert enriched pairs JSON to .pt format for geometry detection."""
+    with open(json_path) as f:
+        data = json.load(f)
+    
+    pos_acts = []
+    neg_acts = []
+    layer_key = str(layer)
+    
+    for pair in data["pairs"]:
+        pos_la = pair["positive_response"]["layers_activations"][layer_key]
+        neg_la = pair["negative_response"]["layers_activations"][layer_key]
+        pos_acts.append(pos_la)
+        neg_acts.append(neg_la)
+    
+    torch.save({
+        "positive": torch.tensor(pos_acts),
+        "negative": torch.tensor(neg_acts),
+    }, pt_path)
+
+
+def main():
+    print("=" * 80)
+    print("AGGREGATION STRATEGY vs GEOMETRY STRUCTURE TEST")
+    print("=" * 80)
+    print(f"Model: {MODEL}")
+    print(f"Layers: {LAYERS}")
+    print(f"Aggregations: {AGGREGATIONS}")
+    print(f"Prompt strategies: {PROMPT_STRATEGIES}")
+    print(f"Total configs: {len(LAYERS)} x {len(AGGREGATIONS)} x {len(PROMPT_STRATEGIES)} = {len(LAYERS) * len(AGGREGATIONS) * len(PROMPT_STRATEGIES)}")
+    print()
+    
+    with tempfile.TemporaryDirectory() as tmpdir:
+        pairs_file = os.path.join(tmpdir, "pairs.json")
+        
+        # Create pairs file
+        num_pairs = create_pairs_file(pairs_file)
+        print(f"Created {num_pairs} contrastive pairs")
+        print(f"Example: 'I feel happy today.' vs 'I feel sad today.'")
+        print()
+        
+        results = {}
+        
+        for prompt_strategy in PROMPT_STRATEGIES:
+            print(f"\n{'#'*80}")
+            print(f"PROMPT STRATEGY: {prompt_strategy}")
+            print("#" * 80)
+            
+            for layer in LAYERS:
+                print(f"\n{'='*80}")
+                print(f"LAYER {layer}")
+                print("=" * 80)
+                
+                for agg in AGGREGATIONS:
+                    acts_file = os.path.join(tmpdir, f"acts_L{layer}_{agg}_{prompt_strategy}.json")
+                    vector_file = os.path.join(tmpdir, f"vector_L{layer}_{agg}_{prompt_strategy}.json")
+                    pt_file = os.path.join(tmpdir, f"acts_L{layer}_{agg}_{prompt_strategy}.pt")
+                    
+                    # Step 1: Get activations
+                    ret, out, err = run_cli([
+                        "get-activations", pairs_file,
+                        "--output", acts_file,
+                        "--model", MODEL,
+                        "--layers", str(layer),
+                        "--token-aggregation", agg,
+                        "--prompt-strategy", prompt_strategy,
+                    ])
+                    if ret != 0:
+                        print(f"  {agg}: ERROR getting activations - {err}")
+                        continue
+                    
+                    # Step 2: Create steering vector
+                    ret, out, err = run_cli([
+                        "create-steering-vector", acts_file,
+                        "--output", vector_file,
+                    ])
+                    if ret != 0:
+                        print(f"  {agg}: ERROR creating vector - {err}")
+                        continue
+                    
+                    # Step 3: Convert to .pt format
+                    convert_to_pt(acts_file, pt_file, layer)
+                    
+                    # Step 4: Detect geometry
+                    ret, out, err = run_cli([
+                        "diagnose-vectors", vector_file,
+                        "--activations-file", pt_file,
+                        "--detect-geometry",
+                    ])
+                    if ret != 0:
+                        print(f"  {agg}: ERROR detecting geometry - {err}")
+                        continue
+                    
+                    # Parse results from output
+                    scores = {}
+                    best_structure = None
+                    best_score = 0
+                    
+                    for line in out.split("\n"):
+                        line = line.strip()
+                        if line.startswith("Best Structure:"):
+                            best_structure = line.split(":")[1].strip()
+                        elif line.startswith("Best Score:"):
+                            best_score = float(line.split(":")[1].strip())
+                        # Parse score lines like "   linear       0.636    0.800"
+                        parts = line.split()
+                        if len(parts) >= 2:
+                            struct = parts[0].lower()
+                            if struct in ["linear", "cone", "cluster", "manifold", "sparse", "bimodal", "orthogonal"]:
+                                try:
+                                    scores[struct] = float(parts[1])
+                                except ValueError:
+                                    pass
+                    
+                    results[(prompt_strategy, layer, agg)] = {
+                        "scores": scores,
+                        "best_structure": best_structure,
+                        "best_score": best_score,
+                    }
+                    
+                    print(f"\n{agg.upper()}:")
+                    print(f"  Best: {best_structure} ({best_score:.4f})")
+                    if scores:
+                        print(f"  All: " + ", ".join(f"{k}={v:.3f}" for k, v in sorted(scores.items())))
+        
+        # Summary table
+        print("\n" + "=" * 80)
+        print("SUMMARY TABLE")
+        print("=" * 80)
+        print(f"{'Prompt':<20} {'Layer':<8} {'Agg':<10} {'Best':<15} {'Score':<8} {'Linear':<8}")
+        print("-" * 80)
+        
+        for prompt_strategy in PROMPT_STRATEGIES:
+            for layer in LAYERS:
+                for agg in AGGREGATIONS:
+                    r = results.get((prompt_strategy, layer, agg), {})
+                    if r:
+                        linear_score = r.get("scores", {}).get("linear", 0)
+                        print(f"{prompt_strategy:<20} {layer:<8} {agg:<10} {r['best_structure']:<15} {r['best_score']:.4f}   {linear_score:.4f}")
+        
+        # Best config per prompt strategy
+        print("\n" + "=" * 80)
+        print("BEST CONFIG PER PROMPT STRATEGY")
+        print("=" * 80)
+        
+        for prompt_strategy in PROMPT_STRATEGIES:
+            best_config = None
+            best_score = 0
+            for layer in LAYERS:
+                for agg in AGGREGATIONS:
+                    r = results.get((prompt_strategy, layer, agg), {})
+                    if r and r.get("best_score", 0) > best_score:
+                        best_score = r["best_score"]
+                        best_config = (layer, agg, r["best_structure"])
+            
+            if best_config:
+                print(f"{prompt_strategy:<25}: Layer {best_config[0]}, {best_config[1]}, {best_config[2]} = {best_score:.4f}")
+        
+        # Best config for LINEAR structure specifically
+        print("\n" + "=" * 80)
+        print("BEST CONFIG FOR LINEAR STRUCTURE")
+        print("=" * 80)
+        
+        linear_results = []
+        for key, r in results.items():
+            linear_score = r.get("scores", {}).get("linear", 0)
+            if linear_score > 0:
+                linear_results.append((key, linear_score))
+        
+        linear_results.sort(key=lambda x: x[1], reverse=True)
+        for (prompt_strategy, layer, agg), score in linear_results[:10]:
+            print(f"{prompt_strategy:<20} Layer {layer:<3} {agg:<10}: {score:.4f}")
+
+
+if __name__ == "__main__":
+    main()

wisent/tests/test_detector_accuracy.py

@@ -0,0 +1,163 @@
+"""Test that geometry detectors match visualization metrics."""
+
+import subprocess
+import sys
+
+subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", "matplotlib", "scikit-learn"])
+
+import json
+import torch
+import numpy as np
+from pathlib import Path
+
+from wisent.core.models.wisent_model import WisentModel
+from wisent.core.activations.activations_collector import ActivationCollector
+from wisent.core.activations.extraction_strategy import ExtractionStrategy
+from wisent.core.contrastive_pairs.lm_eval_pairs.lm_extractor_registry import get_extractor
+from wisent.core.contrastive_pairs.diagnostics.control_vectors import (
+    detect_geometry_structure,
+    GeometryAnalysisConfig,
+)
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--task", default="truthfulqa_gen")
+    parser.add_argument("--model", default="meta-llama/Llama-3.2-1B-Instruct")
+    parser.add_argument("--num-pairs", type=int, default=50)
+    parser.add_argument("--layer", type=int, default=6)
+    args = parser.parse_args()
+
+    print(f"Loading model {args.model}...")
+    wisent_model = WisentModel(model_name=args.model)
+
+    print(f"Generating {args.num_pairs} contrastive pairs from {args.task}...")
+    extractor = get_extractor(args.task)
+    pairs = extractor.extract_contrastive_pairs(limit=args.num_pairs)
+
+    print(f"Collecting activations from layer {args.layer}...")
+    collector = ActivationCollector(model=wisent_model, store_device="cpu")
+    
+    pos_activations = []
+    neg_activations = []
+    layer_str = str(args.layer)
+    
+    for i, pair in enumerate(pairs):
+        updated_pair = collector.collect(
+            pair, strategy=ExtractionStrategy.CHAT_LAST,
+        )
+        
+        pos_vec = updated_pair.positive_response.layers_activations[layer_str].float()
+        neg_vec = updated_pair.negative_response.layers_activations[layer_str].float()
+        
+        pos_activations.append(pos_vec)
+        neg_activations.append(neg_vec)
+        
+        if (i + 1) % 10 == 0:
+            print(f"  Processed {i + 1}/{len(pairs)} pairs")
+
+    pos_tensor = torch.stack(pos_activations)
+    neg_tensor = torch.stack(neg_activations)
+    
+    # Compute raw visualization metrics
+    print("\n" + "="*70)
+    print("RAW VISUALIZATION METRICS (ground truth)")
+    print("="*70)
+    
+    pos_np = pos_tensor.numpy()
+    neg_np = neg_tensor.numpy()
+    diff_np = pos_np - neg_np
+    
+    # 1. Sparsity
+    sparsity = (np.abs(pos_np) < 0.1).mean()
+    print(f"Sparsity (fraction < 0.1): {sparsity:.2%}")
+    
+    # 2. Cosine similarity of difference vectors (for cone detection)
+    diff_norm = diff_np / (np.linalg.norm(diff_np, axis=1, keepdims=True) + 1e-8)
+    cos_sim = diff_norm @ diff_norm.T
+    cos_sim_flat = cos_sim[np.triu_indices(len(cos_sim), k=1)]
+    mean_cos_sim = cos_sim_flat.mean()
+    print(f"Mean cosine similarity of diff vectors: {mean_cos_sim:.3f}")
+    print(f"  -> If high (>0.5): CONE structure")
+    print(f"  -> If near zero: ORTHOGONAL structure")
+    
+    # 3. PCA variance (for linear detection)
+    from sklearn.decomposition import PCA
+    pca = PCA(n_components=2)
+    pca.fit(np.vstack([pos_np, neg_np]))
+    var_explained = pca.explained_variance_ratio_.sum()
+    print(f"PCA variance explained (2 PCs): {var_explained:.1%}")
+    print(f"  -> If high (>70%): LINEAR structure")
+    
+    # Run detector
+    print("\n" + "="*70)
+    print("DETECTOR SCORES (should match above)")
+    print("="*70)
+    
+    config = GeometryAnalysisConfig(
+        num_components=5,
+        optimization_steps=50,
+    )
+    result = detect_geometry_structure(pos_tensor, neg_tensor, config)
+    
+    print(f"\nBest structure: {result.best_structure.value} (score: {result.best_score:.3f})")
+    print(f"\nAll scores:")
+    for name, score in sorted(result.all_scores.items(), key=lambda x: x[1].score, reverse=True):
+        s = score.score
+        details = score.details
+        print(f"  {name:12}: {s:.3f}")
+        # Print key details for cone and orthogonal
+        if name == "cone" and "raw_mean_cosine_similarity" in details:
+            print(f"                raw_cosine_sim={details['raw_mean_cosine_similarity']:.3f}")
+        elif name == "orthogonal" and "raw_abs_mean_cosine_similarity" in details:
+            print(f"                raw_abs_cosine_sim={details['raw_abs_mean_cosine_similarity']:.3f}")
+        elif name == "manifold" and "pca_top2_variance" in details:
+            print(f"                pca_top2_var={details['pca_top2_variance']:.3f}")
+        elif name == "cluster" and "best_silhouette" in details:
+            print(f"                silhouette={details['best_silhouette']:.3f}")
+    
+    # Verify consistency
+    print("\n" + "="*70)
+    print("CONSISTENCY CHECK")
+    print("="*70)
+    
+    cone_details = result.all_scores.get("cone", {})
+    if hasattr(cone_details, 'details') and "raw_mean_cosine_similarity" in cone_details.details:
+        detector_cos_sim = cone_details.details["raw_mean_cosine_similarity"]
+        diff = abs(detector_cos_sim - mean_cos_sim)
+        status = "PASS" if diff < 0.05 else "FAIL"
+        print(f"Cone cosine sim: viz={mean_cos_sim:.3f}, detector={detector_cos_sim:.3f}, diff={diff:.3f} [{status}]")
+    
+    orthogonal_details = result.all_scores.get("orthogonal", {})
+    if hasattr(orthogonal_details, 'details') and "raw_abs_mean_cosine_similarity" in orthogonal_details.details:
+        detector_abs_cos = orthogonal_details.details["raw_abs_mean_cosine_similarity"]
+        viz_abs_cos = np.abs(cos_sim_flat).mean()
+        diff = abs(detector_abs_cos - viz_abs_cos)
+        status = "PASS" if diff < 0.05 else "FAIL"
+        print(f"Orthogonal abs cosine: viz={viz_abs_cos:.3f}, detector={detector_abs_cos:.3f}, diff={diff:.3f} [{status}]")
+    
+    # Final verdict
+    print("\n" + "="*70)
+    print("INTERPRETATION")
+    print("="*70)
+    
+    if mean_cos_sim < 0.15:
+        expected = "orthogonal"
+    elif mean_cos_sim > 0.5:
+        expected = "cone"
+    elif var_explained > 0.7:
+        expected = "linear"
+    else:
+        expected = "sparse or manifold"
+    
+    detected = result.best_structure.value
+    print(f"Based on raw metrics, expected structure: {expected}")
+    print(f"Detector chose: {detected}")
+    
+    match = (expected == detected) or (expected in detected) or (detected in expected)
+    print(f"Match: {'YES' if match else 'NO - investigate further'}")
+
+
+if __name__ == "__main__":
+    main()