The Void

::GALACTIC REGISTRY ANOMALY REPORT::
ID: epsilon-5
SYSTEM: Rigel
PLANET: Aetheria
SECTOR: Sector 007
PLANETARY_CLASS: Artificial
DOMINANT_FAUNA: Magma-Rock Lizard
DOMINANT_FLORA: Ironwood Tree
NATIVE_SENTIENT: Plantoids
GOVERNMENT: Feudal
TECH_LEVEL: Bio-Tech
PRIMARY_EXPORT: Medical Isotopes
...

logit_i = activations[i] @ w + b
y_i     = 1 if sigmoid(logit_i) >= 0.5 else 0

######################### DO NOT CHANGE THIS CELL ##########################

FINAL_EVALUATION_MODE = False  # We will set this flag to True during grading.

######################### DO NOT CHANGE THIS CELL ##########################

import json
import os
import sys
import numpy as np
import torch
from typing import List, Tuple, Dict, Any

RANDOM_SEED = 2026
os.environ["PYTHONHASHSEED"] = str(RANDOM_SEED)
np.random.seed(RANDOM_SEED)
torch.manual_seed(RANDOM_SEED)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False

if not FINAL_EVALUATION_MODE:
    DATA_PATH = os.path.join("data", "val_release.jsonl")
    GROUND_TRUTH_PATH = os.path.join("data", "val_release_ground_truth.json")
    ACTIVATION_CACHE_PATH = os.path.join("data", "val_release_activation_cache.npz")
    print(f"Stored activations: {ACTIVATION_CACHE_PATH}")

######################### DO NOT CHANGE THIS CELL ##########################

if not FINAL_EVALUATION_MODE:
    with open(DATA_PATH) as f:
        val_rows = [json.loads(line) for line in f]

    with open(GROUND_TRUTH_PATH) as f:
        GROUND_TRUTH = [tuple(pair) for pair in json.load(f)["trigger_pairs"]]

    print(f"Loaded {len(val_rows)} reports")
    print(f"Loaded {len(GROUND_TRUTH)} true trigger pairs for local validation")

######################### DO NOT CHANGE THIS CELL #########################

if not FINAL_EVALUATION_MODE:
    if not os.path.isfile(ACTIVATION_CACHE_PATH):
        raise FileNotFoundError(
            f"Missing activations file: {ACTIVATION_CACHE_PATH}\n"
            "Place it in the data/ folder before running this notebook."
        )

    cache = np.load(ACTIVATION_CACHE_PATH)
    required_keys = {"row_ids", "bottleneck_post", "out_w", "out_b"}
    if set(cache.files) != required_keys:
        raise ValueError(
            f"The activation cache must contain exactly {sorted(required_keys)}, got {sorted(cache.files)}."
        )

    row_ids = cache["row_ids"].astype(int)
    val_activations = cache["bottleneck_post"].astype(np.float32)
    val_w = cache["out_w"].astype(np.float32).reshape(-1)
    val_b = float(cache["out_b"])

    expected_row_ids = np.array([int(row["id"]) for row in val_rows], dtype=int)
    if row_ids.shape != expected_row_ids.shape:
        raise ValueError(
            f"The activation cache contains {row_ids.shape[0]} row identifiers, "
            f"but the dataset has {expected_row_ids.shape[0]} rows."
        )
    if not np.array_equal(row_ids, expected_row_ids):
        raise ValueError(
            "The rows in the activation cache do not match val_release.jsonl. "
            "The cache must be saved in exactly the order of the dataset."
        )

    print(f"Loaded the activation cache with keys: {sorted(cache.files)}")
    print(f"The activations have shape: {val_activations.shape}")
    print(f"Output layer dimensions: val_w={val_w.shape}, val_b=scalar")

######################### DO NOT CHANGE THIS CELL #########################

if not FINAL_EVALUATION_MODE:
# Let us analyse one example
    example = val_rows[0]
    print("\n=== Example Report ===")
    print(f"ID: {example.get('id', 'N/A')}")
    print(f"\nText (first 300 characters):\n{example['sentence'][:300]}...")
    print("\nConcepts:")
    for concept, value in example["concepts"].items():
        print(f"  {concept}: {value}")
    print(val_activations[0])

######################### DO NOT CHANGE THIS CELL ##########################

def compute_score(
    predicted_pairs: List[Tuple[str, str]],
    ground_truth_pairs: List[Tuple[str, str]],
) -> Dict[str, Any]:
    if len(predicted_pairs) != 5:
        return {
            "score": 0
        }
    pred_set = set(predicted_pairs)
    truth_set = set(ground_truth_pairs)
    correct_pairs = sorted(pred_set & truth_set)
    missed_pairs = sorted(truth_set - pred_set)
    extra_pairs = sorted(pred_set - truth_set)
    return {
        "score": 100.0 * len(correct_pairs) / 5.0,
        "n_correct": len(correct_pairs),
        "n_total": 5,
        "correct_pairs": correct_pairs,
        "missed_pairs": missed_pairs,
        "extra_pairs": extra_pairs,
    }

def solve_release_set(
    activations,
    rows,
    w,
    b,
) -> List[Tuple[str, str]]:
    """Return exactly 5 (concept, value) tuples of the hidden pairs."""
    predicted_triggers = [
        # ('ConceptName', 'Value'),
        # ('ConceptName', 'Value'),
        # ('ConceptName', 'Value'),
        # ('ConceptName', 'Value'),
        # ('ConceptName', 'Value'),
    ]
    # TODO: implement me!
    return predicted_triggers

######################### DO NOT CHANGE THIS CELL ##########################

if not FINAL_EVALUATION_MODE:
    predicted_triggers = solve_release_set(
        activations=val_activations,
        rows=val_rows,
        w=val_w,
        b=val_b,
    )
    print(f"\nYour answers ({len(predicted_triggers)} pairs):")
    for i, (concept, value) in enumerate(predicted_triggers, 1):
        print(f"  {i}. {concept} = {value!r}")
    results = compute_score(predicted_triggers, GROUND_TRUTH)
    print(results)
    print(f"Score: {results['score']} pts")