File size: 8,494 Bytes
9f50319 | 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 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 | import os
from evaluate_code.load_datasets import load_data
from evaluate_code.graph_embed import GraphEmbedder
from evaluate_code.extract import AnswerExtractor
from evaluate_code.llm_api import LLMCaller
from evaluate_code.evaluate import Evaluator
TASK_DATASET_MAPPING = {
# Simple Tasks
"S_0D": "datasets/Simple_Tasks/0D_Component_Counting", # 0D component counting
"S_1D": "datasets/Simple_Tasks/1D_Simplex_Counting", # 1D simplex counting
"S_Modification": "datasets/Simple_Tasks/Component_Reduction", # Component reduction task
# Medium Tasks
"M_Merge": "datasets/Medium_Tasks/Component_Merge_Time", # Persistent homology calculation
"M_Birth": "datasets/Medium_Tasks/Simplex_Birth_Time", # Birth time calculation
"M_Filtration": "datasets/Medium_Tasks/Component_Count_Under_Filtration", # Filtration feature counting
# Hard Tasks
"H_Selection": "datasets/Hard_Tasks/Optimal_Filtration_Selection", # Filtration method selection
"H_Generation": "datasets/Hard_Tasks/Non-Uniform_Filtration_Generation", # Filtration value selection
# Real World Tasks
"R_Selection": "datasets/Real_World_Tasks/Filtration_Selection_for_Classification", # Real data filtration method selection
"R_Generation": "datasets/Real_World_Tasks/Filtration_Sequence_Generation_for_Classification", # Real data filtration value selection
"R_Directly": "datasets/Real_World_Tasks/Direct_Classification" # Direct classification
}
class LLMEvaluator:
def __init__(self, task_name, model_name="gpt-4o"):
"""
Initialize LLM evaluator
Args:
dataset_name (str): Name of the dataset to evaluate
model_name (str): Name of the model to use
"""
self.task_name = task_name
# Initialize LLM caller
self.llm_caller = LLMCaller(model_name)
# Initialize graph embedder and evaluator
self.graph_embedder = GraphEmbedder(self.task_name)
self.extractor = AnswerExtractor(self.task_name)
self.evaluator = Evaluator(self.task_name)
# Load dataset
self.dataset = self._load_dataset()
def _load_dataset(self):
"""Load dataset based on task name"""
dataset_path = TASK_DATASET_MAPPING[self.task_name]
data = {}
# Check if path exists
if not os.path.exists(dataset_path):
raise FileNotFoundError(f"Dataset path not found: {dataset_path}")
# Load all files in the dataset directory
for file_name in os.listdir(dataset_path):
file_path = os.path.join(dataset_path, file_name)
if os.path.isfile(file_path):
file_data = load_data(file_path)
data[file_name] = file_data
return data
def process_single_data(self, graph_data):
"""
Process a single graph through the complete pipeline:
1. Generate prompt
2. Get LLM response
3. Extract and evaluate answer
Args:
graph_data: A single graph data object
Returns:
dict: Dictionary containing:
- prompt: Generated prompt
- response: Raw LLM response
- extracted_answer: Processed answer
- evaluation: Evaluation results
"""
# try:
# Step 1: Generate prompt for single graph
prompt = self.graph_embedder.embed_graph(graph_data)
# Step 2: Get LLM response
response = self.llm_caller.call(prompt)
# Step 3: Extract answer
extracted_answer = self.extractor.extract_answers(response)
return extracted_answer
def process_dataset(self):
"""
Process all graphs in all parquet files in the dataset.
Returns:
list: List of results for each file, where each file's results is a list of results for each graph
"""
all_results = {}
if self.task_name in ["S_0D", "S_1D", "S_Modification", "M_Merge", "M_Birth", "M_Filtration"]:
# Process each parquet file in the dataset
for file_idx, (file_name, file_data) in enumerate(self.dataset.items()):
print(f"\nProcessing file {file_idx + 1}/{len(self.dataset)}")
# Process each graph in the current file (DataFrame)
graph_datas = []
answers = []
for idx, row in file_data.iterrows():
# if idx >= 3: # Only process first 3 graphs
# break
print(f"Processing graph {idx + 1}/{len(file_data)} in file {file_idx + 1}")
# Convert DataFrame row to dict
graph_data = row.to_dict()
graph_datas.append(graph_data)
answer = self.process_single_data(graph_data)
answers.append(answer)
evaluation = self.evaluator.evaluate(graph_datas, answers)
all_results[file_name] = evaluation
return all_results
elif self.task_name in ["H_Selection", "H_Generation"]:
# Process each parquet file in the dataset
for file_idx, (file_name, file_data) in enumerate(self.dataset.items()):
print(f"\nProcessing file {file_idx + 1}/{len(self.dataset)}")
# Group data by pair_id
pairs = {}
for idx, row in file_data.iterrows():
pair_id = row['pair_id']
if pair_id not in pairs:
pairs[pair_id] = []
pairs[pair_id].append(row.to_dict())
# Process each pair
graph_datas = []
answers = []
pair_count = 0
for pair_id, pair_data in pairs.items():
if len(pair_data) != 2: # Skip if pair is incomplete
continue
# if pair_count >= 3: # Only process first 3 pairs
# break
# print(f"Processing pair {pair_id}")
# Sort by graph_position to ensure correct order
pair_data.sort(key=lambda x: x['graph_position'])
graph_datas.append(pair_data)
answer = self.process_single_data(pair_data)
answers.append(answer)
pair_count += 1
evaluation = self.evaluator.evaluate(graph_datas, answers)
all_results[file_name] = evaluation
return all_results
elif self.task_name in ["R_Selection", "R_Generation"]:
# Process each parquet file in the dataset
for file_idx, (file_name, file_data) in enumerate(self.dataset.items()):
print(f"\nProcessing file {file_idx + 1}/{len(self.dataset)}")
# Group data by group_id
groups = {}
for idx, row in file_data.iterrows():
group_id = row['group_id']
if group_id not in groups:
groups[group_id] = []
groups[group_id].append(row.to_dict())
# Process each group
graph_datas = []
answers = []
group_count = 0
for group_id, group_data in groups.items():
if len(group_data) != 4: # Skip if group is incomplete
continue
# if group_count >= 3: # Only process first 3 groups
# break
# Sort by graph_position to ensure correct order
group_data.sort(key=lambda x: x['graph_position'])
graph_datas.append(group_data)
answer = self.process_single_data(group_data)
answers.append(answer)
group_count += 1
evaluation = self.evaluator.evaluate(graph_datas, answers)
all_results[file_name] = evaluation
return all_results
|