new mat

hal_det_llama.py

@@ -9,6 +9,8 @@ from tqdm import tqdm
 import numpy as np
 import pickle
 # from utils import get_llama_activations_bau, tokenized_tqa, tokenized_tqa_gen, tokenized_tqa_gen_end_q
+from utils import mahalanobis_distance
+from scipy.io import savemat
 import llama_iti
 import pickle
 import argparse
@@ -58,7 +60,7 @@ def main():
     parser.add_argument('--num_gene', type=int, default=1)
     parser.add_argument('--use_rouge', type=bool, default= False)
     parser.add_argument('--weighted_svd', type=int, default=0)
-    parser.add_argument('--feat_loc_svd', type=int, default=0)
+    parser.add_argument('--feat_loc_svd', type=int, default=1)
     parser.add_argument('--wild_ratio', type=float, default=0.75)
     parser.add_argument('--thres_gt', type=float, default=0.5)
     parser.add_argument('--most_likely', type=bool, default=True)
@@ -165,10 +167,13 @@ def main():
     model = llama_iti.LlamaForCausalLM.from_pretrained(MODEL, low_cpu_mem_usage=True,
                                                            torch_dtype=torch.float16,
                                                            device_map="auto").cuda()
+    HEADS = [f"model.layers.{i}.self_attn.head_out" for i in range(model.config.num_hidden_layers)]
+    MLPS = [f"model.layers.{i}.mlp" for i in range(model.config.num_hidden_layers)]
         # firstly get the embeddings of the generated question and answers.
     embed_generated = []
     embed_generated_h =[]
     embed_generated_t=[]
+    
 
     if args.dataset_name == 'tydiqa':
             length = len(used_indices)
