Upload 12 files

README.md

@@ -0,0 +1,78 @@
+# LLM4PH: Large Language Models as Topological Thinkers
+
+This repository contains the benchmark code for our NeurIPS paper: "Large Language Models as Topological Thinkers: A Benchmark on Graph Persistent Homology".
+
+## Overview
+
+LLM4PH is a comprehensive benchmark designed to evaluate the capabilities of Large Language Models (LLMs) in understanding and reasoning about topological concepts, specifically focusing on graph persistent homology.
+
+## Dataset
+
+The benchmark consists of four difficulty levels of tasks:
+
+![llm4ph](llm4ph.png)
+
+Each level is designed to progressively challenge the model's understanding of topological concepts.
+
+## Code Structure
+
+The codebase is organized as follows:
+
+```
+LLM4PH/
+├── config.py           # Configuration settings for tasks and models
+├── main.py            # Main entry point for running the benchmark
+├── datasets/          # Dataset files for different difficulty levels
+├── evaluate_code/     # Evaluation scripts and metrics
+├── results/           # Directory for storing evaluation results
+└── .env              # Environment variables for API keys (create if needed)
+```
+Key components:
+- `config.py`: Configure task parameters and model settings
+- `main.py`: Run the benchmark with specified configurations
+- `evaluate_code/`: Contains evaluation logic and scoring metrics
+- `datasets/`: Stores the benchmark datasets
+- `results/`: Output directory for evaluation results
+
+## Installation
+
+Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+## Configuration
+
+The benchmark can be configured through `config.py`:
+
+- Task configuration: Set difficulty levels and evaluation parameters
+- Model configuration: Choose between local and API-based models
+
+### API Key Setup
+
+For closed-source models, create a `.env` file in the root directory:
+
+```bash
+touch .env
+```
+
+Add your API keys to the `.env` file:
+```
+OPENAI_API_KEY=your_key_here
+ANTHROPIC_API_KEY=your_key_here
+```
+
+## Usage
+
+1. Configure your desired task and model in `config.py`
+2. Run the benchmark:
+```bash
+python main.py
+```
+
+## Citation
+
+If you use this benchmark in your research, please cite our paper:
+```
+
+```

config.py

@@ -0,0 +1,10 @@
+# List of tasks to be processed
+TASKS = [
+    "R_Generation",
+    # Add more tasks as needed
+]
+
+# Model configuration
+MODEL_NAMES = [
+    "gpt-4o",  # You can change this to other model names if needed 
+]

evaluate_code/evaluate.py

