author-code-snapshot/method/saplma.py

import os
import argparse
import json
import time
from typing import Optional, List, Dict
import torch.autograd as autograd
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
from skdim.id import TwoNN
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader
from tqdm import tqdm
from LID import build_parser,LID
from src.metrics import roc
from src.utils import last_token_stack,get_least_used_gpu,MODEL2LAYER
import copy
import matplotlib.pyplot as plt
# import wandb
# Known transformer layer counts for supported models


def build_saplma_parser() -> argparse.ArgumentParser:
    parser=build_parser()
    # parser.add_argument("--result_name", type=str, default="saplma_results.json", help="Name of the results file.")
    parser.add_argument(
        "--epochs",
        type=int,
        default=15,
        help="Number of training epochs."
    )
    parser.add_argument(
        "--weight_decay",
        type=float,
        default=1e-4,
        help="Weight decay for optimizer."
    )
    parser.add_argument(
        "--learning_rate",
        type=float,
        default=1e-2,
        help="Learning rate for optimizer."
    )
    parser.add_argument("-b","--batch_size",type=int,default=2048)
    return parser


class _LogReg(nn.Module):
    def __init__(self, dim: int):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(dim, 512),
            nn.ReLU(),
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 2),
        )
        self.num_layers = len(self.net)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = x.to(self.net[0].weight.dtype)
        return self.net(x)




