author-code-snapshot/method/LID.py

import os
import sys
import argparse
from typing import List, Dict, Optional
from matplotlib import pyplot as plt
from tqdm import tqdm

import numpy as np
import pandas as pd
import torch
import faiss
from pathlib import Path
_PROJECT_ROOT = str(Path.cwd())
_RESULTS_DIR = os.path.join(_PROJECT_ROOT, "results")
if _PROJECT_ROOT not in sys.path:
    sys.path.insert(0, _PROJECT_ROOT)

from src.metrics import roc
from src.utils import last_token_stack,MODEL2HF,DATA2HF,MODEL2LAYER
# Defaults aligned with xp_prj1/get_activation.py



def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="Compute LID metrics over saved activations")
    parser.add_argument(
        "-m",
        "--model",
        default="llama_instruct",
        choices=MODEL2HF.keys(),
    )
    parser.add_argument(
        "-d",
        "--dataset",
        default="hotpotqa",
        choices=DATA2HF.keys(),
    )
    parser.add_argument(
        "--basepath2prepared_data",
        type=str,
        default=os.path.join(_PROJECT_ROOT, "prepared_data"),
        help="Base path where get_activation.py wrote activations and labels",
    )
    parser.add_argument(
        "-k",
        "--num-neighbors",
        type=int,
        default=50,
        dest="num_neighbors",
        help="Number of nearest neighbors used for LID computation.",
    )
    # Output directory for metrics CSVs
    parser.add_argument(
        "--results-base",
        dest="results_base",
        type=str,
        default=_RESULTS_DIR,
        help="Base directory to write results/metrics.csv",
    )
    parser.add_argument("--zero-shot", type=bool, default=True)
    parser.add_argument("--all_data",action="store_true",help='if set, run LID over all datasets')
    return parser