@@ -0,0 +1,951 @@
+from typing import Tuple, Dict
+from evaluate_code.ph_utils import count_connected_components
+from evaluate_code.ph_utils import check_graph_group
+import statistics
+import numpy as np
+import json
+class Evaluator:
+    def __init__(self, task_name):
+        self.task_name = task_name
+    def evaluate(self, graph_data, extracted_answers):
+        """
+        Call the corresponding evaluation function based on the task type
+        
+        Args:
+            graph_data: List of graph data objects
+            extracted_answers: List of dicts with number_of_features
+            task_type: Task type
+        
+        Returns:
+            accuracy: accuracy
+            evaluation_results: dict containing detailed evaluation results and statistics
+        """
+        task_evaluators = {
+            "S_0D": self.evaluate_S_0D,
+            "S_1D": self.evaluate_S_1D,
+            "S_Modification": self.evaluate_S_Modification,
+            "M_Merge": self.evaluate_M_Merge,
+            "M_Birth": self.evaluate_M_Birth,
+            "M_Filtration": self.evaluate_M_Filtration,
+            "H_Selection": self.evaluate_H_Selection,
+            "H_Generation": self.evaluate_H_Generation,
+            "R_Selection": self.evaluate_R_Selection,
+            "R_Generation": self.evaluate_R_Generation,
+            "R_Classification": self.evaluate_R_Classification,
+        }
+    
+        if self.task_name not in task_evaluators:
+            raise ValueError(f"Unsupported task type: {self.task_name}")
+        
+        return task_evaluators[self.task_name](graph_data, extracted_answers)
+    
+    def evaluate_S_0D(self, graph_data, extracted_answers):
+        """
+        Evaluate the accuracy of the structure_0dim_identification task
+        
+        Args:
+            graph_data: List of graph data objects
+            extracted_answers: List of dicts with number_of_features
+        
+        Returns:
+            accuracy: accuracy
+            evaluation_results: dict containing detailed evaluation results and statistics
+        """
+        correct_count = 0
+        total_count = len(extracted_answers)
+        evaluation_results = []
+        
+        for i, answer in enumerate(extracted_answers):
+            if i >= len(graph_data):
+                break
+                
+          
+            correct_answer = graph_data[i]["num_components"]
+            
+        
+            predicted_answer = answer.get("connected_components")
+       
+            is_correct = predicted_answer == correct_answer
+            if is_correct:
+                correct_count += 1
+            
+        
+            evaluation_result = {
+                "is_correct": is_correct,
+                "predicted_answer": predicted_answer,
+                "correct_answer": correct_answer
+            }
+            evaluation_results.append(evaluation_result)
+        
+       
+        accuracy = correct_count / total_count if total_count > 0 else 0
+        
+        
+        stats = {
+            "total_samples": total_count,
+            "correct_count": correct_count,
+            "wrong_count": total_count - correct_count,
+            "accuracy": accuracy
+        }
+        
+        return accuracy, {
+            "statistics": stats,
+            "detailed_results": evaluation_results
+        }
+    def evaluate_S_1D(self, graph_data, extracted_answers):
+        """
+        Evaluate the accuracy of the structure_1dim_identification task, including two sets of metrics:
+        1. Whether the existence of 1-dimensional features is correctly judged (through the has_feature field)
+        2. For graphs with 1-dimensional features, whether the barcodes match completely
+        
+        Args:
+            graph_data: List of graph data objects
+            extracted_answers: List of dicts with has_feature and persistence_pairs
+        
+        Returns:
+            accuracy: accuracy of existence judgment
+            evaluation_results: dict containing detailed evaluation results and statistics
+        """
+        correct_count = 0
+        total_count = len(extracted_answers)
+        evaluation_results = []
+        
+        for i, answer in enumerate(extracted_answers):
+            if i >= len(graph_data):
+                break
+                
+          
+            correct_answer = graph_data[i]["num_holes"]
+            
+        
+            predicted_answer = answer.get("cycle_holes")
+            if predicted_answer is None:
+                evaluation_results.append({
+                    "index": i,
+                    "correct": correct_answer,
+                    "predicted": None,
+                    "match": False,
+                    "error": "Missing 'cycle_holes'"
+                })
+                continue
+            is_correct = predicted_answer == correct_answer
+            if is_correct:
+                correct_count += 1
+            
+        
+            evaluation_result = {
+                "is_correct": is_correct,
+                "predicted_answer": predicted_answer,
+                "correct_answer": correct_answer
+            }
+            evaluation_results.append(evaluation_result)
+        
+       
+        accuracy = correct_count / total_count if total_count > 0 else 0
+        
+        
+        stats = {
+            "total_samples": total_count,
+            "correct_count": correct_count,
+            "wrong_count": total_count - correct_count,
+            "accuracy": accuracy
+        }
+        
+        return accuracy, {
+            "statistics": stats,
+            "detailed_results": evaluation_results
+        }
+    def evaluate_S_Modification(self, graph_data, extracted_answers):
+        """
+        Evaluate graph_0dim_modification accuracy
+        
+        Args:
+            graph_data: List of graph data objects
+            extracted_answers: List of dicts with edge_to_add
+        
+        Returns:
+            accuracy: accuracy
+            evaluation_results: dict containing detailed evaluation results and statistics
+        """
+        correct_count = 0
+        total_count = len(graph_data)
+        evaluation_results = []
+        
+        for i, (graph, answer) in enumerate(zip(graph_data, extracted_answers)):
+            # Check answer format
+            if "error" in answer:
+                evaluation_results.append({
+                    "is_correct": False,
+                    "error": answer["error"]
+                })
+                continue
+            
+            if "edge_to_add" not in answer:
+                evaluation_results.append({
+                    "is_correct": False,
+                    "error": "Missing edge_to_add in answer"
+                })
+                continue
+            
+            # Get edge to add
+            edge_to_add = answer["edge_to_add"]
+            if len(edge_to_add) != 2:
+                evaluation_results.append({
+                    "is_correct": False,
+                    "error": f"Invalid edge format: {edge_to_add}"
+                })
+                continue
+            
+            # Get original edge index and node count
+            original_edge_index = graph["edge_index"]  # Shape [2,N]
+            num_nodes = graph["num_nodes"]
+            
+            # Ensure original_edge_index is 2D array
+            if len(original_edge_index.shape) == 1:
+                original_edge_index = original_edge_index.reshape(2, -1)
+            
+            # Validate node index range
+            if edge_to_add[0] >= num_nodes or edge_to_add[1] >= num_nodes:
+                evaluation_results.append({
+                    "is_correct": False,
+                    "error": f"Node indices out of range: {edge_to_add}, max index is {num_nodes-1}"
+                })
+                continue
+            
+            # Calculate original number of connected components
+            original_components = graph["num_components"]
+            
+            # Add new edge, maintaining [2,N] shape
+            new_edge = np.array([[edge_to_add[0]], [edge_to_add[1]]], dtype=np.int64)
+            new_edge_index = np.concatenate([original_edge_index, new_edge], axis=1)
+            
+            # Calculate new number of connected components
+            new_components = count_connected_components(new_edge_index, num_nodes)
+            
+            # Check if correct (number of connected components should decrease)
+            is_correct = new_components < original_components
+            
+            if is_correct:
+                correct_count += 1
+            
+            evaluation_results.append({
+                "is_correct": is_correct,
+                "edge_added": edge_to_add,
+                "original_components": original_components,
+                "new_components": new_components
+            })
+        
+        # Calculate accuracy
+        accuracy = correct_count / total_count if total_count > 0 else 0
+        
+        # Add statistics
+        stats = {
+            "total_samples": total_count,
+            "correct_count": correct_count,
+            "wrong_count": total_count - correct_count,
+            "accuracy": accuracy
+        }
+        
+        return accuracy, {
+            "statistics": stats,
+            "detailed_results": evaluation_results
+        }
+    
+    def evaluate_filtration_edge_construction(self, graph_data, extracted_answers):
+        """
+        Evaluate filtration edge construction accuracy
+        
+        Args:
+            graph_data: List of graph data objects
+            extracted_answers: List of dicts with sorted_edges
+        
+        Returns:
+            accuracy: accuracy
+            evaluation_results: dict containing detailed evaluation results and statistics
+        """
+        correct_count = 0
+        total_count = len(extracted_answers)
+        evaluation_results = []
+        
+        for i, answer in enumerate(extracted_answers):
+            if i >= len(graph_data):
+                break
+                
+            # get correct answer (sorted_edges)
+            correct_edges = graph_data[i]["sorted_edges"]
+            
+            # get predicted answer (filtration dictionary)
+            predicted_filtration = answer["filtration"]
+            
+            # convert predicted filtration to edge list format
+            predicted_edges = []
+            for value, edges in predicted_filtration.items():
+                for u, v in edges:
+                    predicted_edges.append((u, v, float(value)))
+            
+            # sort edges by weight (ascending)
+            predicted_edges.sort(key=lambda x: x[2])
+            
+            # check if correct
+            is_correct = len(predicted_edges) == len(correct_edges)
+            if is_correct:
+                for pred, corr in zip(predicted_edges, correct_edges):
+                    if pred != corr:
+                        is_correct = False
+                        break
+            
+            if is_correct:
+                correct_count += 1
+            
+            # record detailed evaluation results
+            evaluation_result = {
+                "is_correct": is_correct,
+                "predicted_edges": predicted_edges,
+                "correct_edges": correct_edges,
+                "edge_count_match": len(predicted_edges) == len(correct_edges),
+                "edge_order_match": is_correct
+            }
+            evaluation_results.append(evaluation_result)
+        
+        # calculate accuracy
+        accuracy = correct_count / total_count if total_count > 0 else 0
+        
+        # prepare statistics
+        stats = {
+            "total_samples": total_count,
+            "correct_count": correct_count,
+            "wrong_count": total_count - correct_count,
+            "accuracy": accuracy
+        }
+        
+        return accuracy, {
+            "statistics": stats,
+            "detailed_results": evaluation_results
+        }
+    
+    def evaluate_simplicial_complex_construction(self, graph_data, extracted_answers):
+        """
+        Evaluate simplicial complex construction accuracy
+        
+        Args:
+            graph_data: List of graph data objects
+            extracted_answers: List of dicts with simplicial_complexes
+        
+        Returns:
+            accuracy: accuracy
+            evaluation_results: dict containing detailed evaluation results and statistics
+        """
+        correct_count = 0
+        total_count = len(extracted_answers)
+        evaluation_results = []
+        
+        for i, answer in enumerate(extracted_answers):
+            if i >= len(graph_data):
+                break
+                
+            # get correct answer (2-dimensional simplices)
+            correct_simplices = {}
+            for simplex, value in graph_data[i]["simplex"]:
+                if len(simplex) == 3:  # only process 2-dimensional simplices
+                    if value not in correct_simplices:
+                        correct_simplices[value] = []
+                    correct_simplices[value].append(sorted(simplex))
+            
+            # get predicted answer
+            predicted_simplices = answer.get("simplicial_complexes", {})
+            
+            is_correct = True
+            
+            # check all filtration values
+            all_values = set(list(correct_simplices.keys()) + list(predicted_simplices.keys()))
+            for value in all_values:
+                correct = sorted([sorted(s) for s in correct_simplices.get(value, [])])
+                predicted = sorted([sorted(s) for s in predicted_simplices.get(value, [])])
+                
+                if correct != predicted:
+                    is_correct = False
+                    break
+            
+            if is_correct:
+                correct_count += 1
+            
+            # record detailed evaluation results
+            evaluation_result = {
+                "is_correct": is_correct,
+                "predicted_simplices": predicted_simplices,
+                "correct_simplices": correct_simplices,
+                "value_match": is_correct
+            }
+            evaluation_results.append(evaluation_result)
+        
+        # calculate accuracy
+        accuracy = correct_count / total_count if total_count > 0 else 0
+        
+            
+        stats = {
+            "total_samples": total_count,
+            "correct_count": correct_count,
+            "wrong_count": total_count - correct_count,
+            "accuracy": accuracy
+        }
+        
+        return accuracy, {
+            "statistics": stats,
+            "detailed_results": evaluation_results
+        }
+    
+    def evaluate_M_Merge(self, graph_data, extracted_answers):
+        """
+        Evaluate 0-dimensional persistent homology calculation accuracy
+        
+        Args:
+            graph_data: List of graph data objects
+            extracted_answers: List of dictionaries containing death time of feature
+        
+        Returns:
+            accuracy: accuracy
+            evaluation_results: dict containing detailed evaluation results and statistics
+        """
+        correct_count = 0
+        total_count = len(extracted_answers)
+        evaluation_results = []
+        
+        for i, answer in enumerate(extracted_answers):
+            if i >= len(graph_data):
+                break
+                
+            # get correct answer
+            correct_time = graph_data[i]["death_value"]
+            
+            # get predicted answer
+            if "error" in answer:
+                is_correct = False
+                predicted_time = None
+            else:
+                predicted_time = answer.get("death_time", [None])[0]  # Get first value from death_time list
+                is_correct = predicted_time == correct_time
+
+            if is_correct:
+                correct_count += 1
+            
+            evaluation_result = {
+                "is_correct": is_correct,
+                "predicted_time": predicted_time,
+                "correct_time": correct_time
+            }
+            evaluation_results.append(evaluation_result)
+        
+        accuracy = correct_count / total_count if total_count > 0 else 0
+        
+        stats = {
+            "total_samples": total_count,
+            "correct_count": correct_count,
+            "wrong_count": total_count - correct_count,
+            "accuracy": accuracy
+        }
+        
+        return accuracy, {
+            "statistics": stats,
+            "detailed_results": evaluation_results
+        }
+
+    def evaluate_M_Birth(self, graph_data, extracted_answers):
+        """
+        Evaluate 1-dimensional persistent homology calculation accuracy
+        
+        Args:
+            graph_data: List of graph data objects
+            extracted_answers: List of dicts with persistent_features
+        
+        Returns:
+            accuracy: accuracy
+            evaluation_results: dict containing detailed evaluation results and statistics
+        """
+        correct_count = 0
+        total_count = len(extracted_answers)
+        evaluation_results = []
+        
+        for i, answer in enumerate(extracted_answers):
+            if i >= len(graph_data):
+                break
+                
+            # get correct answer
+            correct_time = graph_data[i]["birth_value"]
+            
+            # get predicted answer
+            if "error" in answer:
+                is_correct = False
+                predicted_time = None
+            else:
+                predicted_time = answer.get("birth_time", [None])[0]  # Get first value from death_time list
+                is_correct = predicted_time == correct_time
+
+            if is_correct:
+                correct_count += 1
+            
+            evaluation_result = {
+                "is_correct": is_correct,
+                "predicted_time": predicted_time,
+                "correct_time": correct_time
+            }
+            evaluation_results.append(evaluation_result)
+        
+        accuracy = correct_count / total_count if total_count > 0 else 0
+        
+        stats = {
+            "total_samples": total_count,
+            "correct_count": correct_count,
+            "wrong_count": total_count - correct_count,
+            "accuracy": accuracy
+        }
+        
+        return accuracy, {
+            "statistics": stats,
+            "detailed_results": evaluation_results
+        }
+    def evaluate_M_Filtration(self, graph_data, extracted_answers):
+        """
+        Evaluate filtration_features_count accuracy
+        
+        Args:
+            graph_data: List of graph data objects
+            extracted_answers: filtration_features_count number
+        
+        Returns:
+            accuracy: accuracy
+            evaluation_results: dict containing detailed evaluation results and statistics
+        """
+        correct_count = 0
+        total_count = len(extracted_answers)
+        evaluation_results = []
+        
+        for i, answer in enumerate(extracted_answers):
+            if i >= len(graph_data):
+                break
+                
+            # get correct answer
+            correct_n = graph_data[i]["t3_0dim"]
+            
+            # get predicted answer
+            if "error" in answer:
+                is_correct = False
+                predicted_count = None
+            else:
+                predicted_count = answer.get("connected_components", [None])[0]  # Get first value from death_time list
+                is_correct = predicted_count == correct_n
+
+            if is_correct:
+                correct_count += 1
+            
+            evaluation_result = {
+                "is_correct": is_correct,
+                "predicted_count": predicted_count,
+                "correct_count": correct_n
+            }
+            evaluation_results.append(evaluation_result)
+        
+        accuracy = correct_count / total_count if total_count > 0 else 0
+        
+        stats = {
+            "total_samples": total_count,
+            "correct_count": correct_count,
+            "wrong_count": total_count - correct_count,
+            "accuracy": accuracy
+        }
+        
+        return accuracy, {
+            "statistics": stats,
+            "detailed_results": evaluation_results
+        }
+    def _check_edge_sorting(self, edge_sorting, graph_data):
+        """Check if edge sorting is correct"""
+
+        try:
+           
+            if not edge_sorting:
+                return False
+            
+            
+            for i in range(1, len(edge_sorting)):
+                if edge_sorting[i][2] < edge_sorting[i-1][2]:
+                    return False
+            
+            return True
+        except:
+            return False
+    
+
+
+    def evaluate_H_Selection(self, graph_data, extracted_answers) -> Tuple[float, Dict]:
+        """
+        Evaluate filtration method selection ranking statistics
+        
+        Args:
+            graph_data: List of graph data objects, where graph_data[2i].better_filter contains correct answer
+            extracted_answers: List of dicts with selected_method
+            
+        Returns:
+            Tuple of (accuracy, detailed results dict)
+        """
+        detailed_results = []
+        
+        all_ranks = []
+        top1_count = 0
+        top2_count = 0
+        top3_count = 0
+        
+        for i, answer in enumerate(extracted_answers):
+            if answer is None or answer.get("selected_method") is None:
+                detailed_results.append({
+                    "reason": "No valid answer extracted"
+                })
+                continue
+                
+            graph_idx = i
+            if graph_idx >= len(graph_data):
+                break
+                
+            predicted_method = answer["selected_method"]
+            if predicted_method == 'weight':
+                predicted_method = 'e'
+            if predicted_method == "k-shell":
+                predicted_method = "k_shell"
+            dist_features = {'dist_k_shell': graph_data[graph_idx][0]['dist_k_shell'], 'dist_closeness': graph_data[graph_idx][0]['dist_closeness'], 'dist_e': graph_data[graph_idx][0]['dist_e'], 'dist_betweenness': graph_data[graph_idx][0]['dist_betweenness'], 'dist_degree': graph_data[graph_idx][0]['dist_degree'], 'dist_eigenvector': graph_data[graph_idx][0]['dist_eigenvector']}
+            
+            predicted_rank = None
+            current_rank = 1
+            current_distance = None
+            same_rank_count = 0
+            
+            for method, distance in dist_features.items():
+                if current_distance is not None and distance != current_distance:
+                    current_rank += same_rank_count
+                    same_rank_count = 0
+                    current_distance = distance
+                elif current_distance is None:
+                    current_distance = distance
+                
+                if method.replace('dist_', '') == predicted_method:
+                    predicted_rank = current_rank
+                    all_ranks.append(current_rank)
+                    if current_rank == 1:
+                        top1_count += 1
+                    if current_rank <= 2:
+                        top2_count += 1
+                    if current_rank <= 3:
+                        top3_count += 1
+                    break
+                
+                same_rank_count += 1
+            
+            detailed_results.append({
+                "predicted": predicted_method,
+                "predicted_rank": predicted_rank,
+                "method_rankings": dict(dist_features)
+            })
+        
+        ranking_stats = {
+            'mean_rank': sum(all_ranks) / len(all_ranks) if all_ranks else float('inf'),
+            'min_rank': min(all_ranks) if all_ranks else float('inf'),
+            'max_rank': max(all_ranks) if all_ranks else float('inf'),
+            'std_rank': statistics.stdev(all_ranks) if len(all_ranks) > 1 else 0,
+            'total_predictions': len(all_ranks),
+            'top1_count': top1_count,
+            'top2_count': top2_count,
+            'top3_count': top3_count,
+            'top1_ratio': top1_count / len(all_ranks) if all_ranks else 0,
+            'top2_ratio': top2_count / len(all_ranks) if all_ranks else 0,
+            'top3_ratio': top3_count / len(all_ranks) if all_ranks else 0
+        }
+        
+        return 0.0, {
+            "statistics": {
+                **ranking_stats
+            },
+            "detailed_results": detailed_results
+        }
+
+    def evaluate_H_Generation(self, graph_data, extracted_answers) -> Tuple[float, Dict]:
+        """
+        评估过滤序列选择的排名统计
+        
+        Args:
+            graph_data: List of graph data objects
+            extracted_answers: List of dicts with selected_filtration_values field
+            
+        Returns:
+            Tuple (accuracy, detailed_results_dict)
+        """
+        total = 0
+        detailed_results = []
+        
+        for i, answer in enumerate(extracted_answers):
+            if i >= len(graph_data):
+                break
+                
+            if answer is None or "selected_filtration_values" not in answer:
+                detailed_results.append({
+                    "reason": "No valid answer extracted"
+                })
+                continue
+            
+            graph1 = graph_data[i][0]
+
+            selected_values = answer["selected_filtration_values"]
+            if isinstance(selected_values, (int, float)):
+                selected_values = [[selected_values]]
+            elif isinstance(selected_values, (list, tuple)) and not any(isinstance(x, (list, tuple)) for x in selected_values):
+                selected_values = [selected_values]
+            
+            selected_distances = []
+            selected_ranks = []
+            
+            for seq in selected_values:
+                if not isinstance(seq, (list, tuple)):
+                    seq = [seq]
+                seq_tuple = tuple(sorted(float(x) if isinstance(x, (int, float)) else x for x in seq))
+                
+                found_match = False
+                current_rank = 1
+                current_distance = None
+                same_rank_count = 0
+                sorted_distances = json.loads(graph1['sorted_distances'])
+                for item in sorted_distances:
+                    curr_seq = item['nodes']
+                    distance = item['distance']
+                    curr_seq_tuple = tuple(sorted(float(x) if isinstance(x, (int, float)) else x for x in curr_seq))
+                    
+                    if current_distance is not None and distance != current_distance:
+                        current_rank += same_rank_count
+                        same_rank_count = 0
+                        current_distance = distance
+                    elif current_distance is None:
+                        current_distance = distance
+                        
+                    if curr_seq_tuple == seq_tuple:
+                        selected_distances.append(float(distance))
+                        selected_ranks.append(current_rank)
+                        found_match = True
+                        break
+                        
+                    same_rank_count += 1
+                
+                if not found_match:
+                    selected_distances.append(float('inf'))
+                    selected_ranks.append(len(graph1.sorted_distances) + 1)
+            
+            rank = sum(selected_ranks) / len(selected_ranks) if selected_ranks else float('inf')
+            
+            in_top3 = sum(1 for rank in selected_ranks if rank <= 3)
+            in_top10 = sum(1 for rank in selected_ranks if rank <= 10)
+            top3 = in_top3 / len(selected_ranks) if selected_ranks else 0
+            top10 = in_top10 / len(selected_ranks) if selected_ranks else 0
+            
+            total += 1
+            
+            detailed_results.append({
+                "selected_ranks": selected_ranks,
+                "selected_distances": selected_distances,
+                "rank": float(rank),
+                "top3": float(top3),
+                "top10": float(top10),
+                "original_values": selected_values
+            })
+        
+        valid_results = [r for r in detailed_results if "rank" in r]
+        rank_list = [r["rank"] for r in valid_results]
+
+        avg_stats = {
+            "mean_rank": float(sum(rank_list) / len(rank_list)) if rank_list else float('inf'),
+            "top3": float(sum(r["top3"] for r in valid_results) / len(valid_results)) if valid_results else 0.0,
+            "top10": float(sum(r["top10"] for r in valid_results) / len(valid_results)) if valid_results else 0.0,
+            "std_rank": float(statistics.stdev(rank_list)) if len(rank_list) > 1 else 0.0
+        }
+        
+        return 0.0, {
+            "statistics": {
+                "total": int(total),
+                **avg_stats
+            },
+            "detailed_results": detailed_results
+        }
+        
+    def evaluate_R_Classification(self, graph_data, extracted_answers):
+        correct_count = 0
+        total_count = len(extracted_answers)
+        evaluation_results = []
+
+        ground_truth_sorted = sorted([sorted([1, 2]), sorted([3, 4])])
+
+        for i, answer in enumerate(extracted_answers):
+            if "error" in answer or "categories" not in answer:
+                evaluation_results.append({
+                    "index": i,
+                    "is_correct": False,
+                    "reason": "Missing or invalid 'categories' field",
+                    "predicted": None,
+                    "expected": ground_truth_sorted
+                })
+                continue
+
+            predicted = answer["categories"]
+
+            try:
+                predicted_sorted = sorted([sorted(group) for group in predicted])
+                is_correct = predicted_sorted == ground_truth_sorted
+            except Exception as e:
+                is_correct = False
+                predicted_sorted = None
+
+            if is_correct:
+                correct_count += 1
+
+            evaluation_results.append({
+                "index": i,
+                "is_correct": is_correct,
+                "predicted": predicted,
+                "expected": ground_truth_sorted
+            })
+
+        accuracy = correct_count / total_count if total_count > 0 else 0.0
+
+        stats = {
+            "total_samples": total_count,
+            "correct_count": correct_count,
+            "wrong_count": total_count - correct_count,
+            "accuracy": accuracy
+        }
+
+        return accuracy, {
+            "statistics": stats,
+            "detailed_results": evaluation_results
+        }
+
+    
+    def evaluate_R_Selection(self, graph_data, extracted_answers):
+        """
+        Evaluate whether the selected filtration method is correct based on method_dict.
+        
+        Args:
+            graph_data: List of graph data entries, where each entry is a tuple (graph, ...) and graph.method_dict is a dict
+            extracted_answers: List of dicts with key 'selected_method'
+        
+        Returns:
+            accuracy: float
+            result_summary: dict with statistics and detailed evaluation results
+        """
+        correct_count = 0
+        total_count = len(extracted_answers)
+        evaluation_results = []
+
+        for i, answer in enumerate(extracted_answers):
+            if i >= len(graph_data):
+                break
+
+            method_dict = {
+            'weight': graph_data[i][0]['method_weight'],
+            'degree': graph_data[i][0]['method_degree'],
+            'betweenness': graph_data[i][0]['method_betweenness'],
+            'k_shell': graph_data[i][0]['method_k_shell'],
+            'closeness': graph_data[i][0]['method_closeness'],
+            'eigenvector': graph_data[i][0]['method_eigenvector']
+            }
+
+            if "error" in answer or "selected_method" not in answer:
+                evaluation_results.append({
+                    "index": i,
+                    "is_correct": False,
+                    "predicted_method": answer.get("selected_method", None),
+                    "expected_methods": [k for k, v in method_dict.items() if v],
+                    "reason": "No valid method extracted"
+                })
+                continue
+            predicted_method = answer.get("selected_method")
+
+            if predicted_method not in method_dict:
+                return {"error": f"Invalid method selected: {predicted_method}"}
+
+            is_correct = bool(method_dict[predicted_method])
+
+            if is_correct:
+                correct_count += 1
+
+            evaluation_results.append({
+                "index": i,
+                "is_correct": is_correct,
+                "predicted_method": predicted_method,
+                "expected_methods": [k for k, v in method_dict.items() if v]
+            })
+
+        accuracy = correct_count / total_count if total_count > 0 else 0.0
+
+        stats = {
+            "total_samples": total_count,
+            "correct_count": correct_count,
+            "wrong_count": total_count - correct_count,
+            "accuracy": accuracy
+        }
+
+        return accuracy, {
+            "statistics": stats,
+            "detailed_results": evaluation_results
+        }
+
+    def evaluate_R_Generation(self, graph_data, extracted_answers):
+        """
+        Evaluate predictions based on filtration_values using check_filt_value().
+        
+        Args:
+            graph_data: List of graph data objects
+            extracted_answers: List of dicts with key 'filtration_values'
+        
+        Returns:
+            accuracy: float
+            result_summary: dict with statistics and detailed evaluation results
+        """
+        correct_count = 0
+        total_count = len(extracted_answers)
+        evaluation_results = []
+
+        for i, answer in enumerate(extracted_answers):
+            if i >= len(graph_data):
+                break
+
+            if "error" in answer or "filtration_values" not in answer:
+                evaluation_results.append({
+                    "index": i,
+                    "is_correct": False,
+                    "predicted_values": answer.get("filtration_values", None),
+                    "reason": "No valid filtration_values extracted"
+                })
+                continue
+
+            filtration_values = answer["filtration_values"]
+
+            is_correct,distances = check_graph_group(graph_data[i], method='weight',pre_calculate=False,filt_value=filtration_values)
+  
+            if is_correct:
+                correct_count += 1
+                correct = "True"
+            else:
+                correct = "False"
+            evaluation_results.append({
+                "index": i,
+                "is_correct": correct,
+                "predicted_values": filtration_values,
+                "correct": correct
+            })
+
+        accuracy = correct_count / total_count if total_count > 0 else 0.0
+
+        stats = {
+            "total_samples": total_count,
+            "correct_count": correct_count,
+            "wrong_count": total_count - correct_count,
+            "accuracy": accuracy
+        }
+
+        return accuracy, {
+            "statistics": stats,
+            "detailed_results": evaluation_results
+        }

