from collections import defaultdict from typing import Optional, List, Dict, Any import os import sys import ast import json from matplotlib import pyplot as plt import numpy as np import torch import tempfile import pandas as pd from tqdm import tqdm import argparse import glob from transformers import ( AutoModelForCausalLM, AutoTokenizer, ) import warnings import copy import traceback import gc from collections import defaultdict from typing import Dict, DefaultDict, List, Optional from transformers import AutoModelForCausalLM from datasets import load_dataset, Dataset from src.metrics import rouge_L from src.utils import load_model_and_validate_gpu,MODEL2HF,DATA2HF,ensure_dir from src.construct_dataset_utils import build_prompt_answer from method.curvature import curvature from pathlib import Path PROJECT_PATH = str(Path.cwd()) MODEL_CACHE_DIR = "path2model" Data_CACHE_DIR = "path2dataset" # ---------------------- # Args # ---------------------- def build_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description="Extract layer activations for QA datasets") parser.add_argument( "-m", "--model", default="llama_instruct", choices=MODEL2HF.keys(), ) parser.add_argument( "-d", "--dataset", default="halueval_summary", choices=DATA2HF.keys(), ) parser.add_argument( "--basepath2prepared_data", type=str, default=f"{PROJECT_PATH}/prepared_data", help="base path to prepared data, which include context, gold answer and predicted answer", ) parser.add_argument( "--model-cache-dir", type=str, default=MODEL_CACHE_DIR, dest="model_cache_dir", help="HF cache dir", ) parser.add_argument( "--device", default="auto", help=( "Device to place inputs on (and for dtype validation). " "Use 'cuda', 'cuda:0', 'cpu', etc. 'auto' prefers CUDA." ), ) parser.add_argument("--split", type=str, default="train",choices=["train","test"]) parser.add_argument("--zero-shot", type=bool, default=True) parser.add_argument( "--device-map", default="auto", choices=["auto", "balanced", "balanced_low_0", "sequential", "none"], dest="device_map", help=( "Device map strategy for loading the model. Use 'none' to keep the model on a single device " "(controlled by --device)." ), ) parser.add_argument( "-b", "--batch-size", type=int, default=16, help="Batch size for activation extraction.", ) parser.add_argument( "--curvature", action="store_true", help="If set, compute per-layer curvature (using all non-padding tokens).", ) parser.add_argument( "--act", action="store_true", help="If set, save last-token hidden states (original activations).", ) parser.add_argument( "--dont-save", action="store_true", dest="dont_save", help="Run the computation but do not save activation or label tensors.", ) parser.add_argument( "--all_data", action="store_true", ) parser.add_argument( "--all_split", action="store_true", ) parser.add_argument("--all_model",action='store_true') return parser def get_acts( prompt_answers_list, answer_column, tokenizer: AutoTokenizer, model: AutoModelForCausalLM, device: torch.device, batch_size: int, compute_acts: bool, compute_curvature: bool, ): num_layers = len(model.model.layers) enc_all = tokenizer( prompt_answers_list, return_tensors="pt", padding=True, add_special_tokens=False, return_offsets_mapping=True, ) input_ids = enc_all["input_ids"] # [B, L] attn_mask = enc_all["attention_mask"] # [B, L] offsets_all = enc_all["offset_mapping"] # [B, L, 2] B = input_ids.size(0) # tokenize answers once (list of list[int]) ans_start_chars=torch.tensor([len(c)-len(f" {a}") for c, a in zip(prompt_answers_list, answer_column)],dtype=torch.long,device=input_ids.device) acts: Optional[Dict[int, List[torch.Tensor]]] = ( {layer: [] for layer in range(num_layers)} if compute_acts else None ) curvs: Optional[Dict[int, List[float]]] = ( {layer: [] for layer in range(num_layers)} if compute_curvature else None ) for start in tqdm(range(0, B, batch_size), desc="Collect hidden states / curvature / fisher"): end = min(B, start + batch_size) sl = slice(start, end) ids = input_ids[sl].to(device) # [b, L] mask = attn_mask[sl].to(device) # [b, L] off = offsets_all[sl].to(device) # [b, L, 2] mask_bool = mask.bool() bsz = ids.size(0) a_sch = ans_start_chars[sl].to(device) # [b] # ---------- Forward ---------- with torch.inference_mode(): out = model( input_ids=ids, attention_mask=mask, output_hidden_states=True, ) hidden_states = out.hidden_states # tuple, len = num_layers + 1 batch_index = torch.arange(bsz, device=ids.device) # ---------- 1) activations & curvature ---------- for layer in range(num_layers): h = hidden_states[layer + 1] # [b, L, D], skip the embedding layer # last-token activations if compute_acts: last_h = h[batch_index, -1] # [b, D] for i in range(bsz): acts[layer].append(last_h[i].detach().cpu()) # curvature using all non-padding tokens if compute_curvature: for i in range(bsz): valid_h = h[i][mask_bool[i]] # [T_i, D] if valid_h.numel() == 0: continue curv_val = curvature(valid_h) if curv_val is None or (isinstance(curv_val, float) and np.isnan(curv_val)): print(f"[WARN] curvature is {curv_val} at layer {layer}, sample {start+i}") continue curvs[layer].append(float(curv_val)) return acts, curvs def get_acts_save( args, dataset: Dataset, acts_dir: Optional[str], curv_dir: Optional[str], tokenizer: AutoTokenizer, model: AutoModelForCausalLM, device: torch.device, gt_flag: bool = False, ): """ Save activations / curvature / gradient-based metrics depending on args.act / args.curvature / args.gradient flags. """ prompt_list = build_prompt_answer(args, dataset, gt_flag) acts_batch, curv_batch = get_acts( prompt_list, dataset['matched_ground_truth'] if gt_flag else dataset['best_answer'], tokenizer, model, device, args.batch_size, compute_acts=args.act, compute_curvature=args.curvature, ) tag = "gt" if gt_flag else "pred" # ====== save activations ====== if args.act and (not args.dont_save) and acts_dir is not None and acts_batch is not None: os.makedirs(acts_dir, exist_ok=True) for layer_id, acts_list in acts_batch.items(): layer_acts = torch.stack(acts_list, dim=0) # [N, D] save_path = os.path.join( acts_dir, f"{args.model}_{args.dataset}_layer_{layer_id}_{tag}.pt", ) torch.save(layer_acts, save_path) print(f"[{tag}] activations saved to {acts_dir}") elif args.act and args.dont_save: print(f"[{tag}] activations were computed but not saved because --dont-save is enabled") # ====== save curvature ====== if args.curvature and curv_dir is not None and curv_batch is not None: os.makedirs(curv_dir, exist_ok=True) layer_mean_curv = { layer_id: float(np.mean(vals)) # vals is the list of per-sample curvature values for layer_id, vals in curv_batch.items() if len(vals) > 0 } df_curv = pd.DataFrame( [ {"layer": int(layer), "curvature_mean": mean_c} for layer, mean_c in layer_mean_curv.items() ] ) save_path = os.path.join(curv_dir, f"{args.model}_{args.dataset}_curvature_mean.csv") df_curv.to_csv(save_path, index=False) print(f"Saved mean curvature per layer to {save_path}") # plot and save the curvature curve layers = df_curv["layer"].values curv_means = df_curv["curvature_mean"].values plt.figure(figsize=(8, 5)) plt.plot(layers, curv_means, marker="o") plt.xlabel("Layer") plt.ylabel("Mean curvature") plt.title(f"Curvature vs Layer ({args.model} on {args.dataset})") plt.grid(True, linestyle="--", alpha=0.5) fig_path = os.path.join( curv_dir, f"{args.model}_{args.dataset}_curvature_mean.png" ) plt.savefig(fig_path, bbox_inches="tight") plt.close() print(f"Saved curvature plot to {fig_path}") def main(args): gpu_name = torch.cuda.get_device_name(0) # if args.all_data: if args.dataset in ['coqa','squad',]: args.batch_size=16 if (gpu_name=='NVIDIA RTX A6000' or 'NVIDIA A40' )else 64 elif args.dataset in ['psiloqa','halueval_summary','cnn_dailymail']: args.batch_size=16 if (gpu_name=='NVIDIA RTX A6000' or 'NVIDIA A40' ) else 4 else: args.batch_size=32 if (gpu_name=='NVIDIA RTX A6000' or 'NVIDIA A40' ) else 64 if args.split == 'train': if not (args.act and args.curvature): args.act = True args.curvature=True warnings.warn("'act' and 'curvature' are set to True on split='train'.", UserWarning) else: if not args.act : args.act = True warnings.warn("'act' is set to True since on split='test'.", UserWarning) args.curvature = False model, tokenizer=load_model_and_validate_gpu( MODEL2HF[args.model], cache_dir=args.model_cache_dir, ) tokenizer.pad_token_id = tokenizer.eos_token_id tokenizer.padding_side='left' device = model.device base_path = os.path.join( args.basepath2prepared_data, args.model, args.dataset, ) dataset_path = os.path.join(base_path, f"{args.split}_data.jsonl") base_save_path = os.path.join(base_path,f"{args.split}", "activations") gt_acts_path = os.path.join(base_save_path, "ground_truth") pred_acts_path = os.path.join(base_save_path, "predicted") label_path = os.path.join(base_save_path, "labels") curv_base_path = os.path.join(PROJECT_PATH, "results", f"{args.model}", f"{args.dataset}","curvature") dirs_to_create = [curv_base_path] if args.curvature else [] if not args.dont_save: dirs_to_create.extend([base_save_path, gt_acts_path, pred_acts_path, label_path]) if dirs_to_create: ensure_dir(dirs_to_create) df=pd.read_json(dataset_path,orient="records",lines=True) dataset=Dataset.from_pandas(df) # predicted get_acts_save( args, dataset, acts_dir=pred_acts_path if args.act else None, curv_dir=curv_base_path if args.curvature else None, tokenizer=tokenizer, model=model, device=device, gt_flag=False, ) if not args.dont_save: labels = dataset["label"] labels_tensor = torch.tensor(labels, dtype=torch.long) labels_path = os.path.join( label_path, f"{args.model}_{args.dataset}_all_layer_label.pt" ) torch.save(labels_tensor, labels_path) else: print("Label tensor was not saved because --dont-save is enabled") del model del tokenizer gc.collect() torch.cuda.empty_cache() if __name__ == "__main__": parser = build_parser() args = parser.parse_args() def run_one(a): try: print(f"\n=== Running model={a.model} dataset={a.dataset} split={a.split} ===") main(a) except Exception: traceback.print_exc() def run_all_splits(a): if a.all_split: for split in ["train", "test"]: aa = copy.deepcopy(a) aa.split = split run_one(aa) else: run_one(a) def run_all_datasets(a): if a.all_data: for dataset_name in ["coqa", "squad", "hotpotqa", "triviaqa", "psiloqa"]: aa = copy.deepcopy(a) aa.dataset = dataset_name run_all_splits(aa) else: run_all_splits(a) def run_all_models(a): if a.all_model: for model_name in ["llama_instruct", "mistral_instruct"]: aa = copy.deepcopy(a) aa.model = model_name run_all_datasets(aa) else: run_all_datasets(a) run_all_models(args)