| import pynvml |
| import pandas as pd |
| from typing import Any, Dict, List, Optional |
| import torch |
| from tqdm import tqdm |
| import ast |
| import os |
| import tempfile |
| import numpy as np |
| from src.metrics import rouge_L |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
| MODEL2HF={ |
| "llama2-7b":"meta-llama/Llama-2-7b-hf", |
| "mistral-7b-0.3":"mistralai/Mistral-7B-v0.3", |
| "llama2-13b":"meta-llama/Llama-2-13b-hf", |
| "llama3.1-8b":"meta-llama/Llama-3.1-8B", |
| "llama3.2_1b_instruct":"/bigtemp/usr/Model/Llama-3.2-1B-Instruct", |
| "llama3.2_3b_instruct":"/bigtemp/usr/Model/Llama-3.2-3B-Instruct", |
| "mistral_instruct":"mistralai/Mistral-7B-Instruct-v0.3", |
| "llama_instruct":"meta-llama/Llama-3.1-8B-Instruct", |
| "llama3.2-1b":"/bigtemp/usr/Model/Llama-3.2-1B", |
| "llama3.2-3b":"/bigtemp/usr/Model/Llama-3.2-3B", |
| "qwen2.5_14b_instruct":"/bigtemp/usr/Model/Qwen2.5-14B-Instruct", |
| "qwen2.5_14b":"/bigtemp/usr/Model/Qwen2.5-14B" |
| } |
| MODEL2LAYER = { |
| "llama2-7b": 32, |
| "mistral-7b": 32, |
| "llama2-13b": 40, |
| "llama3.1-8b":32, |
| "llama3.2-3b":28, |
| "llama3.2-1b":16, |
| "llama_instruct":32, |
| "llama3.2_3b_instruct":28, |
| "llama3.2_1b_instruct":16, |
| "mistral_instruct":32, |
| "qwen2.5_14b_instruct":48 |
| } |
|
|
| DATA2HF={ |
| "coqa":"stanfordnlp/coqa", |
| "triviaqa":None, |
| "hotpotqa":None, |
|
|
| "squad":"rajpurkar/squad", |
| "hotpotqa_c":None, |
| 'psiloqa':None, |
| "halueval_summary":None, |
| "cnn_dailymail":"abisee/cnn_dailymail", |
| "odd_man_out":None, |
| "trec":"trec", |
| "dbpedia_14":"dbpedia_14", |
| "ag_news":"ag_news" |
| } |
| def get_least_used_gpu() -> int: |
| """ |
| Returns the local GPU index (0-based) with the least used memory among visible GPUs. |
| Raises RuntimeError if no GPU is available. |
| """ |
| visible_devices = os.environ.get("CUDA_VISIBLE_DEVICES") |
| visible_physical_ids: Optional[List[int]] = None |
| if visible_devices is not None and visible_devices.strip(): |
| visible_physical_ids = [] |
| for token in visible_devices.split(","): |
| token = token.strip() |
| if not token: |
| continue |
| if not token.lstrip("-").isdigit(): |
| visible_physical_ids = None |
| break |
| physical_id = int(token) |
| if physical_id < 0: |
| visible_physical_ids = None |
| break |
| visible_physical_ids.append(physical_id) |
| if visible_physical_ids == []: |
| visible_physical_ids = None |
|
|
| pynvml.nvmlInit() |
| try: |
| device_count = pynvml.nvmlDeviceGetCount() |
| if device_count == 0: |
| raise RuntimeError("No GPU devices found.") |
|
|
| if visible_physical_ids is None: |
| candidate_ids = list(range(device_count)) |
| local_to_physical = {idx: idx for idx in candidate_ids} |
| else: |
| candidate_ids = [idx for idx in visible_physical_ids if idx < device_count] |
| if not candidate_ids: |
| raise RuntimeError( |
| "CUDA_VISIBLE_DEVICES does not reference any valid GPU." |
| ) |
| local_to_physical = { |
| local_idx: physical_idx |
| for local_idx, physical_idx in enumerate(candidate_ids) |
| } |
|
|
| best_local_idx = 0 |
| best_used = None |
|
|
| for local_idx, physical_idx in local_to_physical.items(): |
| handle = pynvml.nvmlDeviceGetHandleByIndex(physical_idx) |
| mem_info = pynvml.nvmlDeviceGetMemoryInfo(handle) |
| used = mem_info.used |
|
|
| if best_used is None or used < best_used: |
| best_used = used |
| best_local_idx = local_idx |
|
|
| return best_local_idx |
| finally: |
| pynvml.nvmlShutdown() |
|
|
|
|
| def expand_df_to_data(df: pd.DataFrame, save_csv_path: Optional[str] = None) -> pd.DataFrame: |
| """Expand a prepared QA DataFrame into model-ready records. |
| |
| """ |
| eval_expanded: Dict[str, List[Any]] = {"context_pred": [], "label": [], "context_gt": [], "context": []} |
|
|
| for _, row in tqdm(df.iterrows(), total=len(df), desc="Expanding DataFrame"): |
| context = row['context'] |
| prediction=row['sampled_answers'] |
| gold_answer: List[str] = row['gold_answer'] |
| |
| score,matched_gold = rouge_L([prediction], gold_answer) |
| label = score > 0.5 |
| context_pred = construct_input(context, prediction) |
| context_gt = construct_input(context, matched_gold) |
| eval_expanded["context_pred"].append(context_pred) |
| eval_expanded["context"].append(context) |
| eval_expanded["label"].append(label) |
| eval_expanded["context_gt"].append(context_gt) |
|
|
| eval_df = pd.DataFrame(eval_expanded) |
|
|
| |
| if save_csv_path is not None: |
| try: |
| pd.DataFrame({ |
| "context": eval_df["context"].tolist(), |
| "context_pred": eval_df["context_pred"].tolist(), |
| "context_gt": eval_df["context_gt"].tolist(), |
| "label": eval_df["label"].astype(int).tolist(), |
| }).to_csv(save_csv_path, index=False) |
| except Exception as e: |
| print(f"Warning: failed to save labels CSV at {save_csv_path}: {e}") |
|
|
| return eval_df |
|
|
|
|
|
|
| def process_row(row,args): |
| context = row['context'] |
| prediction = row['sampled_answers'] |
| if args.model=='mistral-7b': |
| prediction=ast.literal_eval(row['sampled_answers']) |
| prediction=prediction[0] |
| gold_answer = row['gold_answer'] |
| with tempfile.TemporaryDirectory() as tmpdirname: |
| os.environ["HF_DATASETS_CACHE"] = tmpdirname |
| score, matched_gold = rouge_L([prediction], gold_answer) |
| label = score > 0.4 |
| context_pred = construct_input(context, prediction) |
| context_gt = construct_input(context, matched_gold) |
| return pd.Series({ |
| "context_pred": context_pred, |
| "context": context, |
| "label": label, |
| "context_gt": context_gt |
| }) |
|
|
|
|
|
|
| def construct_input(context: str, answer: str) -> str: |
| return f"{context}{answer}" |
|
|
| def last_token_stack(acts): |
| """ |
| acts |
| - List[Tensor]: each of shape [L_i, D] |
| |
| Returns: |
| Tensor: [N, D] |
| """ |
| last_vecs = [] |
| for i, t in enumerate(acts): |
| if not isinstance(t, torch.Tensor): |
| raise TypeError(f"acts[{i}] is not a Tensor, got {type(t)}") |
| if t.ndim != 2: |
| raise ValueError(f"acts[{i}] should have shape [L_i, D], got {t.shape}") |
| if t.size(0) == 0: |
| raise ValueError(f"acts[{i}] has zero length in seq dimension") |
| last_vecs.append(t[-1]) |
| return torch.stack(last_vecs, dim=0) |
|
|
|
|
| def load_model_and_validate_gpu(model_path,cache_dir=None,single_gpu=False,args=None): |
| tokenizer_path = model_path |
| tokenizer = AutoTokenizer.from_pretrained(tokenizer_path,cache_dir=cache_dir) |
| print("Started loading model") |
| if single_gpu: |
| device_id = get_least_used_gpu() |
| device = torch.device(f"cuda:{device_id}") |
| model = AutoModelForCausalLM.from_pretrained( |
| model_path, |
| torch_dtype=torch.bfloat16, |
| low_cpu_mem_usage=True, |
| cache_dir=cache_dir, |
| ) |
| model.to(device) |
| else: |
| model = AutoModelForCausalLM.from_pretrained(model_path, device_map='auto', |
| dtype=torch.bfloat16, low_cpu_mem_usage=True,cache_dir=cache_dir,) |
| assert ('cpu' not in model.hf_device_map.values()) |
|
|
| return model, tokenizer |
|
|
| def ensure_dir(path: List[str] | str) -> None: |
| if isinstance(path, list): |
| for p in path: |
| ensure_dir(p) |
| elif not os.path.exists(path): |
| os.makedirs(path, exist_ok=True) |
|
|
|
|
|
|
|
|