evaluate_code/extract.py

@@ -0,0 +1,633 @@
+from typing import Dict, List, Any
+import re
+
+def _extract_section(text: str, start_marker: str, end_marker: str) -> str:
+    """Extract content between two markers"""
+    start = text.find(start_marker)
+    if start == -1:
+        return ""
+    start += len(start_marker)
+    end = text.find(end_marker, start)
+    if end == -1:
+        return ""
+    return text[start:end].strip()
+
+class AnswerExtractor:
+    def __init__(self, task_name):
+        """Initialize answer extractor"""
+        self.task_name = task_name
+    
+    def extract_answers(self, response):
+        """Extract answers based on task type"""
+        try:
+            task_extractors = {
+                "S_0D": self.extract_S_0D,
+                "S_1D": self.extract_S_1D,
+                "S_Modification": self.extract_S_Modification,
+                "M_Birth": self.extract_M_Birth,
+                "M_Merge": self.extract_M_Merge,
+                "M_Filtration": self.extract_M_Filtration,
+                "H_Selection": self.extract_H_Selection,
+                "H_Generation": self.extract_H_Generation,
+                "R_Selection": self.extract_R_Selection,
+                "R_Generation": self.extract_R_Generation,
+                "R_Directly": self.extract_R_Directly
+            }
+            
+            answer = task_extractors.get(self.task_name)(response) if self.task_name in task_extractors else None
+            
+            return answer
+        except Exception as e:
+            print(f"Error extracting answer: {str(e)}")
+            return None
+    
+    
+    def extract_S_0D(self, answer: str) -> Dict[str, Any]:
+        """Extract information from 0-dimensional topology structure identification answer"""
+        try:
+            # Extract the answer section
+            answer_section = answer
+            if "Answer:" in answer:
+                answer_section = answer.split("Answer:")[-1].strip()
+            
+            # Extract the filtration value with more flexible pattern matching
+            value_match = re.search(r'connected components:\s*(\d+)', answer_section)
+            if not value_match:
+                return {"error": "connected components not found"}
+            
+            # Parse the value
+            try:
+                value = int(value_match.group(1).strip())
+                return {
+                    "connected_components": value
+                }
+            except ValueError as e:
+                return {"error": f"Error parsing value: {str(e)}"}
+            
+        except Exception as e:
+            return {"error": f"Error during extraction: {str(e)}"}
+        
+    def extract_S_1D(self, answer: str) -> Dict[str, Any]:
+        """Extract information from 1-dimensional topology structure identification answer"""
+        try:
+            # Extract the answer section
+            answer_section = answer
+            if "Answer:" in answer:
+                answer_section = answer.split("Answer:")[-1].strip()
+            
+            # Extract the filtration value with more flexible pattern matching
+            value_match = re.search(r'cycle holes:\s*(\d+)', answer_section)
+            if not value_match:
+                return {"error": "cycle holes not found"}
+            
+            # Parse the value
+            try:
+                value = int(value_match.group(1).strip())
+                return {
+                    "cycle_holes": value
+                }
+            except ValueError as e:
+                return {"error": f"Error parsing value: {str(e)}"}
+            
+        except Exception as e:
+            return {"error": f"Error during extraction: {str(e)}"}
+
+
+    def extract_S_Modification(self, answer: str) -> Dict[str, Any]:
+        """Extract information from graph structure modification answer"""
+        try:
+            # Extract the answer section
+            answer_section = answer
+            if "Answer:" in answer:
+                answer_section = answer.split("Answer:")[-1].strip()
+            
+            # Try multiple matching patterns
+            patterns = [
+                r'Edge to add:\s*\[(.*?)\]',  # Match "Edge to add: [0, 7]" format
+                r'Edge to add:\s*\((\d+)\s*,\s*(\d+)\)',  # Match "Edge to add: (0, 7)" format
+                r'Edge to add:\s*(\d+)\s*-\s*(\d+)',  # Match "Edge to add: 0-7" format
+                r'Edge to add:\s*(\d+)\s*,\s*(\d+)'  # Match "Edge to add: 0, 7" format
+            ]
+            
+            for pattern in patterns:
+                value_match = re.search(pattern, answer_section)
+                if value_match:
+                    try:
+                        if pattern == r'Edge to add:\s*\[(.*?)\]':
+                            # Handle [0, 7] format
+                            values_str = value_match.group(1).strip()
+                            values = [int(x.strip()) for x in values_str.split(',')]
+                        else:
+                            # Handle other formats
+                            values = [int(value_match.group(1)), int(value_match.group(2))]
+                        
+                        return {
+                            "edge_to_add": values
+                        }
+                    except (ValueError, IndexError):
+                        continue
+            
+            return {"error": "Edge to add not found or invalid format"}
+            
+        except Exception as e:
+            return {"error": f"Error during extraction: {str(e)}"}
+        
+        
+    def extract_M_Birth(self, answer: str) -> Dict[str, Any]:
+        """Extract birth time calculation task answer"""
+        try:
+            # Extract the answer section
+            answer_section = answer
+            if "Answer:" in answer:
+                answer_section = answer.split("Answer:")[-1].strip()
+            
+            # Extract the filtration value
+            value_match = re.search(r'birth time:\s*\[(.*?)\]', answer_section)
+            if not value_match:
+                return {"error": "birth_time not found"}
+            
+            # Parse the values
+            try:
+                values = [self._parse_number(x) for x in value_match.group(1).split(',')]
+                return {
+                    "birth_time": values
+                }
+            except ValueError as e:
+                return {"error": f"Error parsing : {str(e)}"}
+            
+        except Exception as e:
+            return {"error": f"Error during extraction: {str(e)}"}
+
+    def extract_M_Merge(self, answer: str) -> Dict[str, Any]:
+        """Extract information from 0-dimensional persistent homology calculation task answer"""
+        try:
+            # Extract the answer section
+            answer_section = answer
+            if "Answer:" in answer:
+                answer_section = answer.split("Answer:")[-1].strip()
+            
+            # Extract the filtration value
+            value_match = re.search(r'death time:\s*\[(.*?)\]', answer_section)
+            if not value_match:
+                return {"error": "death_time not found"}
+            
+            # Parse the values
+            try:
+                values = [self._parse_number(x) for x in value_match.group(1).split(',')]
+                return {
+                    "death_time": values
+                }
+            except ValueError as e:
+                return {"error": f"Error parsing : {str(e)}"}
+            
+        except Exception as e:
+            return {"error": f"Error during extraction: {str(e)}"}
+        
+    def extract_M_Filtration(self,answer:str) -> Dict[str, Any]:
+        try:
+            # Extract the answer section
+            answer_section = answer
+            if "Answer:" in answer:
+                answer_section = answer.split("Answer:")[-1].strip()
+            
+            # Extract the filtration value
+            value_match = re.search(r'connected components:\s*\[(.*?)\]', answer_section)
+            if not value_match:
+                return {"error": "connected components not found"}
+            
+            # Parse the values
+            try:
+                values = [self._parse_number(x) for x in value_match.group(1).split(',')]
+                return {
+                    "connected_components": values
+                }
+            except ValueError as e:
+                return {"error": f"Error parsing : {str(e)}"}
+            
+        except Exception as e:
+            return {"error": f"Error during extraction: {str(e)}"}
+
+    def extract_H_Selection(self, answer: str) -> Dict[str, Any]:
+        """Extract selected filtration method from the response"""
+        try:
+            # Extract the answer section
+            answer_section = answer
+            if "Answer:" in answer:
+                answer_section = answer.split("Answer:")[-1].strip()
+            # Try multiple matching patterns
+            patterns = [
+                r'Method:\s*([\w-]+)',  # Match "Method: k-shell" format
+                r'Method:\s*\[([\w-]+)\]',  # Match "Method: [k-shell]" format
+                r'selected_method:\s*([\w-]+)',  # Match "selected_method: k-shell" format
+                r'Selected Method:\s*([\w-]+)'  # Match "Selected Method: k-shell" format
+            ]
+
+            for pattern in patterns:
+                value_match = re.search(pattern, answer_section, re.IGNORECASE)
+                if value_match:
+                    method = value_match.group(1).strip().lower()
+                    # Validate method name
+                    valid_methods = ['degree', 'betweenness', 'k-shell', 'closeness', 'weight', 'eigenvector']
+                    if method in valid_methods:
+                        return {
+                            "selected_method": method
+                        }
+
+            return {"error": "Method not found or invalid"}
+            
+        except Exception as e:
+            return {"error": f"Error during extraction: {str(e)}"}
+
+
+    def extract_H_Generation(self, answer: str) -> Dict[str, Any]:
+        """Extract information from filteration value selection task answer"""
+        try:
+            # Extract the answer section
+            answer_section = answer
+            if "Answer:" in answer:
+                answer_section = answer.split("Answer:")[-1].strip()
+            
+            # Extract the filtration value
+            value_match = re.search(r'filtration value:\s*\[(.*?)\]', answer_section)
+            if not value_match:
+                return {"error": "Filtration value not found"}
+            
+            # Parse the values
+            try:
+                values = [int(x.strip()) for x in value_match.group(1).split(',')]
+                return {
+                    "selected_filtration_values": values
+                }
+            except ValueError as e:
+                return {"error": f"Error parsing filtration values: {str(e)}"}
+            
+        except Exception as e:
+            return {"error": f"Error during extraction: {str(e)}"}
+        
+    def extract_filtration_edge_construction(self, answer: str) -> Dict[str, Any]:
+        """Extract information from filtration edge construction task answer"""
+        result = {
+            "filtration": {}
+        }
+        
+        try:
+            # Extract filtration process
+            filtration_section = _extract_section(answer, "===FILTRATION_START===", "===FILTRATION_END===")
+            result["filtration"] = self._parse_filtration_edges(filtration_section)
+            
+            # Validate results
+            if not result["filtration"]:
+                print("Warning: Failed to extract filtration process")
+                print("Filtration process:", result["filtration"])
+            
+        except Exception as e:
+            import traceback
+            print(f"Error during extraction: {str(e)}")
+            print("Error details:")
+            print(traceback.format_exc())
+            return result  # Return partially parsed results instead of None
+        
+        return result
+    
+    def extract_simplicial_complex_construction(self, answer: str) -> Dict[str, Any]:
+        """
+        Extract answer for simplicial_complex_construction task
+        
+        Parameters:
+            answer: Model generated answer text
+        
+        Returns:
+            dict: Contains extracted simplicial complex information
+        """
+        try:
+            # Extract simplicial complex section
+            simplex_text = self._extract_section(answer, "===SIMPLICIAL_COMPLEX_START===", "===SIMPLICIAL_COMPLEX_END===")
+            if not simplex_text:
+                return {"error": "Simplicial complex section not found"}
+            
+            # Parse simplicial complex
+            simplices = {}
+            
+            for line in simplex_text.split('\n'):
+                line = line.strip()
+                if not line:
+                    continue
+                    
+                # Check if it's a simplex
+                if line.startswith('[') and line.endswith(']'):
+                    try:
+                        # Parse node list and filtration value
+                        content = line[1:-1]  # Remove outer brackets
+                        nodes_part, value_part = content.split('),')
+                        nodes = [int(x.strip()) for x in nodes_part[1:].split(',')]  # Remove inner brackets
+                        value = float(value_part.strip())
+                        
+                        if len(nodes) == 3:  # Only process 2-dimensional simplices (triangles)
+                            if value not in simplices:
+                                simplices[value] = []
+                            simplices[value].append(nodes)
+                    except (ValueError, IndexError) as e:
+                        print(f"Error parsing simplex: {line}, error: {str(e)}")
+                        continue
+            
+            return {
+                "simplicial_complexes": simplices
+            }
+            
+        except Exception as e:
+            return {"error": f"Error during extraction: {str(e)}"}
+    
+    def _parse_number(self, value_str: str) -> float:
+        """Parse number intelligently, try integer first, then float"""
+        value_str = value_str.strip()
+        try:
+            # Try parsing as integer first
+            return int(value_str)
+        except ValueError:
+            try:
+                # If integer parsing fails, try parsing as float
+                value = float(value_str)
+                # If it's an integer (no decimal part), return integer
+                if value.is_integer():
+                    return int(value)
+                return value
+            except ValueError:
+                raise ValueError(f"Cannot parse number: {value_str}")
+
+    def extract_R_Selection(self, answer: str) -> Dict[str, Any]:
+        """Extract selected filtration method from the response"""
+        try:
+            # Extract the answer section
+            answer_section = answer
+            if "Answer:" in answer:
+                answer_section = answer.split("Answer:")[-1].strip()
+
+            # Try multiple matching patterns
+            patterns = [
+                r'Method:\s*(\w+)',  # Match "Method: weight" format
+                r'Method:\s*\[(.*?)\]',  # Match "Method: [weight]" format
+                r'selected_method:\s*(\w+)',  # Match "selected_method: weight" format
+                r'Selected Method:\s*(\w+)'  # Match "Selected Method: weight" format
+            ]
+
+            for pattern in patterns:
+                value_match = re.search(pattern, answer_section, re.IGNORECASE)
+                if value_match:
+                    method = value_match.group(1).strip().lower()
+                    # 验证方法名称是否有效
+                    valid_methods = ['degree', 'betweenness', 'k-shell', 'closeness', 'weight','eigenvector']
+                    if method in valid_methods:
+                        return {
+                            "selected_method": method
+                        }
+
+            return {"error": "Method not found or invalid"}
+            
+        except Exception as e:
+            return {"error": f"Error during extraction: {str(e)}"}
+        
+
+    def extract_R_Generation(self, answer: str) -> Dict[str, Any]:
+        """Extract filtration values from the response"""
+        try:
+            # Extract content after "Answer:" if present
+            answer_section = answer
+            if "Answer:" in answer:
+                answer_section = answer.split("Answer:")[-1].strip()
+
+            # Match pattern like Filtration value: [0.1,0.4,0.5,...]
+            pattern = r'Filtration\s*value[s]?:\s*\[([^\]]+)\]'
+            match = re.search(pattern, answer_section, re.IGNORECASE)
+            if not match:
+                return {"error": "Filtration values not found"}
+
+            # Extract numbers inside brackets, split by comma and convert to float
+            nums_str = match.group(1)
+            values: List[float] = []
+            for part in nums_str.split(','):
+                part = part.strip()
+                if part:
+                    try:
+                        values.append(float(part))
+                    except ValueError:
+                        return {"error": f"Cannot convert '{part}' to float"}
+            
+            return {"filtration_values": values}
+
+        except Exception as e:
+            return {"error": f"Error during extraction: {str(e)}"}
+    
+    def extract_R_Directly(self, answer: str) -> Dict[str, Any]:
+        """Extract category classification from the response"""
+        # Get content after "Answer:" if present
+        if "Answer:" in answer:
+            answer_section = answer.split("Answer:")[-1].strip()
+        else:
+            answer_section = answer
+        pattern = r'Category:\s*[\[\(]\s*([\d\.\s,]+)[\]\)]\s*,\s*[\[\(]\s*([\d\.\s,]+)[\]\)]'
+        match = re.search(pattern, answer_section, re.IGNORECASE | re.DOTALL)
+        if not match:
+            return {"error": "Category format not found or incorrect"}
+
+        def parse_group(group_str: str) -> List[int]:
+            return [int(float(x.strip())) for x in group_str.split(',') if x.strip()]
+
+        category1 = parse_group(match.group(1))
+        category2 = parse_group(match.group(2))
+
+        all_indices = sorted(category1 + category2)
+        if all_indices != [1, 2, 3, 4]:
+            return {"error": f"Graph indices must be [1, 2, 3, 4], got: {all_indices}"}
+
+        return {
+            "categories": [category1, category2]
+        }
+
+    # def _parse_filtration_edges(self, section: str) -> Dict[float, List[Tuple[int, int]]]:
+    #     """Parse filtration process, specific to the format of filtration edge construction task"""
+    #     filtration = {}
+    #     current_value = None
+    #     for line in section.split('\n'):
+    #         line = line.strip()
+    #         if line.startswith('**Value='):
+    #             value_part = line.replace('**', '').replace('Value=', '').strip()
+    #             current_value = float(value_part)
+    #             filtration[current_value] = []
+    #         elif line.startswith('(') and line.endswith(')'):
+    #             try:
+    #                 u, v = map(int, line[1:-1].split(','))
+    #                 filtration[current_value].append((u, v))
+    #             except:
+    #                 print(f"Cannot parse edge: {line}")
+    #     return filtration
+    
+    
+    # def extract_structure_identification(self, answer: str) -> Dict[str, Any]:
+    #     """Extract information from topology structure identification answer"""
+    #     result = {
+    #         "cavities": [],
+    #         "temporal_evolution": {}
+    #     }
+        
+    #     # Extract cavity information
+    #     if "2-DIMENSIONAL CAVITIES:" in answer:
+    #         cavities_section = self._extract_section(
+    #             answer, "2-DIMENSIONAL CAVITIES:", "TEMPORAL EVOLUTION:"
+    #         )
+    #         result["cavities"] = self._extract_cavities(cavities_section)
+        
+    #     # Extract temporal evolution
+    #     if "TEMPORAL EVOLUTION:" in answer:
+    #         evolution_section = answer.split("TEMPORAL EVOLUTION:")[1]
+    #         result["temporal_evolution"] = self._extract_temporal_evolution(evolution_section)
+        
+    #     return result
+    
+
+    # def extract_simplex_structure_identification(self, answer: str) -> Dict[str, Any]:
+    #     """Extract information from simplex structure identification answer"""
+    #     result = {
+    #         "simplex_count": 0
+    #     }
+        
+    #     lines = answer.strip().split('\n')
+    #     for line in lines:
+    #         line = line.strip()
+    #         if line.startswith('2维单纯形数量：'):
+    #             count_str = line.split('：')[1].strip()
+    #             try:
+    #                 result["simplex_count"] = int(count_str)
+    #             except ValueError:
+    #                 # Keep default value 0 if cannot parse as integer
+    #                 pass
+        
+    #     return result
+    
+    # def _extract_section(self, text: str, start_marker: str, end_marker: str) -> str:
+    #     """Extract text between two markers"""
+    #     if start_marker in text and end_marker in text:
+    #         start_idx = text.find(start_marker) + len(start_marker)
+    #         end_idx = text.find(end_marker)
+    #         return text[start_idx:end_idx].strip()
+    #     return ""
+    
+    
+
+    
+    # def _extract_list(self, text: str) -> List:
+    #     """Extract list from text"""
+    #     items = text.split(':')[1].strip()
+    #     if items.startswith('[') and items.endswith(']'):
+    #         return eval(items)
+    #     return []
+    
+    # def _extract_feature_info(self, line: str) -> Dict[str, Any]:
+    #     """Extract feature information from text"""
+    #     info = {}
+    #     if 'Birth time:' in line:
+    #         info['birth'] = float(line.split(':')[1].strip())
+    #     elif 'Death time:' in line:
+    #         info['death'] = float(line.split(':')[1].strip())
+    #     elif 'Persistence:' in line:
+    #         info['persistence'] = float(line.split(':')[1].strip())
+    #     elif 'Description:' in line:
+    #         info['description'] = line.split(':')[1].strip()
+    #     return info
+
+    
+    # def _extract_cavities(self, text: str) -> List[Dict[str, Any]]:
+    #     """Extract cavity information"""
+    #     cavities = []
+    #     current_cavity = None
+        
+    #     for line in text.split('\n'):
+    #         if line.startswith('Cavity'):
+    #             if current_cavity:
+    #                 cavities.append(current_cavity)
+    #             current_cavity = {}
+    #         elif current_cavity is not None and line.startswith('-'):
+    #             key = line.split(':')[0].strip('- ').lower()
+    #             value = line.split(':')[1].strip()
+    #             if key in ['birth threshold', 'death threshold', 'persistence']:
+    #                 value = float(value)
+    #             elif key in ['nodes', 'edges']:
+    #                 value = eval(value)
+    #             current_cavity[key] = value
+        
+    #     if current_cavity:
+    #         cavities.append(current_cavity)
+        
+    #     return cavities
+    
+    # def _extract_temporal_evolution(self, text: str) -> Dict[float, Dict[str, List[int]]]:
+    #     """Extract temporal evolution information"""
+    #     evolution = {}
+    #     current_threshold = None
+        
+    #     for line in text.split('\n'):
+    #         if line.startswith('Threshold'):
+    #             current_threshold = float(line.split()[1])
+    #             evolution[current_threshold] = {
+    #                 'active': [],
+    #                 'new': [],
+    #                 'disappeared': []
+    #             }
+    #         elif current_threshold is not None and line.startswith('-'):
+    #             key = line.split(':')[0].strip('- ').lower()
+    #             value = eval(line.split(':')[1].strip())
+    #             evolution[current_threshold][key] = value
+        
+    #     return evolution
+    
+    # def _extract_current_state(self, text: str) -> Dict[str, Any]:
+    #     """Extract current state information"""
+    #     state = {}
+    #     for line in text.split('\n'):
+    #         if line.startswith('- Number of cycles:'):
+    #             state['cycles'] = int(line.split(':')[1].strip())
+    #         elif line.startswith('- Cycle locations:'):
+    #             state['locations'] = eval(line.split(':')[1].strip())
+    #     return state
+    
+    # def _extract_proposed_modifications(self, text: str) -> List[Dict[str, Any]]:
+    #     """Extract proposed modifications"""
+    #     modifications = []
+    #     current_mod = None
+        
+    #     for line in text.split('\n'):
+    #         if line.startswith('Modification'):
+    #             if current_mod:
+    #                 modifications.append(current_mod)
+    #             current_mod = {}
+    #         elif current_mod is not None and line.startswith('-'):
+    #             key = line.split(':')[0].strip('- ').lower()
+    #             value = line.split(':')[1].strip()
+    #             if key == 'new edge':
+    #                 value = tuple(map(int, value.split('-')))
+    #             elif key == 'expected new cycles':
+    #                 value = eval(value)
+    #             current_mod[key] = value
+        
+    #     if current_mod:
+    #         modifications.append(current_mod)
+        
+    #     return modifications
+    
+    # def _extract_expected_outcome(self, text: str) -> Dict[str, Any]:
+    #     """Extract expected outcome"""
+    #     outcome = {}
+    #     for line in text.split('\n'):
+    #         if line.startswith('- New number of cycles:'):
+    #             outcome['new_cycles'] = int(line.split(':')[1].strip())
+    #         elif line.startswith('- New cycle locations:'):
+    #             outcome['new_locations'] = eval(line.split(':')[1].strip())
+    #         elif line.startswith('- Changes in persistence:'):
+    #             outcome['persistence_changes'] = line.split(':')[1].strip()
+    #     return outcome
+    
+
+
+ 
+
+
+        

