Comment old code

Author: sshivam95

dicee/static_funcs_training.py

@@ -35,7 +35,69 @@ def evaluate_lp(model, triple_idx, num_entities, er_vocab: Dict[Tuple, List], re
     all_entities = torch.arange(0, num_entities).long()
     all_entities = all_entities.reshape(len(all_entities), )
 
-    # Iterate over test triples in batches
+    # Evaluation without Batching
+    # for i in tqdm(range(0, len(triple_idx))):
+    #     # (1) Get a triple (head entity, relation, tail entity
+    #     data_point = triple_idx[i]
+    #     h, r, t = data_point[0], data_point[1], data_point[2]
+
+    #     # (2) Predict missing heads and tails
+    #     x = torch.stack((torch.tensor(h).repeat(num_entities, ),
+    #                      torch.tensor(r).repeat(num_entities, ),
+    #                      all_entities), dim=1)
+
+    #     predictions_tails = model(x)
+    #     x = torch.stack((all_entities,
+    #                      torch.tensor(r).repeat(num_entities, ),
+    #                      torch.tensor(t).repeat(num_entities)
+    #                      ), dim=1)
+
+    #     predictions_heads = model(x)
+    #     del x
+
+    #     # 3. Computed filtered ranks for missing tail entities.
+    #     # 3.1. Compute filtered tail entity rankings
+    #     filt_tails = er_vocab[(h, r)]
+    #     # 3.2 Get the predicted target's score
+    #     target_value = predictions_tails[t].item()
+    #     # 3.3 Filter scores of all triples containing filtered tail entities
+    #     predictions_tails[filt_tails] = -np.Inf
+    #     # 3.4 Reset the target's score
+    #     predictions_tails[t] = target_value
+    #     # 3.5. Sort the score
+    #     _, sort_idxs = torch.sort(predictions_tails, descending=True)
+    #     sort_idxs = sort_idxs.detach()
+    #     filt_tail_entity_rank = np.where(sort_idxs == t)[0][0]
+
+    #     # 4. Computed filtered ranks for missing head entities.
+    #     # 4.1. Retrieve head entities to be filtered
+    #     filt_heads = re_vocab[(r, t)]
+    #     # 4.2 Get the predicted target's score
+    #     target_value = predictions_heads[h].item()
+    #     # 4.3 Filter scores of all triples containing filtered head entities.
+    #     predictions_heads[filt_heads] = -np.Inf
+    #     predictions_heads[h] = target_value
+    #     _, sort_idxs = torch.sort(predictions_heads, descending=True)
+    #     sort_idxs = sort_idxs.detach()
+    #     filt_head_entity_rank = np.where(sort_idxs == h)[0][0]
+
+    #     # 4. Add 1 to ranks as numpy array first item has the index of 0.
+    #     filt_head_entity_rank += 1
+    #     filt_tail_entity_rank += 1
+
+    #     rr = 1.0 / filt_head_entity_rank + (1.0 / filt_tail_entity_rank)
+    #     # 5. Store reciprocal ranks.
+    #     reciprocal_ranks.append(rr)
+    #     # print(f'{i}.th triple: mean reciprical rank:{rr}')
+
+    #     # 4. Compute Hit@N
+    #     for hits_level in range(1, 11):
+    #         res = 1 if filt_head_entity_rank <= hits_level else 0
+    #         res += 1 if filt_tail_entity_rank <= hits_level else 0
+    #         if res > 0:
+    #             hits.setdefault(hits_level, []).append(res)
+    
+    # Evaluation with Batching
     for batch_start in tqdm(range(0, len(triple_idx), batch_size), desc="Evaluating Batches"):
         batch_end = min(batch_start + batch_size, len(triple_idx))
         batch_triples = triple_idx[batch_start:batch_end]
@@ -85,7 +147,7 @@ def evaluate_lp(model, triple_idx, num_entities, er_vocab: Dict[Tuple, List], re
 
         # Iterating one by one is not good when you are using batch norm
         for i in range(0, batch_size_current):
-        # (1) Get a triple (head entity, relation, tail entity
+        # (1) Get a triple (head entity, relation, tail entity)
             h = h_batch[i].item()
             r = r_batch[i].item()
             t = t_batch[i].item()