File size: 6,752 Bytes
1a881d8
 
 
 
 
 
 
 
 
55ece2a
 
 
1a881d8
 
 
 
 
55ece2a
 
 
 
 
 
 
1a881d8
55ece2a
 
 
 
 
 
 
 
1a881d8
 
 
 
 
 
 
 
 
 
55ece2a
 
 
 
 
1a881d8
55ece2a
 
 
 
1a881d8
55ece2a
1a881d8
 
 
55ece2a
1a881d8
 
55ece2a
 
 
 
 
 
1a881d8
 
 
 
 
55ece2a
 
 
 
 
 
1a881d8
 
 
 
55ece2a
 
 
 
 
 
1a881d8
 
 
55ece2a
1a881d8
 
 
 
 
55ece2a
 
 
 
 
 
 
 
 
 
1a881d8
 
 
55ece2a
1a881d8
 
 
 
55ece2a
 
 
1a881d8
55ece2a
 
1a881d8
55ece2a
 
 
 
 
 
 
 
 
 
 
1a881d8
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
55ece2a
1a881d8
 
 
 
 
 
 
 
55ece2a
1a881d8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
import glob
import json
import math
import os
from dataclasses import dataclass

import dateutil
import numpy as np

from src.display.formatting import make_hyperlink
from src.display.utils import AutoEvalColumn, ModelType, Tasks, Precision
from src.about import Model_Backbone, Training_Dataset, Testing_Type


@dataclass
class EvalResult:
    """
    Represents one full evaluation. Built from a combination of the result and request file for a given run.
    """
    eval_name: str # model_training_testing_precision (identifier for evaluations)
    model_name: str
    training_dataset_type: Training_Dataset
    training_dataset: str
    testing_type: Testing_Type
    results: dict
    paper_name: str = ""
    model_link: str = ""
    paper_link: str = ""
    model_backbone_type: Model_Backbone = Model_Backbone.Other
    model_backbone: str = ""
    precision: Precision = Precision.Other
    model_parameters: float = 0
    model_type: ModelType = ModelType.Other # Pretrained, fine tuned, ...
    date: str = "" # submission date of request file

    @classmethod
    def init_from_json_file(self, json_filepath):
        """Inits the result from the specific model result file"""
        with open(json_filepath) as fp:
            data = json.load(fp)

        config = data.get("config")

        # Extract evaluation config
        model_name = config["model_name"]
        training_dataset_type = Training_Dataset.from_str(config["training_dataset"])
        if training_dataset_type.name != Training_Dataset.Other.name:
            training_dataset = training_dataset_type.value
        else:
            training_dataset = config["training_dataset"]
        testing_type = Testing_Type(config["testing_type"])
        precision = Precision.from_str(config.get("model_dtype"))
        eval_name = model_name + precision.value + training_dataset + testing_type.value

        # Extract results
        results = {}
        for task in Tasks:
            task = task.value
            results[task.metric] = data["results"].get(task.metric, -1)

        return self(
            eval_name=eval_name,
            model_name=model_name,
            training_dataset_type=training_dataset_type,
            training_dataset=training_dataset,
            testing_type=testing_type,
            precision=precision,
            results=results,
        )

    def update_with_request_file(self, requests_path):
        """Finds the relevant request file for the current model and updates info with it"""
        if self.training_dataset_type.name != Training_Dataset.Other.name:
            training_dataset_request = self.training_dataset_type.name
        else:
            training_dataset_request = self.training_dataset
        training_dataset_request = "_".join(training_dataset_request.split())
        request_file = get_request_file_for_model(requests_path, self.model_name, self.precision.value, training_dataset_request, self.testing_type.value)

        try:
            with open(request_file, "r") as f:
                request = json.load(f)
            self.model_parameters = request.get("model_parameters", 0)
            self.model_link = request.get("model_link", "None")
            self.model_backbone = request.get("model_backbone", "Unknown")
            self.model_backbone_type = Model_Backbone.from_str(self.model_backbone)
            self.paper_name = request.get("paper_name", "None")
            self.paper_link = request.get("paper_link", "None")
            self.model_type = ModelType.from_str(request.get("model_type", ""))
            self.date = request.get("submitted_time", "")
        except Exception:
            print(f"Could not find request file for {self.model_name} with precision {self.precision.value}, training dataset {self.training_dataset} and testing type {self.testing_type.value}")

    def to_dict(self):
        """Converts the Eval Result to a dict compatible with our dataframe display"""
        data_dict = {
            "eval_name": self.eval_name,  # not a column, just a save name,
            AutoEvalColumn.precision.name: self.precision.value,
            AutoEvalColumn.model_parameters.name: self.model_parameters,
            AutoEvalColumn.model_name.name: self.model_name,
            AutoEvalColumn.paper.name: make_hyperlink(self.paper_link, self.paper_name) if self.paper_link.startswith("http") else self.paper_name,
            AutoEvalColumn.model_backbone_type.name: self.model_backbone_type.value,
            AutoEvalColumn.model_backbone.name: self.model_backbone,
            AutoEvalColumn.training_dataset_type.name: self.training_dataset_type.value,
            AutoEvalColumn.training_dataset.name: self.training_dataset,
            AutoEvalColumn.testing_type.name: self.testing_type.name,
            AutoEvalColumn.model_link.name: self.model_link
        }

        for task in Tasks:
            data_dict[task.value.col_name] = self.results[task.value.metric]

        return data_dict


def get_request_file_for_model(requests_path, model_name, precision, training_dataset, testing_type):
    """Selects the correct request file for a given model if it's marked as FINISHED"""
    request_filename = os.path.join(
        requests_path,
        model_name,
        f"{model_name}_eval_request_{precision}_{training_dataset}_{testing_type}.json",
    )

    # check for request file
    try:
        with open(request_filename, "r") as file:
            req_content = json.load(file)
            if req_content["status"] not in ["FINISHED"]:
                return None
    except OSError:
        return None

    return request_filename


def get_raw_eval_results(results_path: str, requests_path: str) -> list[EvalResult]:
    """From the path of the results folder root, extract all needed info for results"""
    model_result_filepaths = []

    for root, _, files in os.walk(results_path):
        # We should only have json files in model results
        if len(files) == 0 or any([not f.endswith(".json") for f in files]):
            continue

        for file in files:
            model_result_filepaths.append(os.path.join(root, file))

    eval_results = {}
    for model_result_filepath in model_result_filepaths:
        # Creation of result
        eval_result = EvalResult.init_from_json_file(model_result_filepath)
        eval_result.update_with_request_file(requests_path)

        eval_name = eval_result.eval_name
        eval_results[eval_name] = eval_result

    results = []
    for v in eval_results.values():
        try:
            v.to_dict() # we test if the dict version is complete
            results.append(v)
        except KeyError:  # not all eval values present
            continue
    
    return results