evaluate_code/graph_embed.py

@@ -0,0 +1,583 @@
+class GraphEmbedder:
+    def __init__(self, task_name):
+        """Initialize graph embedder (text format only)"""
+        self.embed_type = "text"  # Fixed as text format
+        self.task_name = task_name
+    
+    def embed_graph(self, graph_data):
+        """
+        Embed graph data into prompt
+        
+        Parameters:
+        - graph_data: Graph data object
+        - task_type: Task type, can be one of:
+          - "filtration_edge_construction": Filtration edge construction task
+          - "simplicial_complex_construction": Simplicial complex construction task
+          - "persistent_homology_calculation": Persistent homology calculation task
+          - "node_addition": Node addition analysis task
+          - "structure_identification": Topological structure identification task
+          - "graph_modification": Graph structure modification task
+          - "topology_interpretation": Topological feature interpretation task
+          - "vector_representation": Topological feature vectorization task
+          - "noise_robustness": Noise robustness testing task
+          
+        Returns:
+        - prompt: Prompt with embedded graph data
+        """
+        
+        if self.task_name == "S_0D":
+            return self._create_S_0D_prompt(graph_data)
+        elif self.task_name == "S_1D":
+            return self._create_S_1D_prompt(graph_data)
+        elif self.task_name == "S_Modification":
+            return self._create_S_Modification_prompt(graph_data)
+        elif self.task_name == "M_Birth":
+            return self._create_M_Birth_prompt(graph_data)
+        elif self.task_name == "M_Merge":
+            return self._create_M_Merge_prompt(graph_data)
+        elif self.task_name=="M_Filtration":
+            return self._create_M_Filtration_prompt(graph_data)
+        elif self.task_name == "H_Selection":
+            return self._create_H_Selection_prompt(graph_data)
+        elif self.task_name == "H_Generation":
+            return self._create_H_Generation_prompt(graph_data)
+        elif self.task_name == "R_Selection":
+            return self._create_R_Selection_prompt(graph_data)
+        elif self.task_name == "R_Generation":
+            return self._create_R_Generation_prompt(graph_data)
+        elif self.task_name == "R_Directly":
+            return self._create_R_Directly_prompt(graph_data)
+        # elif task_type == "P_Prediction":
+        #     return self._create_truedata_predict_prompt(graph_data)
+        else:
+            raise ValueError(f"Unsupported task type: {self.task_name}")
+
+    def _create_S_0D_prompt(self, graph_data):
+        """Create topological structure identification prompt"""
+        graph_desc = self._graph_to_text(graph_data,weight=False)
+        return f"""You are a mathematical expert specializing in graph theory and persistent homology. Given the following graph structure:
+        Graph Structure:
+        {graph_desc}
+
+        Please calculate the number of connected component in this graph(vertex that not connected to other vertex is not a connected component).
+        And strictly answer in following format:
+        Answer:
+            connected components: n
+        (e.g.
+        Answer:
+            connected components: 3"""
+    def _create_S_1D_prompt(self, graph_data):
+        """Create topological structure identification prompt"""
+        graph_desc = self._graph_to_text(graph_data,weight=False)
+        return f"""You are a mathematical expert specializing in graph theory and persistent homology. Given the following graph structure:
+        Graph Structure:
+        {graph_desc}
+        Please identify if 1-dimensional features (cycle holes) exist in the graph.(triangles are not cycle holes)
+        And strictly answer in following format:
+        Answer:
+            cycle holes: n
+        (e.g. 
+        Answer:
+            cycle holes: 3"""
+            
+    def _create_S_Modification_prompt(self, graph_data):
+        """Create graph structure modification prompt"""
+        graph_desc = self._graph_to_text(graph_data,weight=False)
+        return f"""You are a mathematical expert specializing in graph theory and persistent homology. Given the following graph structure:
+
+        Graph Structure:
+        {graph_desc}
+
+        Task:
+        Please identify the connected components in the graph and add one edge to reduce the number of connected components.
+
+        You can follow these steps:
+        Step1:Please identify the connected components in the graph.
+        Step2:Please add one edge between the different connected components.
+
+        Please strictly follow the format below:
+        Answer:
+            Edge to add: [u,v]
+        (e.g.
+        Answer:
+            Edge to add: [0,3]
+        """
+    def _create_M_Birth_prompt(self, graph_data):
+        """Create persistent homology calculation task prompt"""
+        graph_desc = self._graph_to_text(graph_data,weight=True)
+        return f"""You are a mathematical expert specializing in graph theory and persistent homology. Please calculate persistent homology features based on the following graph structure.
+        Graph Structure:
+        {graph_desc}
+
+        Task:Calculate persistent homology on the graph below. There are 1-dimensional persistent features; please give the birth time of the earliest-born 1-dimensional feature.
+
+        You should follow these steps:
+        Step1:Add edges to the graph according to the edge weights(from smallest to largest,and if there are multiple edges with the same weight, should add them at the same time).
+        Step2:Find the edges that first construct a cycle(Triangle is not cycle,Cycle should be at least 4 edges).
+        Step3:The birth time is the weight of the edge.
+
+        Rule:
+        The cycle cannot be filled by other edges. (e.g. If [0,1], [1,2], [2,3] already exist, adding [3,0] and [3,1] simultaneously would fill the cycle[0,1,2,3] with triangles, so it doesn't count as a birth)
+
+        Please answer in the following format:
+
+        Answer:
+            birth time:[t]
+        (e.g.
+        Answer:
+            birth time:[3])
+        """
+        
+    def _create_M_Merge_prompt(self, graph_data):
+        """Create persistent homology calculation task prompt"""
+        graph_desc = self._graph_to_text(graph_data,weight=True)
+        return f"""You are a mathematical expert specializing in graph theory and persistent homology. Please calculate persistent homology features based on the following graph structure.
+        Graph Structure:
+        {graph_desc}
+        Task: There are 2 0-dimensional persistent features in the graph,and one 0-dimensional feature is dead at time t(t is a real number),please give the death time t.
+
+        You can follow these steps:
+        Step1:Add edges to the graph according to the edge weights,and record the connected components.
+        Step2:Find the edge that first connect two different connected components.
+        Step3:The death time t is the weight of the edge.
+
+        Please answer in the following format:
+        Answer:
+            death time:[t]
+        (e.g.
+        Answer:
+            death time:[4])
+        Please ensure final answer strictly follows above format.
+        """
+        
+    def _create_M_Filtration_prompt(self,graph_data):
+        """Create filtration_features_count task prompt"""
+        graph_desc = self._graph_to_text(graph_data,weight=True)
+        return f"""You are a mathematical expert specializing in graph theory and persistent homology. Now filter the simplicial complex on the following graph according to the edge weights.
+        Graph Structure:
+        {graph_desc}
+
+
+        Task:Count how many connected components are present at filtration value 3?
+
+        You can follow these steps:
+        Step1:Find the edges with weight less than or equal to 3.
+        Step2:Use the edges to construct a graph.
+        Step3:Count how many connected components are present in the graph.
+
+        Rule:Vertices are only introduced into the complex when their associated edges are added.
+
+        Please answer in the following format:
+
+        Answer:
+            connected components:[n]
+        (e.g.
+        Answer:
+            connected components:[3]    
+        """
+    def _create_H_Selection_prompt(self, graph_data):
+        """Create filtration method selection prompt"""
+        graph_desc1 = self._graph_to_text(graph_data[0],weight=True)
+        graph_desc2 = self._graph_to_text(graph_data[1],weight=True)
+        return f""""You are a mathematical expert specializing in graph theory and persistent homology. Given the following two graph structures.
+        Graph structure:
+        graph1:
+        {graph_desc1}
+
+        graph2:
+        {graph_desc2}
+        Task:Please select a filtration method from the following 6 methods that can better distinguish between the two graphs(maximizes the Wasserstein distance between their persistence barcodes).
+        The 6 methods are (all methods filter from low value to high value):
+        Weight: Edge weight.
+        Degree: Number of edges connected to a node.
+        K-shell: Core level of a node based on iterative pruning by degree.
+        Closeness Centrality: Inverse of average shortest path to all other nodes.
+        Betweenness Centrality: Frequency a node lies on shortest paths between others.
+        Eigenvector Centrality: Node importance based on connections to other important nodes.
+        
+        You can follow these steps:
+        1.Analyze the graph's characteristics: Is it sparse or dense? Are there strong local clusters or more global bridge structures? Do edge weights vary significantly?
+        2.Consider what kind of topological features should be emphasized in the filtration: peripheral nodes, local clusters, bridge nodes, or strong/weak connections.
+        3.Match these needs to one of the complex filtration methods.
+
+        Your response should be in this format:
+        Answer:
+            Method: weight/degree/k_shell/closeness/betweenness/eigenvector
+        (e.g
+        Answer:
+            Method: k-shell
+        )
+        Please ensure your answer strictly follows this format.
+        """
+
+    def _create_H_Generation_prompt(self, graph_data):
+        """Create filteration value selection prompt"""
+        graph_desc1 = self._graph_to_text(graph_data[0])
+        graph_desc2 = self._graph_to_text(graph_data[1])
+        filtration_values = list(range(1,int(max(max(graph_data[0]['edge_attr']),max(graph_data[1]['edge_attr'])))+1))
+        return  f"""You are a mathematical expert specializing in graph theory and persistent homology. Given the following two graph structures:
+
+        graph1 structure:
+        {graph_desc1}
+
+        graph2 structure:
+        {graph_desc2}
+        Task:Please select a filtration value sequence from [1,2,3,4,5,6,7,8,9,10] that maximizes the difference between graph 1 and graph 2(maximizes the Wasserstein distance between their persistence barcodes).
+
+        You can follow these steps:
+        Step 1:Compare the structure of graph1 and graph2 to see which is denser, whether there are cycles,etc.
+        Step 2:From the given filtration values, identify values that trigger major topological changes in the graphs.
+        Step 3:Choose 5 filtration values that maximize the difference in persistence barcodes between the two graphs(the max filtration value should be 10). 
+
+        Please answer in the following format:
+        Answer:
+            filtration value: [filtration value]
+        (e.g.
+        Answer:
+            filtration value: [1,3,4,7,10]
+        )
+        Please ensure your answer strictly follows this format.
+        """
+    
+    def _create_R_Selection_prompt(self, graph_data):
+        """Create truedata filtration method selection prompt"""
+        graph_desc1 = self._graph_to_text(graph_data[0],weight=True)
+        graph_desc2 = self._graph_to_text(graph_data[1],weight=True)
+        graph_desc3 = self._graph_to_text(graph_data[2],weight=True)
+        graph_desc4 = self._graph_to_text(graph_data[3],weight=True)
+        return f"""You are a mathematical expert specializing in graph theory and persistent homology. Given the following 4 graph structures (two categories of graphs, each category has 2 graphs, the index of graphs are random):
+        Graph1 Structure:
+        {graph_desc1}
+
+        Graph2 Structure:
+        {graph_desc2}
+
+        Graph3 Structure:
+        {graph_desc3}
+
+        Graph4 Structure:
+        {graph_desc4}
+
+        Task:Please select a filtration method from the following 6 methods that can classify the graph into 2 categories(each category has 2 graphs).
+
+        The 6 methods are (all methods filter from low value to high value):
+        Degree: Number of edges connected to a node.
+        Weight: Edge weight.
+        K-shell: Core level of a node based on iterative pruning by degree.
+        Closeness Centrality: Inverse of average shortest path to all other nodes.
+        Betweenness Centrality: Frequency a node lies on shortest paths between others.
+        Eigenvector Centrality: Node importance based on connections to other important nodes.
+
+        Your selection should be the method that can maximize the difference in persistence barcodes between the two categories and minimize the difference in persistence barcodes within the same category.
+
+        Please answer in the following format:
+        Answer:
+            Method: weight/degree/k-shell/closeness/betweenness/eigenvector
+        (e.g.
+        Answer:
+            Method: k-shell
+        )   
+        Please ensure your answer strictly follows this format.
+        """
+
+    def _create_R_Generation_prompt(self, graph_data):
+        """Create truedata filteration value selection prompt"""
+        graph_desc1 = self._graph_to_text(graph_data[0],weight=True)
+        graph_desc2 = self._graph_to_text(graph_data[1],weight=True)
+        graph_desc3 = self._graph_to_text(graph_data[2],weight=True)
+        graph_desc4 = self._graph_to_text(graph_data[3],weight=True)
+        return f"""You are a mathematical expert specializing in graph theory and persistent homology. Given the following 4 graph structures (two categories of graphs, each category 2 graphs, the index of graphs are random):
+        Graph1 Structure:
+        {graph_desc1}
+
+        Graph2 Structure:
+        {graph_desc2}
+
+        Graph3 Structure:
+        {graph_desc3}
+
+        Graph4 Structure:
+        {graph_desc4}
+
+        Task:Please select a filtration value sequence that can classify the graph into 2 categories(the persistence barcodes of the two different categories should be as different as possible and the same category should have similar persistence barcodes).
+
+        You can follow these steps:
+        Step1:Compare the structure of 4 graphs.
+        Step2:Choose filtration values sequence (from 0 to 1,sequence length not less than 2) that can maximize the difference in persistence barcodes between the two categories and minimize the difference in persistence barcodes within the same category.
+
+        Please answer in the following format:
+        Answer:
+            Filtration value: [filtration values]
+        (e.g.
+        Answer:
+            Filtration value: [0.1,0.4,0.5,0.6,0.9,1]
+        )
+        Please ensure your answer strictly follows this format.
+        """
+        
+    def _create_filtration_edge_construction_prompt(self, graph_data):
+        """Create filtration edge construction task prompt"""
+        graph_desc = self._graph_to_text(graph_data)
+        return f"""You are a mathematical expert specializing in graph theory and persistent homology. Please construct a filtration edge sequence based on the following graph structure.
+
+        Graph Structure:
+        {graph_desc}
+
+        Task: Construct filtration edges from the original edge list.
+        (e.g. Graph structure [0,1,3],[0,2,1],[1,3,2],[1,4,2],[2,3,3]  
+        Filtration edge sequence:
+        Filtration value: 1 
+        [0,2]
+        Filtration value: 2
+        [1,3],[1,4]
+        Filtration value: 3
+        [0,1],[2,3]  )
+        Please strictly follow these steps:
+        1. First sort the original edge list by weight in ascending order
+        2. Divide edges added at each filtration value
+
+        Please answer in the following format:
+
+        ===FILTRATION_START===
+        For each different edge weight, list the edges added at that weight, format as:
+
+        **Value=1**
+        (1,2)
+
+        **Value=2**
+        (1,3)
+
+        **Value=3**
+        (2,3)
+
+        ...continue for other weights
+        ===FILTRATION_END===
+
+        Please ensure strict adherence to the above format. Do not add extra explanations, only include content required by the format
+        """
+
+    def _create_R_Directly_prompt(self, graph_data):
+        """Create truedata classfy prompt"""
+        graph_desc1 = self._graph_to_text(graph_data[0],weight=True)
+        graph_desc2 = self._graph_to_text(graph_data[1],weight=True)
+        graph_desc3 = self._graph_to_text(graph_data[2],weight=True)
+        graph_desc4 = self._graph_to_text(graph_data[3],weight=True)
+        return f"""You are a mathematical expert specializing in graph theory and persistent homology. Given the following 4 graph structures(two categories of graphs, each category has 2 graphs, the index of graphs are random):
+
+        Graph1 Structure:
+        {graph_desc1}
+
+        Graph2 Structure:
+        {graph_desc2}
+
+        Graph3 Structure:
+        {graph_desc3}
+
+        Graph4 Structure:
+        {graph_desc4}
+
+        Task:Please classify them into 2 categories(each category has 2 graphs) according to their topological structure.
+
+        Please answer in the following format:
+        Answer:
+            Category: [category1 graph index,category2 graph index]
+        (e.g.
+        Answer:
+            Category: [[1,3],[2,4]])
+        Please ensure your answer strictly follows this format.
+        """ 
+
+    def _graph_to_text(self, graph_data, weight=True, sort=True):
+        """图结构文本转换"""
+        num_nodes = graph_data['num_nodes']
+        num_edges = graph_data['num_edges']
+        edge_index = graph_data['edge_index']
+        
+        # 收集所有边及其权重
+        edges = []
+        for i in range(0, len(edge_index), 2):
+            src = edge_index[i]
+            dst = edge_index[i + 1]
+            if weight:
+                weight_val = 1.0  # 默认权重为1
+            else:
+                weight_val = 1.0
+            edges.append((weight_val, src, dst))
+        
+        if sort:
+            edges.sort(key=lambda x: x[0])
+        
+        # Generate text
+        text = f"Graph with {num_nodes} nodes and {num_edges} edges:\n"
+        if weight:
+            for weight_val, src, dst in edges:
+                text += f"Node {src}-[{weight_val:.2f}]-Node {dst}\n"
+        else:
+            for weight_val, src, dst in edges:
+                text += f"Node {src}-Node {dst}\n"
+        return text
+
+    def _filt_edges_to_text(self, graph_data,sort=True):
+        """Convert filtration complex to text"""
+        num_nodes = graph_data['num_nodes']
+        num_edges = graph_data['num_edges']
+        edge_index = graph_data['edge_index']
+
+        edges = []
+        for i in range(edge_index.shape[1]):
+            src = edge_index[0, i].item()
+            dst = edge_index[1, i].item()
+            if hasattr(graph_data, 'edge_attr') and graph_data.edge_attr is not None:
+                weight = graph_data.edge_attr[i].item()
+            else:
+                weight = 1.0
+            edges.append((weight, src, dst))
+        
+        if sort:
+            edges.sort(key=lambda x: x[0])
+        
+        # Generate text
+        text = f"Graph with {num_nodes} nodes and {num_edges} edges:\n"
+        for weight, src, dst in edges:
+            text += f"Node {src}-[{weight:.2f}]-Node {dst}\n"
+        return text
+    def _complex_to_text(self, graph_data):
+        """Complex structure description"""
+        simplex = graph_data.task_simplex[0]
+        dim = len(simplex) - 1
+        verts = ", ".join(str(v) for v in simplex)
+
+        if dim == 0:
+            desc = f"vertex {verts}"
+        elif dim == 1:
+            a, b = simplex
+            desc = f"edge between {a} and {b}"
+        elif dim == 2:
+            a, b, c = simplex
+            desc = f"triangle with vertices {a}, {b}, {c}"
+        else:
+            desc = f"{dim}-simplex spanning vertices {verts}"
+
+        text = f"aim simplex: {desc}"
+        return text
+
+
+    def _ph_to_text(self, ph_data):
+        """Persistent homology barcode description"""
+        text = ""
+        for dim in ['0dim', '1dim']:
+            if dim in ph_data:
+                text += f"\n{dim} features:\n"
+                for i, (birth, death) in enumerate(ph_data[dim]):
+                    persistence = death - birth
+                    text += f"Feature {i}: birth {birth:.2f}, death {death:.2f}, persistence {persistence:.2f}\n"
+        return text
+    
+    # def _create_simplicial_complex_construction_prompt(self, graph_data):
+#         """Create simplicial complex construction task prompt"""
+#         filt_edges_desc = self._filt_edges_to_text(graph_data)
+#         return f"""You are a mathematical expert specializing in graph theory and persistent homology. Please construct a simplicial complex sequence based on the following filtration edge sequence.
+
+# Filtration Edge Sequence:
+# {filt_edges_desc}
+
+# Task: Build complex sequence (2-dimensional simplex) from filtration edge list.
+
+# Please strictly follow these steps:
+# 1. For each filtration value, build a complex containing that filtration value and all previous filtration values
+# 2. Record new 2-dimensional simplices appearing at each filtration value (e.g. filtration value 1: [1,2],[2,3] filtration value 2: [1,3]    appears 2-dimensional simplex [(1,2,3),2])
+
+# Please answer in the following format:
+# List simplicial complexes [(complex),filtration value]:
+# ===SIMPLICIAL_COMPLEX_START===
+
+# [(0,1,2),3]
+# [(0,1,4),3]
+# [(0,3,4),4]
+# ...
+# ===SIMPLICIAL_COMPLEX_END===
+
+# Note:
+# - 0-dimensional simplices are omitted, only list 1-dimensional and 2-dimensional simplices
+# - 2-dimensional simplex is a triangle formed by three edges (all edge feature values are less than or equal to filtration value)
+
+# Please ensure strict adherence to the above format. Do not add extra explanations, only include content required by the format
+# """
+
+#     def _create_filteration_value_change_prompt(self, graph_data):
+#         edge_str = "graph structure:\n"
+#         edge_str += self._filt_edges_to_text(graph_data)
+
+        
+#         pd_str = "current persistent homology results:\n"
+#         pd_str += self._ph_to_text(graph_data.vr_10_pd)
+        
+#         question = f"""graph structure:{edge_str}
+# current persistent homology results:{pd_str}
+# if we reduce the filtration step from 10 to 5(filtration value[2,4,6,8,10]), will the number of 0-dimensional persistent features decrease?
+
+# Please answer in the following format:
+# Answer:
+#     Yes/No
+# (e.g.
+# Answer:
+#     Yes
+# )
+# """
+           
+#         return question
+
+
+    
+
+    
+
+    
+
+
+#     def _create_truedata_predict_prompt(self, graph_data):
+#         """Create truedata predict prompt"""
+#         graph_desc1 = self._graph_to_text(graph_data[0],weight=True)
+#         graph_desc2 = self._graph_to_text(graph_data[1],weight=True)
+#         graph_desc3 = self._graph_to_text(graph_data[2],weight=True)
+#         graph_desc4 = self._graph_to_text(graph_data[3],weight=True)
+#         graph_desc5 = self._graph_to_text(graph_data[4],weight=True)
+#         graph_desc6 = self._graph_to_text(graph_data[5],weight=True)
+#         graph_desc7 = self._graph_to_text(graph_data[6],weight=True)
+#         closing_price = [graph_data[0].y,graph_data[1].y,graph_data[2].y,graph_data[3].y,graph_data[4].y,graph_data[5].y,graph_data[6].y]
+#         return f"""You are a mathematical expert specializing in graph theory and persistent homology. Given the following seven-day ETH trading network and closing prices:
+
+# day1:
+# {graph_desc1}
+
+# day2:
+# {graph_desc2}
+
+# day3:
+# {graph_desc3}
+
+# day4:
+# {graph_desc4}
+
+# day5:
+# {graph_desc5}
+
+# day6:
+# {graph_desc6}
+
+# day7:
+# {graph_desc7}
+
+# closing price list(from day):{closing_price}
+
+# Task:Please predict the closing price of day8.
+
+# Please answer in the following format:
+# Answer:
+#     Closing price: [closing price]
+# (e.g.
+# Answer:
+#     Closing price: 1000
+# )
+# Please ensure your answer strictly follows this format.
+# """

