Upload 8 files

code for evaluation

.gitattributes

@@ -54,3 +54,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
 indexing.jsonl filter=lfs diff=lfs merge=lfs -text
+semantic_search_results.json filter=lfs diff=lfs merge=lfs -text

automatic_evaluation.py

@@ -0,0 +1,100 @@
+"""
+Michal Stromko Automating Evaluation Script Annotated Dataset
+for task Semantic Evaluation
+"""
+
+import os
+import sys
+import json
+from metrics import recall, mrr, map, ndcg
+from filtering_parsing import filtering_annotated, filtering_predicted
+
+
+def load_jsonl_file(file_path: str):
+    """
+    Load jsonl file
+    :param file_path: path to the file
+    :return: json data
+    """
+    data = []
+    with open(file_path, "r", encoding="utf-8") as f:
+        for line in f:
+            data.append(json.loads(line))
+    return data
+
+
+def load_json_file(file_path: str):
+    """
+    Load json file
+    :param file_path: path to the file
+    :return: json data
+    """
+    with open(file_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    return data
+
+
+if __name__ == '__main__':
+    # get file names
+    f_annotated_final = sys.argv[1]
+    f_predicted_final = sys.argv[2]
+
+    # load files
+    print("Loading datasets")
+    final_annotated = load_jsonl_file(f_annotated_final)
+    predicted = load_json_file(f_predicted_final)
+    print("Loaded datasets")
+
+    # filtering parsing annotated dataset
+    filtered_annotated_dataset = filtering_annotated.first_filtering_annotated(final_annotated)
+
+    filtering_annotated.counting_count_results(filtered_annotated_dataset)
+    actual_results = filtering_annotated.second_filtering_annotated(filtered_annotated_dataset)
+
+    # filtering and parsing predicted dataset
+    predicted_results = filtering_predicted.prediction_filtering_dataset(predicted)
+
+    # prepare dataset for ndcg evaluation
+    correct_answers_ndcg = ndcg.filtering_annotated_dataset_for_eval_ndcg(filtered_annotated_dataset)
+    predicted_ndcg = ndcg.filter_and_parsing_assignment_article_id_to_category(predicted_results, correct_answers_ndcg)
+
+    print("\n")
+
+    count_results = [5, 10, 15]
+
+    # Evaluation Dataset
+    print("Start evaluation")
+
+    # count recall
+    for i in range(0, len(count_results)):
+        print(f"Count Recall Metric for {count_results[i]} results:")
+        recall_value = recall.count_recall(actual_results, predicted_results, count_results[i])
+        print(f"\nMean value Recall for every count questions: \n{recall_value}")
+        print("\n")
+    print("---------------------------------------------------------")
+
+    # count mrr
+    for i in range(0, len(count_results)):
+        print(f"Count MRR Metric for {count_results[i]} results:")
+        mrr.count_mrr(actual_results, predicted_results, count_results[i])
+        print("\n ")
+        print("---------------------------------------------------------")
+
+    # count map
+    for i in range(0, len(count_results)):
+        print(f"Count MAP Metric for {count_results[i]} results:")
+        results, total_mAP = map.count_map(actual_results, predicted_results, count_results[i])
+        print("Results for individual questions:")
+        print(results)
+
+        print("\n")
+        print("---------------------------------------------------------")
+
+    # count ndcg
+    for i in range(0, len(count_results)):
+        print(f"Count NDCG Metric for {count_results[i]}:")
+        ndcg_res = ndcg.count_ndcg(predicted_ndcg, count_results[i])
+        print("\n")
+    print("---------------------------------------------------------")
+
+    print("Finish evaluation")

metrics/map.py

@@ -0,0 +1,66 @@
+import pandas as pd
+
+
+def count_map(actual_list, predicted_list, count_results):
+    """
+    Funtion for count MAP metric
+    :param actual_list:  actual results from annotated datatest
+    :param predicted_list: predicted results from searched engine
+    :return: map value in question MAP value
+    """
+
+    # Initialization empty list for results
+    questions = []
+    k_stops = []
+    frequencies = []
+    mAPs = []
+
+    # For every question
+    for q, (actual, predicted) in enumerate(zip(actual_list, predicted_list), 1):
+        k_stop = None  # initialization value who stop cycle for this question
+        ap_sum = 0  # initialization sum AP on question
+        count = 0  # count value k_stop
+
+        # Loop throw values k
+        for x, pred_value in enumerate(predicted[:count_results], 1):
+            act_set = set(actual)
+            pred_set = set(predicted[:x])
+            precision_at_k = len(act_set & pred_set) / x
+
+            if pred_value in actual:
+                rel_k = 1
+            else:
+                rel_k = 0
+
+            ap_sum += precision_at_k * rel_k
+
+            # If we have found all the relevant values and we don't have k_stop yet, we stop
+            if len(act_set) == ap_sum and k_stop is None:
+                k_stop = x
+                count += 1
+
+        # If we haven't reached k_stop by 15, we set it to 15
+        if k_stop is None:
+            k_stop = count_results
+
+        # Count mAP for question
+        ap_q = ap_sum / len(actual)
+
+        # Save results to list
+        questions.append(q)
+        k_stops.append(k_stop)
+        frequencies.append(count)
+        mAPs.append(round(ap_q, 2))
+
+    # Create DataFrame from results
+    df_results = pd.DataFrame({'Question': questions, 'k_stop': k_stops, 'Frequency': frequencies, 'mAP': mAPs})
+
+    # Count total mAP
+    total_mAP = round(df_results['mAP'].mean(), 2)
+
+    print(f"MAP Metric for {count_results} is: {total_mAP}")
+
+    k_stop_counts = df_results['k_stop'].value_counts()
+    print(f"Count of K_stop \n{k_stop_counts}")
+
+    return df_results, round(total_mAP,2)

metrics/mrr.py

@@ -0,0 +1,38 @@
+def count_mrr(actual_list, predicted_list, count_results):
+    """
+    Function for calculate MRR metric
+    :param actual_list:  actual results from annotated datatest
+    :param predicted_list: predicted results from searched engine
+    :return: None
+    """
+    # number of queries
+    Q = len(actual_list)
+    # calculate the reciprocal rank for each query
+    cumulative_reciprocal = 0
+    # initialize dictionary to store count of relevant results for each query
+    relevant_results_count = {i: 0 for i in range(1, count_results + 1)}
+
+    for i in range(Q):
+        actual = actual_list[i]
+        pred = predicted_list[i][:count_results]
+        reciprocal_rank = 0
+        for j, result in enumerate(pred, 1):
+            if result in actual:
+                reciprocal_rank = 1 / j
+                relevant_results_count[j] += 1  # increment count of relevant results for this query
+                break
+        cumulative_reciprocal += reciprocal_rank
+        # print(f"query #{i+1} = {1}/{j} = {reciprocal_rank}")
+
+    # calculate MRR
+    mrr = cumulative_reciprocal / Q
+
+    # generate result
+    print(f"MRR Metric for {count_results} is: {round(mrr, 2)}")
+
+    # generate table of relevant results count
+    print("Table of Relevant Results Count:")
+    print("Position | Count")
+
+    for position, count in relevant_results_count.items():
+        print(f"{position:^9} | {count:^5}")

metrics/ndcg.py

@@ -0,0 +1,121 @@
+from math import log2
+import pandas as pd
+
+
+def filtering_annotated_dataset_for_eval_ndcg(filtered_annotated_dataset):
+    """
+    Get from filtering annotated dataset only article id and category
+    next step save in dict and all save dict save in list
+    :param filtered_annotated_dataset: annotated dataset in json format
+    :return: list of dict for prepare datas for evaluation ndcg
+    """
+
+    correct_answers = []
+
+    for i in range(0, len(filtered_annotated_dataset)):
+        correct_answer = {}
+        line = filtered_annotated_dataset[i]
+        for sublist in line["results"]:
+            correct_answer[sublist['answer_id']] = sublist['category']
+
+        correct_answers.append(correct_answer)
+
+    return correct_answers
+
+
+def filter_and_parsing_assignment_article_id_to_category(predicted_list, correct_answers):
+    """
+    Funtion to filter and parsing search_result id to category for evaluation ndcg
+    :param predicted_list:  search results for evaluation ndcg
+    :param correct_answers: correct answers for evaluation ndcg from annotated dataset
+    :return: list with correct order with number of relevant category
+    """
+
+    predictions = []
+
+    # for cycle in seared dataset
+    for i in range(0, len(predicted_list)):
+        prediction = []
+
+        # parsing data to tmp
+        line = predicted_list[i]
+        correct_answer = correct_answers[i]
+
+        # get on id and find same id in dict from annotated dataset
+        for j in range(0, len(line)):
+
+            # if article id in correct answers
+            if line[j] in correct_answer:
+                """
+                acd correct order
+                if category 1 in ndcg is 3
+                if category 2 in ndcg is 2
+                if category 3 in ndcg is 1
+                else category in ndcg is 0
+                """
+                if correct_answer[line[j]] == 1:
+                    prediction.append(3)
+                elif correct_answer[line[j]] == 2:
+                    prediction.append(2)
+                else:
+                    # correct_answer[line[j]] == 3:
+                    prediction.append(1)
+            else:
+                prediction.append(0)
+
+        # save get values
+        predictions.append(prediction)
+
+    return predictions
+
+
+def count_ndcg(relevance, count_results):
+    """
+    Function count ndcg
+    :param relevance: search results with value relevance
+    :return: total ndcg value
+    """
+
+    df = pd.DataFrame()
+    df['Count Results'] = range(1, count_results + 1)
+    df['SUM NDCG'] = [0.00] * count_results
+
+    K = count_results
+
+    for line in relevance:
+
+        # sort items in 'relevance' from most relevant to less relevant
+        ideal_relevance = sorted(line, reverse=True)
+
+        dcg = 0
+        idcg = 0
+        ndcg_list = []
+
+        for k in range(1, K + 1):
+            # calculate rel_k values
+            rel_k = line[k - 1]
+            ideal_rel_k = ideal_relevance[k - 1]
+
+            # calculate dcg and idcg
+            dcg += rel_k / log2(1 + k)
+            idcg += ideal_rel_k / log2(1 + k)
+
+            if dcg == 0.00 and idcg == 0.00:
+                ndcg = 0
+
+            else:
+                # calculate ndcg
+                ndcg = dcg / idcg
+
+            df.at[k - 1, 'SUM NDCG'] += ndcg
+
+    # Create new column "NDCG" in dataFrame df
+    df['NDCG'] = round(df['SUM NDCG'] / len(relevance), 2)
+    print_ndcg = round(df.at[count_results - 1, 'NDCG'], 2)
+    print(f"NDCG Metric for {count_results} is: {print_ndcg} \n")
+    print(df)
+
+    sum_ndcg = df['NDCG'].sum()
+    ndcg_mean = sum_ndcg / K
+
+    return round(ndcg_mean, 2)

metrics/recall.py

@@ -0,0 +1,74 @@
+import pandas as pd
+
+
+# recall@k function
+def recall(actual, predicted, k):
+    """
+    Calculate recall for set results
+    :param actual: actual results on question from annotated datatest
+    :param predicted: predicted results on question from searched engine
+    :param k: max results in set
+    :return: recall value
+    """
+
+    # corrects results
+    act_set = actual
+    # search results (count edit k)
+    pred_set = predicted[:k]
+
+    # count and find same numbers
+    common_elements = 0
+    for item in act_set:
+        if item in pred_set:
+            common_elements += 1
+
+    result = round(common_elements / float(len(act_set)), 2)
+
+    return result
+
+
+def count_recall(actual_list, predicted_list, count_results):
+    """
+    Calculate recall for search engine
+    :param actual_list:  actual results from annotated datatest
+    :param predicted_list: predicted results from searched engine
+    :return: average recall value
+    """
+
+    # set values for parameter k
+    k_start = 3
+    k_end = count_results + 1
+
+    # Initialization empty DataFrame
+    df_recall = pd.DataFrame(index=range(3, count_results + 1))
+
+    # For cycle go to every predicted questions
+    for i, predicted_val in enumerate(predicted_list, 1):
+
+        recalls = []
+
+        #  Count recall for question
+        for k in range(k_start, k_end):
+            recall_val = recall(actual_list[i - 1], predicted_val, k)
+            recalls.append(recall_val)
+
+        df_temp = pd.DataFrame({f"Question {i}": recalls}, index=range(3, count_results + 1))
+        df_recall = pd.concat([df_recall, df_temp], axis=1)
+
+        df_recall[f"Question {i}"] = recalls
+
+    # Calculate the average recall value for each number of questions
+    average_recall = df_recall.mean(axis=1)
+
+    # Print list the recall values for each question separately
+    # print("Recall values for every question:")
+    # print(df_recall)
+
+    # set results two dots numbers
+    pd.set_option('display.float_format', '{:.2f}'.format)
+
+    # Print all mean recall
+    # print(f"\nAll Mean Recall for {count_results} results :{round(average_recall.mean(), 2)}")
+
+    print(f"Recall Metric for {count_results} is: {round(average_recall.iloc[-1], 2)}")
+    return average_recall

requirements.txt

@@ -0,0 +1,2 @@
+pandas
+tqdm

semantic_search_results.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d1b8e3c6094c40a4f91506f180bd990b847ee248e10b8346e0347bc9ab239f4
+size 30758787