class LID:
    """
    Local Intrinsic Dimensionality (LID) scorer.

    Mirrors the computation in LID-HallucinationDetection/calculate_lid.py, but
    packaged as a reusable class and aligned with paths produced by
    xp_prj1/get_activation.py.

    Usage example:
        lid = LID(basepath2prepared_data=..., model="llama2-7b", dataset="triviaqa", num_neighbors=500)
        df = lid.compute_per_layer(write_csv=True)
    """

    def __init__(
        self,
        args: Optional[argparse.Namespace] = None,
    ) -> None:
        """Initialize LID configuration.

        You can either pass parameters directly, or provide an argparse
        Namespace via `args`, or omit both and this will call build_parser().parse_args().
        Explicit kwargs, when provided, override values from `args`.
        """


        # Prefer explicit kwargs, otherwise fall back to args
        self.args=args
        self.basepath2prepared_data = getattr(args, "basepath2prepared_data")
        self.model = getattr(args, "model")
        self.dataset = getattr(args, "dataset")
        self.num_neighbors = int(getattr(args, "num_neighbors"))
        self.zero_shot = bool(getattr(args, "zero_shot"))
        self.results_base = getattr(args, "results_base")

        # Resolve paths
        self.base = os.path.join(self.basepath2prepared_data, self.model, self.dataset)
        self.results_dir = os.path.join(self.results_base, self.model, self.dataset,f'{self.__class__.__name__}')

        self.train_set_dir=os.path.join(self.base, "train",'activations')
        self.train_acts_dir=os.path.join(self.train_set_dir,'predicted')
        self.train_labels_dir=os.path.join(self.train_set_dir,'labels')

        self.test_set_dir=os.path.join(self.base, "test",'activations')
        self.test_acts_dir=os.path.join(self.test_set_dir,'predicted')
        self.test_labels_dir=os.path.join(self.test_set_dir,'labels')

        self.log_name=f"lid_metrics_{self.args.num_neighbors}"
        torch.manual_seed(42)
        np.random.seed(42)
    # ------------------------
    # Public API
    # ------------------------

    def _load_layer_data(self, layer: int):
        train_acts_path=os.path.join(
            self.train_acts_dir, f"{self.model}_{self.dataset}_layer_{layer}_pred.pt"
        )
        train_label_path=os.path.join(
            self.train_labels_dir, f"{self.model}_{self.dataset}_all_layer_label.pt"
        )
        test_acts_path=os.path.join(        
            self.test_acts_dir, f"{self.model}_{self.dataset}_layer_{layer}_pred.pt"
        )
        test_label_path=os.path.join(
            self.test_labels_dir, f"{self.model}_{self.dataset}_all_layer_label.pt"
        )
        train_acts= torch.load(train_acts_path,weights_only=True)
        test_acts= torch.load(test_acts_path,weights_only=True) 
        train_labels= torch.load(train_label_path,weights_only=True)
        test_labels= torch.load(test_label_path,weights_only=True)
        return train_acts, train_labels, test_acts, test_labels
    
    def _compute_for_layer(self, layer: int) -> Optional[Dict[str, float]]:
        """
        Computes LID-related metrics for a single layer and returns a row dict containing:
          - 'layer'
          - 'auroc'
          - 'lid_mean'
          - 'lid_std'
        Ready to be appended directly in compute_per_layer.
        """
        train_acts, train_labels, test_acts, test_labels = self._load_layer_data(layer)

        # use only label=1 train_acts as the reference set
        pos_mask = (train_labels == 1)
        pos_train_acts = train_acts[pos_mask]

        # convert to numpy
        pos_train_acts = pos_train_acts.to(dtype=torch.float32, device="cpu").numpy()
        test_acts      = test_acts.to(dtype=torch.float32, device="cpu").numpy()
        test_labels    = test_labels.numpy()

        if pos_train_acts.shape[0] == 0:
            # no positive samples in edge case — skip this layer
            return None

        k = int(min(pos_train_acts.shape[0], self.num_neighbors))

        lids = self._lid_new(
            feats=test_acts,
            num_neighbors=[k],
            ref_feats=[pos_train_acts],
        )
        lids = np.asarray(lids)

        auroc    = roc(test_labels, -lids)
        lid_mean = float(np.mean(lids))
        lid_std  = float(np.std(lids))

        # return the row dict directly (including the layer field)
        return {
            "layer":   int(layer),
            "auroc":   float(auroc),
            "lid_mean": lid_mean,
            "lid_std":  lid_std,
        }


    def _plot_per_layer_metrics(self, df) -> None:
        """
        Given a DataFrame with 'layer', 'lid_mean', 'auroc' columns, plots a dual-axis figure and saves it.

        Subclasses can override this method to plot different metrics:
            def _plot_per_layer_metrics(self, df, basename):
                ...
        """
        if df.empty:
            return

        layers   = df["layer"].values
        lid_mean = df["lid_mean"].values
        auroc    = df["auroc"].values

        fig, ax1 = plt.subplots(figsize=(8, 5))

        # left axis: LID mean
        ax1.plot(layers, lid_mean, marker="o", linestyle="-", label="LID mean")
        ax1.set_xlabel("Layer")
        ax1.set_ylabel("LID mean")
        ax1.grid(True, linestyle="--", alpha=0.5)

        # right axis: AUROC
        ax2 = ax1.twinx()
        ax2.plot(layers, auroc, marker="s", linestyle="-", label="AUROC", color="tab:orange")
        ax2.set_ylabel("AUROC")

        # merge legend
        lines1, labels1 = ax1.get_legend_handles_labels()
        lines2, labels2 = ax2.get_legend_handles_labels()
        ax1.legend(lines1 + lines2, labels1 + labels2, loc="best")

        fig.tight_layout()
        fig_path = os.path.join(self.results_dir, f"{self.log_name}.png")
        plt.savefig(fig_path, bbox_inches="tight")
        plt.close()
        print(f"Saved LID metrics figure to {fig_path}")

    # ------------------------
    # Public API
    # ------------------------
    def compute_per_layer(self) -> pd.DataFrame:
        """
        Compute LID scores for each saved layer and return a DataFrame with
        per-layer AUROC and LID statistics.
        """
        layer_ids = list(range(MODEL2LAYER[self.model]))

        metrics_rows = []
        for layer in tqdm(layer_ids):
            row = self._compute_for_layer(layer)
            if row is not None:
                metrics_rows.append(row)

        df = pd.DataFrame(metrics_rows)
        self.save_data(df)


        print(f"{self.__class__.__name__} computation complete for model={self.model}, dataset={self.dataset}")
        return df
    
    def save_data(self,df):
        os.makedirs(self.results_dir, exist_ok=True)
        csv_path = os.path.join(self.results_dir, f"{self.log_name}.csv")
        df.to_csv(csv_path, index=False)
        print(f"Saved {self.__class__.__name__} metrics CSV to {csv_path}")
        self._plot_per_layer_metrics(df)


    # ------------------------
    # Core LID kernels (ported)
    # ------------------------
    @staticmethod
    def _lid_new(
        feats: np.ndarray,
        num_neighbors: List[int],
        faiss_instances: Optional[List[faiss.IndexFlatL2]] = None,
        ref_feats: Optional[List[np.ndarray]] = None,
    ) -> np.ndarray:
        """
        Compute LID of `feats` using `ref_feats` as the reference points.
        Returns a numpy array of shape (batch,).
        Ported from LID-HallucinationDetection/calculate_lid.py:_lid_new
        """
        if faiss_instances is None:
            if ref_feats is None:
                raise ValueError("Provide either faiss_instances or ref_feats.")
            faiss_instances = []
            for rf in ref_feats:
                inst = faiss.IndexFlatL2(rf.shape[1])
                inst.add(np.ascontiguousarray(rf))
                faiss_instances.append(inst)
        else:
            if ref_feats is not None:
                # Prefer the provided FAISS indices; ignore ref_feats
                pass

        k_avg_lids = []  # (num_ks, batch)
        for k in num_neighbors:
            bootstrap_avg_lids = []  # (num_bootstrap, batch)
            for faiss_instance in faiss_instances:
                b, _ = faiss_instance.search(feats, k)
                b = np.sqrt(b)

                # Remove self-distance if present
                filtered = []
                for row in b:
                    if row[0] < 1e-6:
                        filtered.append(np.expand_dims(row[1:], axis=0))
                    else:
                        filtered.append(np.expand_dims(row[:-1], axis=0))
                D = np.concatenate(filtered, axis=0)

                rk = np.max(D, axis=1)
                rk[rk == 0] = 1e-8
                lids = D / rk[:, None]
                lids = np.clip(lids, 1e-6, 1.0)

                logs = np.log(lids)
                denom = np.mean(logs, axis=1)
                denom = np.where(np.abs(denom) < 1e-5, 1e-5 * np.sign(denom), denom)
                lids = -1.0 / denom

                lids[np.isinf(lids)] = feats.shape[1]
                lids = np.nan_to_num(lids, nan=feats.shape[1])

                bootstrap_avg_lids.append(lids.tolist())
            bootstrap_avg_lids = np.array(bootstrap_avg_lids).mean(axis=0)
            k_avg_lids.append(bootstrap_avg_lids.tolist())
        k_avg_lids = np.array(k_avg_lids).mean(axis=0)
        return k_avg_lids

if __name__ == "__main__":
    parser = build_parser()
    args = parser.parse_args()
    if args.all_data:
        for dataset_name in ['coqa','hotpotqa','squad','triviaqa','psiloqa','math']:
            args.dataset=dataset_name
            lid=LID(args=args)
            df=lid.compute_per_layer()
    else:
        lid = LID(args=args)
        df = lid.compute_per_layer()
    # print(df)