evaluate_code/llm_api.py

@@ -0,0 +1,126 @@
+import os
+from openai import OpenAI
+from anthropic import Anthropic
+import google.generativeai as genai
+import requests
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class LLMCaller:
+    def __init__(self, model_name: str = "gpt-4.1-mini-2025-04-14"):
+        """
+        Initialize LLM model with unified interface
+        
+        Parameters:
+        - model_name: Model name to use, defaults to "gpt-4.1-mini-2025-04-14"
+        """
+        self.model_name = model_name
+        self._setup_model()
+        
+    def _setup_model(self):
+        """Setup model configuration based on model name"""
+        if self.model_name.startswith("gpt"):
+            self.client = OpenAI(
+                api_key=os.getenv("OPENAI_API_KEY"),
+                base_url="https://api.openai.com/v1"
+            )
+            self.api_type = "openai"
+        elif self.model_name.startswith("claude"):
+            self.client = Anthropic(
+                api_key=os.getenv("ANTHROPIC_API_KEY")
+            )
+            self.api_type = "anthropic"
+        elif self.model_name.startswith("deepseek"):
+            self.api_key = os.getenv("DEEPSEEK_API_KEY")
+            self.api_url = "https://api.deepseek.com/v1/chat/completions"
+            self.api_type = "deepseek"
+        elif self.model_name.startswith("gemini"):
+            genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+            self.model = genai.GenerativeModel(self.model_name)
+            self.api_type = "gemini"
+        elif self.model_name in ["llama-3-70b", "mixtral-8x7b", "qwen-72b"]:
+            self.api_url = "http://localhost:8000/v1"
+            self.api_type = "local"
+        else:
+            raise ValueError(f"Unsupported model: {self.model_name}")
+
+    def call(self, prompt: str) -> str:
+        """
+        Call LLM API with a single prompt
+        
+        Parameters:
+        - prompt: Input prompt string
+        
+        Returns:
+        - response: Model's response
+        """
+        try:
+            if self.api_type == "openai":
+                response = self.client.chat.completions.create(
+                    model=self.model_name,
+                    messages=[
+                        {"role": "system", "content": "You are a mathematical expert specializing in graph theory and persistent homology."},
+                        {"role": "user", "content": prompt}
+                    ]
+                )
+                return response.choices[0].message.content
+                
+            elif self.api_type == "anthropic":
+                response = self.client.messages.create(
+                    model=self.model_name,
+                    system="You are a helpful assistant.",
+                    messages=[{"role": "user", "content": prompt}]
+                )
+                return response.content[0].text
+                
+            elif self.api_type == "deepseek":
+                headers = {
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json"
+                }
+                data = {
+                    "model": self.model_name,
+                    "messages": [
+                        {"role": "user", "content": "/no_think" + prompt}
+                    ]
+                }
+                response = requests.post(self.api_url, headers=headers, json=data)
+                response.raise_for_status()
+                return response.json()["choices"][0]["message"]["content"]
+                
+            elif self.api_type == "gemini":
+                response = self.model.generate_content(prompt)
+                return response.text
+                
+            elif self.api_type == "local":
+                data = {
+                    "model": self.model_name,
+                    "messages": [
+                        {"role": "user", "content": prompt}
+                    ]
+                }
+                response = requests.post(self.api_url, json=data)
+                response.raise_for_status()
+                return response.json()["choices"][0]["message"]["content"]
+                
+        except Exception as e:
+            print(f"Error calling {self.model_name} API: {e}")
+            return f"API call error: {str(e)}"
+
+    def batch_call(self, prompts: list[str]) -> list[str]:
+        """
+        Batch call LLM API with multiple prompts
+        
+        Parameters:
+        - prompts: List of input prompts
+        
+        Returns:
+        - responses: List of model responses
+        """
+        responses = []
+        for idx, prompt in enumerate(prompts, start=1):
+            print(f"Processing prompt {idx}/{len(prompts)}")
+            response = self.call(prompt)
+            responses.append(response)
+        return responses