@@ -185,10 +190,6 @@ def main():
             info = 'batch_generations_'
         answers = np.load(
             f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/answers/' + info + f'hal_det_{args.model_name}_{args.dataset_name}_answers_index_{i}.npy')
-        truths= np.load(
-            f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/truths/' + info + f'hal_det_{args.model_name}_{args.dataset_name}_truths_index_{i}.npy')
-        hallucinations= np.load(
-            f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/hallucinations/' + info + f'hal_det_{args.model_name}_{args.dataset_name}_hallucinations_index_{i}.npy')
         for anw in answers:
 
             if args.dataset_name == 'tydiqa':
@@ -207,136 +208,153 @@ def main():
                     hidden_states = torch.stack(hidden_states, dim=0).squeeze()
                     hidden_states = hidden_states.detach().cpu().numpy()[:, -1, :]
                     embed_generated.append(hidden_states)
-        embed_generated = np.asarray(np.stack(embed_generated), dtype=np.float32)
-        np.save(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_layer_wise.npy', embed_generated)
+    embed_generated = np.asarray(np.stack(embed_generated), dtype=np.float32)
+    np.save(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_layer_wise.npy', embed_generated)
 
-        for tru in truths:
+    embed_generated_t_loc2 = []
+    embed_generated_t_loc1 = []
+    embed_generated_h_loc2 = []
+    embed_generated_h_loc1 = []
+    embed_generated_loc2 = []
+    embed_generated_loc1 = []
+    for i in tqdm(range(length)):
+        if args.dataset_name == 'tydiqa':
+            question = dataset[int(used_indices[i])]['question']
+        else:
+            question = dataset[i]['question']
 
+
+        answers = np.load(
+                f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/answers/' + info + f'hal_det_{args.model_name}_{args.dataset_name}_answers_index_{i}.npy')
+        truths= np.load(
+                f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/truths/' + info + f'hal_det_{args.model_name}_{args.dataset_name}_truths_index_{i}.npy')
+        hallucinations= np.load(
+                f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/hallucinations/' + info + f'hal_det_{args.model_name}_{args.dataset_name}_hallucinations_index_{i}.npy')
+        for anw in answers:
             if args.dataset_name == 'tydiqa':
-                    prompt = tokenizer(
+                prompt = tokenizer(
                         "Concisely answer the following question based on the information in the given passage: \n" + \
-                        " Passage: " + dataset[int(used_indices[i])]['context'] + " \n Q: " + question + " \n A:" + tru,
+                        " Passage: " + dataset[int(used_indices[i])]['context'] + " \n Q: " + question + " \n A:" + anw,
                         return_tensors='pt').input_ids.cuda()
             elif args.dataset_name == 'coqa':
-                    prompt = tokenizer(dataset[i]['prompt'] + tru, return_tensors='pt').input_ids.cuda()
+                prompt = tokenizer(dataset[i]['prompt'] + anw, return_tensors='pt').input_ids.cuda()
             else:
-                    prompt = tokenizer(
-                        f"Answer the question concisely. Q: {question}" + " A:" + tru,
+                prompt = tokenizer(
+                        f"Answer the question concisely. Q: {question}" + " A:" + anw,
                         return_tensors='pt').input_ids.cuda()
+
             with torch.no_grad():
-                    hidden_states = model(prompt, output_hidden_states=True).hidden_states
-                    hidden_states = torch.stack(hidden_states, dim=0).squeeze()
-                    hidden_states = hidden_states.detach().cpu().numpy()[:, -1, :]
-                    embed_generated_t.append(hidden_states)
-        embed_generated_t = np.asarray(np.stack(embed_generated_t), dtype=np.float32)
-        np.save(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_t_layer_wise.npy', embed_generated_t)
+                with TraceDict(model, HEADS + MLPS) as ret:
+                    output = model(prompt, output_hidden_states=True)
+                head_wise_hidden_states = [ret[head].output.squeeze().detach().cpu() for head in HEADS]
+                head_wise_hidden_states = torch.stack(head_wise_hidden_states, dim=0).squeeze().numpy()
+                mlp_wise_hidden_states = [ret[mlp].output.squeeze().detach().cpu() for mlp in MLPS]
+                mlp_wise_hidden_states = torch.stack(mlp_wise_hidden_states, dim=0).squeeze().numpy()
 
+                embed_generated_loc2.append(mlp_wise_hidden_states[:, -1, :])
+                embed_generated_loc1.append(head_wise_hidden_states[:, -1, :])
         for hal in hallucinations:
-
             if args.dataset_name == 'tydiqa':
-                    prompt = tokenizer(
+                prompt = tokenizer(
                         "Concisely answer the following question based on the information in the given passage: \n" + \
                         " Passage: " + dataset[int(used_indices[i])]['context'] + " \n Q: " + question + " \n A:" + hal,
                         return_tensors='pt').input_ids.cuda()
             elif args.dataset_name == 'coqa':
-                    prompt = tokenizer(dataset[i]['prompt'] + hal, return_tensors='pt').input_ids.cuda()
+                prompt = tokenizer(dataset[i]['prompt'] + hal, return_tensors='pt').input_ids.cuda()
             else:
-                    prompt = tokenizer(
+                prompt = tokenizer(
                         f"Answer the question concisely. Q: {question}" + " A:" + hal,
                         return_tensors='pt').input_ids.cuda()
+
             with torch.no_grad():
-                    hidden_states = model(prompt, output_hidden_states=True).hidden_states
-                    hidden_states = torch.stack(hidden_states, dim=0).squeeze()
-                    hidden_states = hidden_states.detach().cpu().numpy()[:, -1, :]
-                    embed_generated_h.append(hidden_states)
-        embed_generated_h = np.asarray(np.stack(embed_generated_h), dtype=np.float32)
-        np.save(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_h_layer_wise.npy', embed_generated_h)
-
-        HEADS = [f"model.layers.{i}.self_attn.head_out" for i in range(model.config.num_hidden_layers)]
-        MLPS = [f"model.layers.{i}.mlp" for i in range(model.config.num_hidden_layers)]
-        embed_generated_loc2 = []
-        embed_generated_loc1 = []
-        for i in tqdm(range(length)):
-            if args.dataset_name == 'tydiqa':
-                question = dataset[int(used_indices[i])]['question']
-            else:
-                question = dataset[i]['question']
-
-
-            answers = np.load(
-                f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/answers/' + info + f'hal_det_{args.model_name}_{args.dataset_name}_answers_index_{i}.npy')
-            for anw in answers:
-                if args.dataset_name == 'tydiqa':
-                    prompt = tokenizer(
-                        "Concisely answer the following question based on the information in the given passage: \n" + \
-                        " Passage: " + dataset[int(used_indices[i])]['context'] + " \n Q: " + question + " \n A:",
-                        return_tensors='pt').input_ids.cuda()
-                elif args.dataset_name == 'coqa':
-                    prompt = tokenizer(dataset[i]['prompt'] + anw, return_tensors='pt').input_ids.cuda()
-                else:
-                    prompt = tokenizer(
-                        f"Answer the question concisely. Q: {question}" + " A:" + anw,
-                        return_tensors='pt').input_ids.cuda()
-
-                with torch.no_grad():
-                    with TraceDict(model, HEADS + MLPS) as ret:
+                with TraceDict(model, HEADS + MLPS) as ret:
                         output = model(prompt, output_hidden_states=True)
-                    head_wise_hidden_states = [ret[head].output.squeeze().detach().cpu() for head in HEADS]
-                    head_wise_hidden_states = torch.stack(head_wise_hidden_states, dim=0).squeeze().numpy()
-                    mlp_wise_hidden_states = [ret[mlp].output.squeeze().detach().cpu() for mlp in MLPS]
-                    mlp_wise_hidden_states = torch.stack(mlp_wise_hidden_states, dim=0).squeeze().numpy()
+                head_wise_hidden_states = [ret[head].output.squeeze().detach().cpu() for head in HEADS]
+                head_wise_hidden_states = torch.stack(head_wise_hidden_states, dim=0).squeeze().numpy()
+                mlp_wise_hidden_states = [ret[mlp].output.squeeze().detach().cpu() for mlp in MLPS]
+                mlp_wise_hidden_states = torch.stack(mlp_wise_hidden_states, dim=0).squeeze().numpy()
 
-                    embed_generated_loc2.append(mlp_wise_hidden_states[:, -1, :])
-                    embed_generated_loc1.append(head_wise_hidden_states[:, -1, :])
-        embed_generated_loc2 = np.asarray(np.stack(embed_generated_loc2), dtype=np.float32)
-        embed_generated_loc1 = np.asarray(np.stack(embed_generated_loc1), dtype=np.float32)
+                embed_generated_h_loc2.append(mlp_wise_hidden_states[:, -1, :])
+                embed_generated_h_loc1.append(head_wise_hidden_states[:, -1, :])
+        for tru in truths:
+            if args.dataset_name == 'tydiqa':
+                prompt = tokenizer(
+                        "Concisely answer the following question based on the information in the given passage: \n" + \
+                        " Passage: " + dataset[int(used_indices[i])]['context'] + " \n Q: " + question + " \n A:" + tru,
+                        return_tensors='pt').input_ids.cuda()
+            elif args.dataset_name == 'coqa':
+                prompt = tokenizer(dataset[i]['prompt'] + tru, return_tensors='pt').input_ids.cuda()
+            else:
+                prompt = tokenizer(
+                        f"Answer the question concisely. Q: {question}" + " A:" + tru,
+                        return_tensors='pt').input_ids.cuda()
 
-        np.save(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_head_wise.npy', embed_generated_loc1)
-        np.save(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_embeddings_mlp_wise.npy',  embed_generated_loc2)
+            with torch.no_grad():
+                with TraceDict(model, HEADS + MLPS) as ret:
+                    output = model(prompt, output_hidden_states=True)
+                head_wise_hidden_states = [ret[head].output.squeeze().detach().cpu() for head in HEADS]
+                head_wise_hidden_states = torch.stack(head_wise_hidden_states, dim=0).squeeze().numpy()
+                mlp_wise_hidden_states = [ret[mlp].output.squeeze().detach().cpu() for mlp in MLPS]
+                mlp_wise_hidden_states = torch.stack(mlp_wise_hidden_states, dim=0).squeeze().numpy()
 
+                embed_generated_t_loc2.append(mlp_wise_hidden_states[:, -1, :])
+                embed_generated_t_loc1.append(head_wise_hidden_states[:, -1, :])
+            
+    embed_generated_loc2 = np.asarray(np.stack(embed_generated_loc2), dtype=np.float32)
+    embed_generated_loc1 = np.asarray(np.stack(embed_generated_loc1), dtype=np.float32)
+    embed_generated_h_loc2 = np.asarray(np.stack(embed_generated_h_loc2), dtype=np.float32)
+    embed_generated_h_loc1 = np.asarray(np.stack(embed_generated_h_loc1), dtype=np.float32)
+    embed_generated_t_loc2 = np.asarray(np.stack(embed_generated_t_loc2), dtype=np.float32)
+    embed_generated_t_loc1 = np.asarray(np.stack(embed_generated_t_loc1), dtype=np.float32)
 
+    np.save(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_head_wise.npy', embed_generated_loc1)
+    np.save(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_embeddings_mlp_wise.npy',  embed_generated_loc2)
+    np.save(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_h_head_wise.npy', embed_generated_h_loc2)
+    np.save(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_h_mlp_wise.npy', embed_generated_h_loc1)
+    np.save(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_t_head_wise.npy', embed_generated_t_loc2)
+    np.save(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_t_mlp_wise.npy', embed_generated_t_loc1)
 
         # get the split and label (true or false) of the unlabeled data and the test data.
-        if args.use_rouge:
-            gts = np.load(f'./ml_{args.dataset_name}_{args.model_name}_rouge_score.npy')
-            gts_bg = np.load(f'./bg_{args.dataset_name}_{args.model_name}_rouge_score.npy')
-        else:
-            gts = np.load(f'./ml_{args.dataset_name}_{args.model_name}_bleurt_score.npy')
-            gts_bg = np.load(f'./bg_{args.dataset_name}_{args.model_name}_bleurt_score.npy')
+    if args.use_rouge:
+        gts = np.load(f'./ml_{args.dataset_name}_{args.model_name}_rouge_score.npy')
+        gts_bg = np.load(f'./bg_{args.dataset_name}_{args.model_name}_rouge_score.npy')
+    else:
+        gts = np.load(f'./ml_{args.dataset_name}_{args.model_name}_bleurt_score.npy')
+        gts_bg = np.load(f'./bg_{args.dataset_name}_{args.model_name}_bleurt_score.npy')
         thres = args.thres_gt
         gt_label = np.asarray(gts> thres, dtype=np.int32)
         gt_label_bg = np.asarray(gts_bg > thres, dtype=np.int32)
 
 
-        if args.dataset_name == 'tydiqa':
-            length = len(used_indices)
-        else:
-            length = len(dataset)
+    if args.dataset_name == 'tydiqa':
+        length = len(used_indices)
+    else:
+        length = len(dataset)
 
 
-        permuted_index = np.random.permutation(length)
-        wild_q_indices = permuted_index[:int(args.wild_ratio * length)]
+    permuted_index = np.random.permutation(length)
+    wild_q_indices = permuted_index[:int(args.wild_ratio * length)]
         # exclude validation samples.
-        wild_q_indices1 = wild_q_indices[:len(wild_q_indices) - 100]
-        wild_q_indices2 = wild_q_indices[len(wild_q_indices) - 100:]
-        gt_label_test = []
-        gt_label_wild = []
-        gt_label_val = []
-        for i in range(length):
-            if i not in wild_q_indices:
-                gt_label_test.extend(gt_label[i: i+1])
-            elif i in wild_q_indices1:
-                gt_label_wild.extend(gt_label[i: i+1])
-            else:
-                gt_label_val.extend(gt_label[i: i+1])
-        gt_label_test = np.asarray(gt_label_test)
-        gt_label_wild = np.asarray(gt_label_wild)
-        gt_label_val = np.asarray(gt_label_val)
+    wild_q_indices1 = wild_q_indices[:len(wild_q_indices) - 100]
+    wild_q_indices2 = wild_q_indices[len(wild_q_indices) - 100:]
+    gt_label_test = []
+    gt_label_wild = []
+    gt_label_val = []
+    for i in range(length):
+        if i not in wild_q_indices:
+            gt_label_test.extend(gt_label[i: i+1])
+        elif i in wild_q_indices1:
+            gt_label_wild.extend(gt_label[i: i+1])
+        else:
+            gt_label_val.extend(gt_label[i: i+1])
+    gt_label_test = np.asarray(gt_label_test)
+    gt_label_wild = np.asarray(gt_label_wild)
+    gt_label_val = np.asarray(gt_label_val)
 
 
 
 
-        def svd_embed_score(embed_generated_wild,  gt_label,embed_generated_h,embed_generated_t, begin_k, k_span, mean=1, svd=1, weight=0):
+    def svd_embed_score(embed_generated_wild,  gt_label,embed_generated_h,embed_generated_t, begin_k, k_span, mean=1, svd=10, epsilon=1e-20):
             embed_generated = embed_generated_wild
             # embed_hallucination= embed_generated_h
             best_auroc_over_k = 0
@@ -350,37 +368,75 @@ def main():
                 mean_recorded = None
                 # best_projection = None
                 for layer in range(len(embed_generated_wild[0])):
+                    # print(len(embed_generated_wild[0]))
                     if mean:
                         mean_recorded = embed_generated[:, layer, :].mean(0)
                         centered = embed_generated[:, layer, :] - mean_recorded
+                        mean_h=embed_generated_h[:, layer, :].mean(0)
+                        centered_h=embed_generated_h[:, layer, :]-mean_h
+                        mean_t=embed_generated_t[:, layer, :].mean(0)
+                        centered_t=embed_generated_t[:, layer, :]-mean_t
                     else:
                         centered = embed_generated[:, layer, :]
 
-                    mean_h=embed_generated_h[:, layer, :].mean(0)
-                    centered_h=embed_generated_h[:, layer, :]-mean_h
+                    
+                    
 
-                    mean_t=embed_generated_t[:, layer, :].mean(0)
-                    centered_t=embed_generated_t[:, layer, :].mean(0)-mean_t
+                    
+                    
 
                     # if not svd:
                     #     assert "Not implemented!"
                     # else:
-                    _, sin_value, V_p = torch.linalg.svd(torch.from_numpy(centered).cuda())
-                    C=(1 / centered.shape[0])* V_p.T.cpu().data.numpy() @ np.diag(sin_value.cpu().data.numpy() ** 2)
-                    _, sin_value_h, V_p_h = torch.linalg.svd(torch.from_numpy(centered_h).cuda())
-                    C_h=(1 / centered_h.shape[0])* V_p_h.T.cpu().data.numpy() @ np.diag(sin_value_h.cpu().data.numpy() ** 2)
-                    _, sin_value_t, V_p_t = torch.linalg.svd(torch.from_numpy(centered_t).cuda())
-                    C_t=(1 / centered_t.shape[0])* V_p_t.T.cpu().data.numpy() @ np.diag(sin_value_t.cpu().data.numpy() ** 2)
-                    scores= (centered*np.invert(C)*centered.T) ** 0.5 - ((embed_generated[:, layer, :]-mean_t)*np.invert(C_t)*(embed_generated[:, layer, :]-mean_t).T) ** 0.5
-                    + ((embed_generated[:, layer, :]-mean_h)*np.invert(C_h)*(embed_generated[:, layer, :]-mean_h).T) ** 0.5
-                   
-                    # clf = Perceptron(tol=1e-3, random_state=0)
+                    centered=torch.from_numpy(centered).cuda()
+                    centered_h=torch.from_numpy(centered_h).cuda()
+                    centered_t=torch.from_numpy(centered_t).cuda()
+                    _, sin_value, V_p = torch.linalg.svd(centered, full_matrices=False)
+                    sin_value_squared = torch.diag(sin_value[:k]) ** 2
+                    V_p = V_p[:k, :]
+                    C=(1 / centered.shape[0])* V_p.T @ sin_value_squared @ V_p
+
+
+                    _, sin_value_h, V_p_h = torch.linalg.svd(centered_h, full_matrices=False)
+                    sin_value_h_squared = torch.diag(sin_value_h[:k]) ** 2
+                    V_p_h = V_p_h[:k, :]
+                    C_h=(1 / centered_h.shape[0])* V_p_h.T @ sin_value_h_squared @ V_p_h
+
+                    # print(centered_t.shape)
+                    _, sin_value_t, V_p_t = torch.linalg.svd(centered_t, full_matrices=False)
+                    sin_value_t_squared = torch.diag(sin_value_t[:k]) ** 2
+                    V_p_t = V_p_t[:k, :]
+                    C_t=(1 / centered_t.shape[0])* V_p_t.T @ sin_value_t_squared @ V_p_t
+
+
+                    
+                    inv_C_t= torch.linalg.pinv(C_t) + torch.eye(C_t.shape[0], dtype=int).cuda() * epsilon
+                    inv_C_h= torch.linalg.pinv(C_h) + torch.eye(C_h.shape[0], dtype=int).cuda() * epsilon
+                    test_t=torch.from_numpy(embed_generated[:, layer, :]).cuda()-centered_t
+                    test_h=torch.from_numpy(embed_generated[:, layer, :]).cuda()-centered_h
+                    # scores= torch.sqrt(torch.clamp(test_t @ inv_C_t @ test_t.T, min=0.0))
+                    # - torch.sqrt(torch.clamp(test_h @ inv_C_h @ test_h.T, min=0.0)) 
+                    scores= torch.sqrt(torch.clamp(centered @ inv_C_t @ centered.T, min=0.0))
+                    - torch.sqrt(torch.clamp(centered @ inv_C_h @ centered.T, min=0.0)) 
+                    # scores= mahalanobis_distance(torch.from_numpy(embed_generated[:, layer, :]).cuda(), torch.from_numpy(mean_recorded).cuda(), C_) torch.clamp(centered @ inv_C_t @ centered.T, min=0.0)
+                    # - mahalanobis_distance(torch.from_numpy(embed_generated[:, layer, :]).cuda(), torch.from_numpy(mean_t).cuda(), C_t)
+                    # + mahalanobis_distance(torch.from_numpy(embed_generated[:, layer, :]).cuda(), torch.from_numpy(mean_h).cuda(), C_h)  centered @ inv_C_h @ centered.T
+                    
+                    scores = torch.mean(scores, -1, keepdim=True)
+                    scores = torch.sqrt(torch.sum(torch.square(scores), dim=1))
+
+                    # projection=V_p[:k, :].T
+                    # scores1 = torch.mean(centered @ projection, -1, keepdim=True)
+                    # scores1 = torch.sqrt(torch.sum(torch.square(scores1), dim=1))
+                    
                     
 
 
                     # not sure about whether true and false data the direction will point to,
                     # so we test both. similar practices are in the representation engineering paper
                     # https://arxiv.org/abs/2310.01405
+                    scores=scores.data.cpu().numpy()
+                    # scores1=scores1.data.cpu().numpy()
                     measures1 = get_measures(scores[gt_label == 1],
                                              scores[gt_label == 0], plot=False)
                     measures2 = get_measures(-scores[gt_label == 1],
@@ -397,8 +453,7 @@ def main():
                         best_auroc = measures[0]
                         best_result = [100 * measures[2], 100 * measures[0]]
                         best_layer = layer
-                        # best_scores = sign_layer * scores
-                        # best_projection = projection
+                        best_scores = sign_layer * scores
                         best_mean = mean_recorded
                         best_sign = sign_layer
                 print('k: ', k, 'best result: ', best_result, 'layer: ', best_layer,
@@ -410,7 +465,7 @@ def main():
                     best_layer_over_k = best_layer
                     best_k = k
                     best_sign_over_k = best_sign
-                    # best_scores_over_k = best_scores
+                    best_scores_over_k = best_scores
                     # best_projection_over_k = best_projection
                     best_mean_over_k = best_mean
 
@@ -426,45 +481,51 @@ def main():
                     }
 
 
-        from sklearn.decomposition import PCA
-        feat_loc = args.feat_loc_svd
+    from sklearn.decomposition import PCA
+    feat_loc = args.feat_loc_svd
 
 
 
-        if args.most_likely:
-            if feat_loc == 3:
-                embed_generated = np.load(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_layer_wise.npy',
+    if args.most_likely:
+        if feat_loc == 1:
+            embed_generated = np.load(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_head_wise.npy',
                                   allow_pickle=True)
-            elif feat_loc == 2:
-                embed_generated = np.load(
+            embed_generated_h = np.load(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_h_head_wise.npy',
+                                  allow_pickle=True)
+            embed_generated_t = np.load(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_t_head_wise.npy',
+                                  allow_pickle=True)
+        elif feat_loc == 2:
+            embed_generated = np.load(
                     f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_mlp_wise.npy',
                     allow_pickle=True)
-            else:
-                embed_generated = np.load(
-                    f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_head_wise.npy',
-                    allow_pickle=True)
-            feat_indices_wild = []
-            feat_indices_eval = []
+            embed_generated_h = np.load(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_h_mlp_wise.npy',
+                                  allow_pickle=True)
+            embed_generated_t = np.load(f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info + f'{args.model_name}_gene_embeddings_t_mlp_wise.npy',
+                                  allow_pickle=True)
+        else:
+            assert "Not supported!"
+        feat_indices_wild = []
+        feat_indices_eval = []
 
-            if args.dataset_name == 'tydiqa':
-                length = len(used_indices)
-            else:
-                length = len(dataset)
+        if args.dataset_name == 'tydiqa':
+            length = len(used_indices)
+        else:
+            length = len(dataset)
 
 
-            for i in range(length):
-                if i in wild_q_indices1:
-                    feat_indices_wild.extend(np.arange(i, i+1).tolist())
-                elif i in wild_q_indices2:
-                    feat_indices_eval.extend(np.arange(i, i + 1).tolist())
-            if feat_loc == 3:
-                embed_generated_wild = embed_generated[feat_indices_wild][:,1:,:]
-                embed_generated_eval = embed_generated[feat_indices_eval][:, 1:, :]
-                embed_generated_hal,embed_generated_tru=embed_generated_h[feat_indices_wild][:,1:,:], embed_generated_t[feat_indices_wild][:,1:,:]
-            else:
-                embed_generated_wild = embed_generated[feat_indices_wild]
-                embed_generated_eval = embed_generated[feat_indices_eval]
-                embed_generated_hal,embed_generated_tru=embed_generated_h[feat_indices_wild], embed_generated_t[feat_indices_wild]
+        for i in range(length):
+            if i in wild_q_indices1:
+                feat_indices_wild.extend(np.arange(i, i+1).tolist())
+            elif i in wild_q_indices2:
+                feat_indices_eval.extend(np.arange(i, i + 1).tolist())
+        if feat_loc == 3:
+            embed_generated_wild = embed_generated[feat_indices_wild][:,1:,:]
+            embed_generated_eval = embed_generated[feat_indices_eval][:, 1:, :]
+            embed_generated_hal,embed_generated_tru=embed_generated_h[feat_indices_wild][:,1:,:], embed_generated_t[feat_indices_wild][:,1:,:]
+        else:
+            embed_generated_wild = embed_generated[feat_indices_wild]
+            embed_generated_eval = embed_generated[feat_indices_eval]
+            embed_generated_hal,embed_generated_tru=embed_generated_h[feat_indices_eval], embed_generated_t[feat_indices_eval]
 
 
 
@@ -474,7 +535,7 @@ def main():
         #                                    1, 11, mean=0, svd=0, weight=args.weighted_svd)
         # get the best hyper-parameters on validation set
         returned_results = svd_embed_score(embed_generated_eval, gt_label_val, embed_generated_hal,embed_generated_tru,
-                                           1, 11, mean=1, svd=1, wei1ght=args.weighted_svd)
+                                           1, 15, mean=1, svd=10)
 
         pca_model = PCA(n_components=returned_results['k'], whiten=False).fit(embed_generated_wild[:,returned_results['best_layer'],:])
         projection = pca_model.components_.T
@@ -502,7 +563,10 @@ def main():
 
         assert test_scores.shape[1] == 1
         test_scores = np.sqrt(np.sum(np.square(test_scores), axis=1))
-
+        mdic = {"gt_1": test_scores[gt_label_test == 1], "gt_0": test_scores[gt_label_test == 0], "scale_gt_1":returned_results['best_sign'] * test_scores[gt_label_test == 1],
+                "scale_gt_0": returned_results['best_sign'] *test_scores[gt_label_test == 0]
+                }
+        savemat("tqa_score.mat", mdic)
         measures = get_measures(returned_results['best_sign'] * test_scores[gt_label_test == 1],
                                  returned_results['best_sign'] *test_scores[gt_label_test == 0], plot=False)
         print_measures(measures[0], measures[1], measures[2], 'direct-projection')
@@ -548,6 +612,7 @@ def main():
 
 
                 clf.eval()
+                torch.save(clf.state_dict(), f'save_for_eval/{args.dataset_name}/{args.model_name}_hal_det/' + info+  '_{layer}_model_weights.pth')
                 output = clf(torch.from_numpy(
                     embed_generated_test[:, layer, :]).cuda())
                 pca_wild_score_binary_cls = torch.sigmoid(output)
@@ -559,7 +624,7 @@ def main():
                     breakpoint()
                 measures = get_measures(pca_wild_score_binary_cls[gt_label_test == 1],
                                         pca_wild_score_binary_cls[gt_label_test == 0], plot=False)
-
+                # print_measures(measures[0], measures[1], measures[2], 'class-acc')
                 if measures[0] > best_auroc:
                     best_auroc = measures[0]
                     best_result = [100 * measures[0]]

hal_generate.py

@@ -62,7 +62,7 @@ def main():
 
     parser = argparse.ArgumentParser()
     parser.add_argument('--model_name', type=str, default='step-1-8k')
-    parser.add_argument('--dataset_name', type=str, default='tqa')
+    parser.add_argument('--dataset_name', type=str, default='triviaqa')
     parser.add_argument('--num_gene', type=int, default=1)
     parser.add_argument('--use_api', type=bool, default=True)
     parser.add_argument('--most_likely', type=bool, default=True)
@@ -175,6 +175,7 @@ def main():
         raise ValueError("Invalid dataset name")
     f = open(args.instruction, 'r', encoding="utf-8")
     instruction = f.read()
+    error_output='No output'
 
     if args.use_api:
         begin_index = 0
@@ -210,8 +211,9 @@ def main():
                 hallucination_prompt=get_hal_prompt(dataset[int(used_indices[i])]['context'],question,instruction)
                 truth_prompt=get_truth_prompt(dataset[int(used_indices[i])]['context'],question)
             elif args.dataset_name == 'triviaqa':
-                prompt = get_qa_prompt("None",dataset[i]['prompt'])
-                hallucination_prompt=get_hal_prompt("None",dataset[i]['prompt'],instruction)
+                prompt = get_qa_prompt("None",dataset[i]['question'])
+                question= dataset[i]['question']
+                hallucination_prompt=get_hal_prompt("None",dataset[i]['question'],instruction)
                 truth_prompt=get_truth_prompt("None",question)
             elif args.dataset_name == 'coqa':
                 prompt = get_qa_prompt("None",dataset[i]['prompt'])
@@ -223,31 +225,46 @@ def main():
 
             for gen_iter in range(args.num_gene):
                 if args.most_likely:
-                    response = client.chat.completions.create(
+                    try:
+                        response = client.chat.completions.create(
                     model = args.model_name,
                     messages = prompt,
                     max_tokens=256,
                     top_p=1,
                     temperature = 1,
                     )
-                    hallucination_response = client.chat.completions.create(
+                        decoded=response.choices[0].message.content
+                    except openai.APIStatusError as e:
+                        print("error occured!"+str(gen_iter)+"responce {e}")
+                        decoded = error_output
+                    try:
+                        hallucination_response = client.chat.completions.create(
                     model = args.model_name,
                     messages = hallucination_prompt,
                     max_tokens=256,
                     top_p=1,
                     temperature = 1,
                     )
+                        hallucination_decoded=hallucination_response.choices[0].message.content
+                    except openai.APIStatusError as e:
+                        print("error occured!"+str(gen_iter)+"hallucination_responce {e}")
+                        hallucination_decoded = error_output
                     if args.dataset_name == 'tydiqa' or args.dataset_name == 'tydiqa':
-                        truth_response=client.chat.completions.create(
+                        try:
+                            truth_response=client.chat.completions.create(
                         model = args.model_name,
                         messages = truth_prompt,
                     max_tokens=256,
                         top_p=1,
                         temperature=1 
                     )
-                        truth_decoded=truth_response.choices[0].message.content
-                    decoded=response.choices[0].message.content
-                    hallucination_decoded=hallucination_response.choices[0].message.content
+                            truth_decoded=truth_response.choices[0].message.content
+                        except openai.APIStatusError as e:
+                            print("error occured!"+str(gen_iter)+"truth_responce {e}")
+                            truth_decoded =error_output
+                    
+                    
+                    
                 else:
                     response = client.chat.completions.create(
                     model = args.model_name,
@@ -275,10 +292,10 @@ def main():
                         top_p=0.5,
                     temperature = 0.5, 
                     )
-                        truth_decoded=truth_response.choices[0].message.content
+                    truth_decoded=truth_response.choices[0].message.content
                     decoded=response.choices[0].message.content
                     hallucination_decoded=hallucination_response.choices[0].message.content
-                time.sleep(20)
+                time.sleep(40)
 
 
                 # decoded = tokenizer.decode(generated[0, prompt.shape[-1]:],

hal_gt.py

@@ -50,14 +50,14 @@ def main():
 
     parser = argparse.ArgumentParser()
     parser.add_argument('--model', type=str, default='llama2_chat_7B')
-    parser.add_argument('--model_name', type=str, default='step-1-8k')
+    parser.add_argument('--model_name', type=str, default='moonshot-v1-8k')
     parser.add_argument('--dataset_name', type=str, default='tqa')
     parser.add_argument('--num_gene', type=int, default=1)
     parser.add_argument('--use_api', type=bool, default=False)
-    parser.add_argument('--most_likely', type=bool, default=True)
+    parser.add_argument('--most_likely', type=bool, default=False)
     parser.add_argument("--model_dir", type=str, default=None, help='local directory with model data')
     parser.add_argument("--instruction", type=str, default=None, help='local directory of instruction file.')
-    parser.add_argument('--use_rouge', type=bool, default=False)
+    parser.add_argument('--use_rouge', type=bool, default=True)
     parser.add_argument('--thres_gt', type=float, default=0.5)
 
     # parser.add_argument('--model_name', type=str, default='llama2_chat_7B')

utils.py

@@ -954,4 +954,8 @@ You are an AI assistant. You'll provide helpful, harmless, and detailed response
                                         "\n#Question#: " + question +
                                         # "\n#Right Answer#: " + answer +
                                         "\n#Answer#: "}
-    ]
+    ]
+def mahalanobis_distance(x, mean, cov):
+    cov_inv = torch.inverse(cov)
+    delta = x - mean
+    return torch.sqrt(torch.einsum('bi,ij,bj->b', delta, cov_inv, delta))