class SAPLMA(LID):
    """
    Implementation of the method from "The Internal State of an LLM Knows When It's Lying"
    (Azaria & Mitchell, 2023): train a lightweight classifier on hidden layer
    activations to predict truthfulness/hallucination labels.

    This class consumes activations saved by xp_prj1/get_activation.py, using
    predicted_activations as features and labels as binary targets.
    """

    def __init__(
        self,
        args: Optional[argparse.Namespace] = None,
    ) -> None:
        super().__init__(args)

        self.layer_num=MODEL2LAYER[args.model]
        self.epochs = args.epochs
        self.lr = args.learning_rate
        self.weight_decay = args.weight_decay

    def run_saplma(self):
        """
        Trains a small classifier on activations for each layer, evaluates test AUROC,
        and saves per-layer metrics with timing info to CSV and a plot.
        """
        device = torch.device({
            'cuda': f'cuda:{get_least_used_gpu()}',
            'cpu': 'cpu'
        }['cuda' if torch.cuda.is_available() else 'cpu'])

        metrics_rows = []  # one row per layer: layer, auroc_saplma, best_val_loss, rgn, timing
        hidden_dim1 = None
        total_training_process_time_sec = 0.0
        total_best_val_loss_compute_time_sec = 0.0
        total_rgn_compute_time_sec = 0.0
        total_snr_compute_time_sec = 0.0

        for layer in tqdm(range(self.layer_num), desc="saplma for each layer"):
            train_acts, train_labels, test_acts, test_labels = self._load_layer_data(layer)

            # ========= prepare train / val / test data =========
            train_X_all = train_acts.to(device=device, dtype=torch.float32)   # [N_train, D]
            train_y_all = train_labels.to(device=device, dtype=torch.long)    # [N_train]

            test_X = test_acts.to(device=device, dtype=torch.float32)         # [N_test, D]
            test_y = test_labels.cpu().numpy()                                # [N_test]

            # ---- split train / val ----
            val_ratio = 0.1
            n_train_total = train_X_all.size(0)
            n_val = max(1, int(n_train_total * val_ratio))

            perm = torch.randperm(n_train_total, device=device)
            val_idx_local   = perm[:n_val]
            train_idx_local = perm[n_val:]

            train_X = train_X_all[train_idx_local]
            train_y = train_y_all[train_idx_local]
            val_X   = train_X_all[val_idx_local]
            val_y   = train_y_all[val_idx_local]

            # ========= define model, loss, optimizer =========
            model = _LogReg(train_X.shape[1]).to(device)
            if hidden_dim1 is None:
                hidden_dim1 = model.net[0].out_features

            criterion = nn.CrossEntropyLoss()
            optimizer = optim.Adam(
                model.parameters(),
                lr=self.lr,
                weight_decay=self.weight_decay,
            )
            batch_size = self.args.batch_size

            train_loader = DataLoader(
                TensorDataset(train_X, train_y),
                batch_size=batch_size,
                shuffle=True,
            )
            val_loader = DataLoader(
                TensorDataset(val_X, val_y),
                batch_size=batch_size,
                shuffle=False,
            )

            scheduler = torch.optim.lr_scheduler.StepLR(
                optimizer, step_size=5, gamma=0.1
            )

            best_val_loss = float("inf")
            best_state_dict = None

            # ========= training =========
            self._sync_device(device)
            training_process_start = time.perf_counter()
            for epoch in range(self.epochs):
                # ---- train epoch ----
                model.train()
                # train_loss_sum = 0.0
                # train_count = 0

                for batch_X, batch_y in train_loader:
                    optimizer.zero_grad()
                    batch_X = batch_X.to(device)
                    batch_y = batch_y.to(device)

                    out = model(batch_X)
                    loss = criterion(out, batch_y)
                    loss.backward()
                    optimizer.step()

                    # train_loss_sum += loss.item() * batch_X.size(0)
                    # train_count += batch_X.size(0)

                # mean_train_loss = train_loss_sum / train_count

                # ---- validation epoch ----
                model.eval()
                val_loss_sum = 0.0
                val_count = 0
                with torch.no_grad():
                    for batch_X, batch_y in val_loader:
                        batch_X = batch_X.to(device)
                        batch_y = batch_y.to(device)

                        out = model(batch_X)
                        loss = criterion(out, batch_y)
                        val_loss_sum += loss.item() * batch_X.size(0)
                        val_count += batch_X.size(0)

                mean_val_loss = val_loss_sum / max(1, val_count)

                # save best val loss checkpoint
                if mean_val_loss < best_val_loss:
                    best_val_loss = mean_val_loss
                    best_state_dict = copy.deepcopy(model.state_dict())

                scheduler.step()
            self._sync_device(device)
            training_process_time_sec = time.perf_counter() - training_process_start

            # ========= evaluate AUROC on test set using best val loss checkpoint =========
            if best_state_dict is not None:
                model.load_state_dict(best_state_dict)

            self._sync_device(device)
            best_val_loss_start = time.perf_counter()
            best_val_loss = self._compute_validation_loss(
                model=model,
                criterion=criterion,
                val_X=val_X,
                val_y=val_y,
                device=device,
                batch_size=batch_size,
            )
            self._sync_device(device)
            best_val_loss_compute_time_sec = time.perf_counter() - best_val_loss_start

            self._sync_device(device)
            rgn_start = time.perf_counter()
            rgn_layer = self._compute_rgn_for_layer(
                model=model,
                criterion=criterion,
                val_X=val_X,
                val_y=val_y,
                device=device,
                batch_size=1,
            )
            self._sync_device(device)
            rgn_compute_time_sec = time.perf_counter() - rgn_start

            self._sync_device(device)
            snr_start = time.perf_counter()
            snr_layer = self._compute_snr_for_layer(
                model=model,
                criterion=criterion,
                val_X=val_X,
                val_y=val_y,
                device=device,
                batch_size=1,
            )
            self._sync_device(device)
            snr_compute_time_sec = time.perf_counter() - snr_start

            total_time_sec = (
                training_process_time_sec
                + best_val_loss_compute_time_sec
                + rgn_compute_time_sec
                + snr_compute_time_sec
            )

            model.eval()
            test_dataset = TensorDataset(test_X)
            test_loader  = DataLoader(
                test_dataset,
                batch_size=batch_size,
                shuffle=False,
            )

            pos_scores_list = []
            with torch.no_grad():
                for (batch_X,) in test_loader:
                    batch_X = batch_X.to(device)
                    logits = model(batch_X)                  # [b, 2]
                    probs  = torch.softmax(logits, dim=-1)   # [b, 2]
                    pos    = probs[:, 1]                     # positive class probability [b]
                    pos_scores_list.append(pos.cpu().numpy())

            pos_scores = np.concatenate(pos_scores_list, axis=0)  # [N_test]
            auroc_saplma = roc(test_y, pos_scores)

            # record one row of metrics for this layer
            metrics_rows.append(
                {
                    "layer": int(layer),
                    "auroc_saplma": float(auroc_saplma),
                    "best_val_loss": float(best_val_loss),
                    "rgn": float(rgn_layer),
                    "snr": float(snr_layer),
                    
                    "training_process_time_sec": float(training_process_time_sec),
                    "best_val_loss_compute_time_sec": float(best_val_loss_compute_time_sec),
                    "rgn_compute_time_sec": float(rgn_compute_time_sec),
                    "snr_compute_time_sec": float(snr_compute_time_sec),
                    "total_time_sec": float(total_time_sec),
                }
            )
            total_training_process_time_sec += training_process_time_sec
            total_best_val_loss_compute_time_sec += best_val_loss_compute_time_sec
            total_rgn_compute_time_sec += rgn_compute_time_sec
            total_snr_compute_time_sec += snr_compute_time_sec

        # ========= save results =========
        os.makedirs(self.results_dir, exist_ok=True)

        results_df = pd.DataFrame(
            metrics_rows,
            columns=[
                "layer",
                "auroc_saplma",
                "best_val_loss",
                "rgn",
                "snr",
                "id_lastfeat_twonn",
                "training_process_time_sec",
                "best_val_loss_compute_time_sec",
                "rgn_compute_time_sec",
                "snr_compute_time_sec",
                "total_time_sec",
            ],
        )
        csv_path = os.path.join(
            self.results_dir,
            f"auroc_valLoss_rgn_snr_lr{self.lr}_epochs{self.epochs}"
            f"_h1={hidden_dim1}_layer{self.layer_num}.csv",
        )
        results_df.to_csv(csv_path, index=False)
        print(f"Saved SAPLMA metrics CSV to {csv_path}")

        summary_path = os.path.join(
            self.results_dir,
            f"auroc_valLoss_rgn_snr_lr{self.lr}_epochs{self.epochs}"
            f"_h1={hidden_dim1}_layer{self.layer_num}_summary.json",
        )
        summary = {
            "total_training_process_time_sec": float(total_training_process_time_sec),
            "total_best_val_loss_compute_time_sec": float(total_best_val_loss_compute_time_sec),
            "total_rgn_compute_time_sec": float(total_rgn_compute_time_sec),
            "total_snr_compute_time_sec": float(total_snr_compute_time_sec),
            "total_time_sec": float(
                total_training_process_time_sec
                + total_best_val_loss_compute_time_sec
                + total_rgn_compute_time_sec
                + total_snr_compute_time_sec
            ),
        }
        with open(summary_path, "w", encoding="utf-8") as f:
            json.dump(summary, f, indent=2)
        print(f"Saved SAPLMA timing summary JSON to {summary_path}")

        # plot
        self._plot_layer_metrics(results_df, hidden_dim1)
        print(f"SAPLMA computation complete for model={self.model}, dataset={self.dataset}")

    @staticmethod
    def _sync_device(device: torch.device) -> None:
        if device.type == "cuda":
            torch.cuda.synchronize(device)



    def _compute_validation_loss(
        self,
        model: nn.Module,
        criterion: nn.Module,
        val_X: torch.Tensor,
        val_y: torch.Tensor,
        device: torch.device,
        batch_size: int,
    ) -> float:
        model.eval()

        val_dataset = TensorDataset(val_X, val_y)
        val_loader = DataLoader(
            val_dataset,
            batch_size=batch_size,
            shuffle=False,
        )

        val_loss_sum = 0.0
        val_count = 0
        with torch.no_grad():
            for batch_X, batch_y in val_loader:
                batch_X = batch_X.to(device)
                batch_y = batch_y.to(device)

                out = model(batch_X)
                loss = criterion(out, batch_y)
                val_loss_sum += loss.item() * batch_X.size(0)
                val_count += batch_X.size(0)

        return float(val_loss_sum / max(1, val_count))

    def _compute_rgn_for_layer(
        self,
        model: nn.Module,
        criterion: nn.Module,
        val_X: torch.Tensor,
        val_y: torch.Tensor,
        device: torch.device,
        batch_size: int,
        eps: float = 1e-12,
    ) -> float:
        """
        Runs backward on the validation set loss of the trained probe
        to estimate RGN for this layer: ||g||_2 / ||theta||_2.
        """
        model.eval()

        val_dataset = TensorDataset(val_X, val_y)
        val_loader  = DataLoader(
            val_dataset,
            batch_size=batch_size,
            shuffle=False,
        )

        rgn_vals = []

        for batch_X, batch_y in val_loader:
            batch_X = batch_X.to(device)
            batch_y = batch_y.to(device)

            # clear gradients
            model.zero_grad(set_to_none=True)

            # forward + backward
            out = model(batch_X)
            loss = criterion(out, batch_y)
            loss.backward()

            # ===== collect all gradients & parameters, then flatten and concatenate =====
            all_g = []
            all_theta = []
            for p in model.parameters():
                # if p.grad is None:
                #     continue
                # cast to float() to avoid numerical issues with half/bfloat16
                all_g.append(p.grad.detach().float().view(-1))
                all_theta.append(p.detach().float().view(-1))

            g_flat = torch.cat(all_g)        # [total_num_params]
            theta_flat = torch.cat(all_theta)

            g_norm = torch.linalg.norm(g_flat)         # sqrt(sum_j g_j^2)
            theta_norm = torch.linalg.norm(theta_flat) # sqrt(sum_j theta_j^2)
            rgn_batch = (g_norm / (theta_norm + eps)).item()
            rgn_vals.append(rgn_batch)
            
        # average over batches to get the global RGN for this layer's probe
        rgn_layer = float(torch.tensor(rgn_vals).mean().item())

        model.zero_grad(set_to_none=True)
        return rgn_layer

    def _compute_snr_for_layer(
        self,
        model: nn.Module,
        criterion: nn.Module,
        val_X: torch.Tensor,
        val_y: torch.Tensor,
        device: torch.device,
        batch_size: int,
        eps: float = 1e-12,
    ) -> float:
        """
        Runs backward on the validation set loss of the trained probe
        to estimate SNR for this layer: (sum_j g_j)^2 / sum_j g_j^2.
        """
        model.eval()

        val_dataset = TensorDataset(val_X, val_y)
        val_loader  = DataLoader(
            val_dataset,
            batch_size=batch_size,
            shuffle=False,
        )

        snr_vals = []

        for batch_X, batch_y in val_loader:
            batch_X = batch_X.to(device)
            batch_y = batch_y.to(device)

            model.zero_grad(set_to_none=True)

            out = model(batch_X)
            loss = criterion(out, batch_y)
            loss.backward()

            all_g = []
            for p in model.parameters():
                all_g.append(p.grad.detach().float().view(-1))

            g_flat = torch.cat(all_g)

            sum_g = g_flat.sum()
            sum_g2 = (g_flat * g_flat).sum()
            snr_batch = ((sum_g * sum_g) / (sum_g2 + eps)).item()
            snr_vals.append(snr_batch)

        snr_layer = float(torch.tensor(snr_vals).mean().item())

        model.zero_grad(set_to_none=True)
        return snr_layer

    def _plot_layer_metrics(self, df: pd.DataFrame, hidden_dim1: int) -> None:
        """
        df must contain columns: ["layer", "auroc_saplma", "best_val_loss", "rgn", "snr"]

        Left axis: AUROC
        Right axis: best_val_loss / rgn / snr each min-max normalized to [0, 1],
                    plotted on the same axis to compare their shapes across layers.
        """
        layers     = df["layer"].values
        aurocs     = df["auroc_saplma"].values
        val_losses = df["best_val_loss"].values
        rgns       = df["rgn"].values
        snrs       = df["snr"].values
        ID=df['id_lastfeat_twonn'].values
        def minmax_norm(x: np.ndarray, eps: float = 1e-12) -> np.ndarray:
            x_min = float(x.min())
            x_max = float(x.max())
            denom = max(x_max - x_min, eps)
            return (x - x_min) / denom
        
        val_losses_norm = minmax_norm(val_losses)
        rgns_norm       = minmax_norm(rgns)
        snrs_norm       = minmax_norm(snrs)

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

        # ---------- left axis: AUROC ----------
        ln1 = ax1.plot(
            layers,
            aurocs,
            marker="o",
            linestyle="-",
            label="AUROC (SAPLMA)",
        )
        ax1.set_xlabel("Layer")
        ax1.set_ylabel("AUROC (SAPLMA)")
        ax1.grid(True, linestyle="--", alpha=0.5)

        # ---------- right axis: normalized ValLoss / RGN / SNR ----------
        ax2 = ax1.twinx()


        ln4 = ax2.plot(
            layers,
            ID,
            marker="s",
            linestyle="-",
            color="tab:red",
            label="ID",
        )
        ax2.set_ylabel("Normalized Val Loss / RGN / SNR (0–1)")

        # ---------- merge legend ----------
        # lines  = ln1 + ln2 + ln3 + ln4
        lines=ln1+ln4
        labels = [l.get_label() for l in lines]
        ax1.legend(lines, labels, loc="best")

        fig.tight_layout()
        fig_path = os.path.join(
            self.results_dir,
            f"auroc_valLoss_rgn_snr_lr{self.lr}_epochs{self.epochs}"
            f"_h1={hidden_dim1}_layer{self.layer_num}.png",
        )
        plt.savefig(fig_path, bbox_inches="tight")
        plt.close()

        print(f"Saved SAPLMA AUROC + ValLoss + RGN + SNR figure to {fig_path}")

if __name__ == "__main__":
    args = build_saplma_parser().parse_args()
    if args.all_data:
        for dataset_name in ['coqa','hotpotqa','squad','triviaqa','psiloqa','math']:
            args.dataset=dataset_name
            sap = SAPLMA(args=args)
            sap.run_saplma()
    else:
        sap = SAPLMA(args=args)
        sap.run_saplma()