evaluate_code/llm_evaluator.py

@@ -0,0 +1,192 @@
+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

evaluate_code/load_datasets.py

@@ -0,0 +1,57 @@
+import os
+import json
+import pandas as pd
+from huggingface_hub import list_repo_files, hf_hub_download
+
+def load_data(file_path):
+    """Load data based on file extension"""
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext == '.json':
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    elif ext == '.csv':
+        return pd.read_csv(file_path)
+    elif ext == '.jsonl':
+        data = []
+        with open(file_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                data.append(json.loads(line))
+        return data
+    elif ext == '.parquet':
+        return pd.read_parquet(file_path)
+    else:
+        raise ValueError(f"Unsupported file extension: {ext}")
+
+def download_and_load_datasets():
+    repo_id = "Antislab/LLM4PH"
+    files = list_repo_files(repo_id=repo_id, repo_type="dataset")
+    
+    downloaded_files = []
+    for file in files:
+        if file.startswith("datasets/"):
+            local_path = os.path.join(".", file)
+            if not os.path.exists(local_path):
+                print(f"Downloading {file}...")
+                hf_hub_download(
+                    repo_id=repo_id,
+                    filename=file,
+                    repo_type="dataset",
+                    local_dir="."
+                )
+            else:
+                print(f"File {file} already exists, skipping download.")
+            downloaded_files.append(local_path)
+    
+    # Load all downloaded files
+    loaded_data = {}
+    for file_path in downloaded_files:
+        try:
+            loaded_data[file_path] = load_data(file_path)
+            print(f"Successfully loaded {file_path}")
+        except Exception as e:
+            print(f"Error loading {file_path}: {str(e)}")
+    
+    return loaded_data
+
+if __name__ == "__main__":
+    data = download_and_load_datasets()

evaluate_code/ph_utils.py

@@ -0,0 +1,171 @@
+import numpy as np
+from scipy.sparse.csgraph import connected_components
+import gudhi as gd
+from persim import wasserstein
+import bisect
+
+def count_connected_components(edge_index, num_nodes):
+    """Count the number of connected components in a graph"""
+    # Create adjacency matrix
+    adj_matrix = np.zeros((num_nodes, num_nodes))
+    for i in range(edge_index.shape[1]):
+        src, dst = edge_index[0, i], edge_index[1, i]
+        adj_matrix[src, dst] = 1
+        adj_matrix[dst, src] = 1
+    
+    # Calculate connected components using scipy
+    n_components, _ = connected_components(adj_matrix)
+    return n_components
+
+def Filtration(edge_index, edge_attr,filt,filt_value):
+    def filt_edge(edges,filt_value):
+        upper_bounds = filt_value
+        filted_edges = []
+        for edge in edges:
+            src, tgt, w = edge
+            index = bisect.bisect_left(upper_bounds, w)
+            if index < len(upper_bounds):
+                assigned_upper = upper_bounds[index]
+            else:
+                assigned_upper = upper_bounds[-1]
+            
+            filted_edges.append((src, tgt, assigned_upper))
+        
+        return filted_edges
+    edge_index = np.array(edge_index).reshape(2, -1)
+    original_edges = []
+    for i in range(edge_index.shape[1]):
+        source = edge_index[0, i].item()
+        target = edge_index[1, i].item()
+        weight = edge_attr[i].item()
+        original_edges.append((source, target, weight))
+    if filt:
+        original_edges = filt_edge(original_edges,filt_value)
+    sorted_edges = sorted(original_edges, key=lambda x: x[2])    
+
+    simplices = gd.SimplexTree()
+    for u, v, weight in sorted_edges:
+        simplices.insert([u, v], filtration=weight)
+    simplices.expansion(2)
+    filtration = simplices.get_filtration()
+    simplex_list = []
+
+    for simplex in filtration:
+        simplex_list.append(simplex)
+
+    simplices.persistence()
+    barcode = []
+    for i in range(2):
+        intervals = simplices.persistence_intervals_in_dimension(i)
+        barcode.append(intervals)
+
+    vr_e_pd = {}
+    for dim, intervals in enumerate(barcode):
+        if intervals.size > 0 and dim<=2:
+            intervals = intervals.tolist()
+            intervals.sort(key=lambda x: x[0])
+            vr_e_pd[f'{dim}dim'] = intervals
+        else:
+            vr_e_pd[f'{dim}dim'] = []
+
+    return sorted_edges, simplex_list, vr_e_pd
+
+def add_vr_ORI(dataset,filt,filt_value=None):
+    for i in range(len(dataset)):
+        edge_index = dataset[i]['edge_index']
+        edge_attr = dataset[i]['edge_attr']
+        
+
+        sorted_edges,simplex_list, vr_e_pd = Filtration(edge_index, edge_attr,filt,filt_value)
+
+        for dim in vr_e_pd:
+            vr_e_pd[dim].sort(key=lambda interval: interval[0])
+    
+        # dataset[i].sorted_edges = sorted_edges  
+        # dataset[i].simplex = simplex_list      
+        # dataset[i].vr_e_pd = vr_e_pd
+        
+        if filt:
+            dataset[i]['selected_vr_e_pd'] = vr_e_pd
+        else:
+            dataset[i]['vr_e_pd'] = vr_e_pd
+            
+def PD_to_diagram(PD):
+    """
+    Convert persistence diagram dictionary to numpy array format.
+    """
+    diagram = []
+    for dim, intervals in PD.items():
+        dim_int = int(dim[0]) 
+        for interval in intervals:
+            birth, death = interval
+            diagram.append([birth, death, dim_int])
+    return np.array(diagram)
+
+def compute_wasserstein_distance(PD1, PD2):
+    """
+    Compute Wasserstein distance between two persistence diagrams.
+    """
+    diagram1 = PD_to_diagram(PD1)
+    diagram2 = PD_to_diagram(PD2)
+
+    # Handle infinite death times
+    diagram1[~np.isfinite(diagram1[:, 1]), 1] = 1.1
+    diagram2[~np.isfinite(diagram2[:, 1]), 1] = 1.1
+
+    return wasserstein(diagram1, diagram2)
+
+
+def check_graph_group(graphs, method='weight', pre_calculate=True, filt_value=None):
+    """
+    Check if four graphs satisfy the separation condition:
+    1. Both distances within same class are smaller than all four distances between different classes
+    2. Four graphs must be arranged in [1,1,-1,-1] order
+    
+    Args:
+        graphs: List of 4 graphs arranged in [1,1,-1,-1] order
+        method: Persistent homology calculation method
+        pre_calculate: Whether persistence diagrams are pre-calculated
+        filt_value: Filtration value for calculation
+    
+    Returns:
+        tuple: (bool, list) - Whether separation condition is satisfied and list of distances
+    """
+    if len(graphs) != 4:
+        raise ValueError("Must provide exactly 4 graphs")
+    
+    # Verify graph label order
+    if not (graphs[0]['y'] == graphs[1]['y'] and graphs[2]['y'] == graphs[3]['y'] and graphs[0]['y'] != graphs[2]['y']):
+        raise ValueError("Graphs must be ordered as [1,1,-1,-1]")
+    
+    if not pre_calculate:
+        add_vr_ORI(graphs, filt=True, filt_value=filt_value)
+        
+    # Calculate distances between all graph pairs
+    distances = []
+    for i in range(4):
+        for j in range(i+1, 4):
+            if method == 'weight':
+                if pre_calculate:
+                    dist = compute_wasserstein_distance(graphs[i]['vr_e_pd'], graphs[j]['vr_e_pd'])
+                else:
+                    dist = compute_wasserstein_distance(graphs[i]['selected_vr_e_pd'], graphs[j]['selected_vr_e_pd'])
+            else:
+                dist = compute_wasserstein_distance(
+                    getattr(graphs[i], f'vr_{method}_pd'),
+                    getattr(graphs[j], f'vr_{method}_pd')
+                )
+            distances.append((i, j, dist))
+    
+    # Distances within same class
+    same_class_distances = [dist for i, j, dist in distances 
+                          if (i < 2 and j < 2) or (i >= 2 and j >= 2)]
+    
+    # Distances between different classes
+    diff_class_distances = [dist for i, j, dist in distances 
+                          if (i < 2 and j >= 2) or (i >= 2 and j < 2)]
+    
+    max_same = max(same_class_distances)
+    min_diff = min(diff_class_distances)
+    
+    return max_same < min_diff, distances

main.py

@@ -0,0 +1,77 @@
+from evaluate_code.llm_evaluator import LLMEvaluator
+from datetime import datetime
+from config import TASKS, MODEL_NAMES
+import os
+import json
+import csv
+
+def save_results(date_str,results, task_name):
+    """
+    Save results to both JSON and CSV files
+    
+    Args:
+        results: Dictionary containing evaluation results
+        task_name: Name of the task
+    """
+    # Create results directory if it doesn't exist
+    if not os.path.exists("results"):
+        os.makedirs("results")
+    
+    # Create date folder
+    date_path = os.path.join("results", date_str)
+    if not os.path.exists(date_path):
+        os.makedirs(date_path)
+    
+    # Create task folder
+    task_path = os.path.join(date_path, task_name)
+    if not os.path.exists(task_path):
+        os.makedirs(task_path)
+    
+    # Save JSON
+    json_path = os.path.join(task_path, "results.json")
+    with open(json_path, 'w', encoding='utf-8') as f:
+        json.dump(results, f, ensure_ascii=False, indent=2)
+    if task_name in ["S_0D", "S_1D", "S_Modification", "M_Merge", "M_Birth", "M_Filtration", "R_Selection", "R_Generation"]:
+        # Save CSV
+        csv_path = os.path.join(task_path, "results.csv")
+        with open(csv_path, 'w', newline='', encoding='utf-8') as f:
+            writer = csv.writer(f)
+            # Write header
+            writer.writerow(['file_name', 'accuracy'])
+            # Write data
+            for file_name, (accuracy, _) in results.items():
+                # Remove .parquet extension
+                file_name = file_name.replace('.parquet', '')
+                writer.writerow([file_name, accuracy])
+    elif task_name in ["H_Selection", "H_Generation"]:
+        # Save CSV
+        csv_path = os.path.join(task_path, "results.csv")
+        with open(csv_path, 'w', newline='', encoding='utf-8') as f:
+            writer = csv.writer(f)
+            # Write header
+            writer.writerow(['file_name', 'mean_rank', 'std_rank'])
+            # Write data
+            for file_name, (_, details) in results.items():
+                mean_rank = details['statistics']['mean_rank']
+                std_rank = details['statistics']['std_rank']
+                file_name = file_name.replace('.parquet', '')
+                writer.writerow([file_name, mean_rank, std_rank])
+
+def main():
+    date_str = datetime.now().strftime("%Y%m%d_%H%M")
+    # Process each task in the task list
+    for task_name in TASKS:
+        for model_name in MODEL_NAMES:
+            print(f"Processing task: {task_name} with model: {model_name}")
+            evaluator = LLMEvaluator(
+                task_name=task_name,
+                model_name=model_name
+            )
+        # Process all graphs in all files
+        results = evaluator.process_dataset()
+        # Save results
+        save_results(date_str, results, task_name)
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,22 @@
+# Core dependencies
+numpy==2.1.3
+pandas==2.2.3
+torch==2.5.1
+scikit-learn==1.6.1
+scipy==1.14.1
+
+# Topology and graph related
+gudhi==3.11.0
+persim==0.3.8
+networkx==3.4.2
+
+# LLM API support
+openai==1.79.0
+anthropic==0.51.0
+google-generativeai==0.8.5
+python-dotenv==1.1.0
+
+# Visualization and utilities
+matplotlib==3.9.2
+tqdm==4.67.1
+huggingface-hub==0.31.2