Add files using upload-large-folder tool

code/evaluation_code/level1/evaluation_FED.py

@@ -0,0 +1,174 @@
+import json
+import re
+from collections import Counter, defaultdict
+from datetime import datetime
+
+import numpy as np
+from sklearn.metrics import (
+    accuracy_score,
+    classification_report,
+    confusion_matrix,
+    f1_score,
+)
+
+
+def extract_emotion_from_output(model_output):
+
+    if not model_output:
+        return None, False, "empty_output"
+
+    patterns = [
+        r"['\"]emotion['\"]:\s*['\"](\w+)['\"]",  
+        r"emotion['\"]?\s*:\s*['\"]?(\w+)['\"]?",  
+        r"\b(positive|negative|neutral)\b",  
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, model_output.lower())
+        if match:
+            emotion = match.group(1).lower()
+            if emotion in ["positive", "negative", "neutral"]:
+                return emotion, True, None
+
+    if re.search(r"['\"]emotion['\"]", model_output.lower()):
+        return None, False, "invalid_emotion_label"
+    elif any(
+        word in model_output.lower() for word in ["positive", "negative", "neutral"]
+    ):
+        return None, False, "emotion_found_but_not_extracted"
+    else:
+        return None, False, "no_emotion_pattern"
+
+
+def evaluate_face_expression_emotion_detection(result_file_path):
+
+    with open(result_file_path, "r", encoding="utf-8") as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    prediction_errors = defaultdict(list)
+
+    for item in results:
+        item_id = item["id"]
+        model_output = item["model_output"]
+        gt_label = item["ground_truth"].lower()
+
+        pred_label, is_valid, error_type = extract_emotion_from_output(model_output)
+
+        detailed_item = {
+            "id": item_id,
+            "model_output": model_output,
+            "extracted_prediction": pred_label,
+            "ground_truth": gt_label,
+            "correct": pred_label == gt_label if pred_label else False,
+            "valid": is_valid,
+        }
+        detailed_results.append(detailed_item)
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+        elif pred_label != gt_label:
+            error_pattern = f"{gt_label}_to_{pred_label}"
+            prediction_errors[error_pattern].append(item_id)
+
+        if is_valid:
+            predictions.append(pred_label)
+            ground_truths.append(gt_label)
+
+    if len(predictions) == 0:
+        return {
+            "error": "No valid predictions found",
+            "total_samples": len(results),
+            "extraction_errors": dict(extraction_errors),
+        }
+    accuracy = accuracy_score(ground_truths, predictions)
+    weighted_f1 = f1_score(ground_truths, predictions, average="weighted")
+    macro_f1 = f1_score(ground_truths, predictions, average="macro")
+
+    labels = ["positive", "negative", "neutral"]
+    cm = confusion_matrix(ground_truths, predictions, labels=labels)
+
+    class_report = classification_report(
+        ground_truths, predictions, target_names=labels, output_dict=True
+    )
+
+    evaluation_result = {
+        "task_info": {
+            "task_name": "face.expression.emotion.detection",
+            "dataset": "CH-SIMS",
+            "evaluation_time": datetime.now().isoformat(),
+            "total_samples": len(results),
+            "valid_predictions": len(predictions),
+            "extraction_success_rate": round(len(predictions) / len(results), 4),
+        },
+        "metrics": {
+            "ACC": round(accuracy, 4),
+            "WAF": round(weighted_f1, 4),
+            "Macro_F1": round(macro_f1, 4),
+        },
+        "per_class_metrics": {
+            label: {
+                "precision": round(class_report[label]["precision"], 4),
+                "recall": round(class_report[label]["recall"], 4),
+                "f1_score": round(class_report[label]["f1-score"], 4),
+                "support": int(class_report[label]["support"]),
+            }
+            for label in labels
+        },
+        "confusion_matrix": {"labels": labels, "matrix": cm.tolist()},
+        "error_analysis": {
+            "extraction_errors": {
+                error_type: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_type, sample_ids in extraction_errors.items()
+            },
+            "prediction_errors": {
+                error_pattern: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_pattern, sample_ids in prediction_errors.items()
+            },
+        },
+        "distribution": {
+            "ground_truth": dict(Counter(ground_truths)),
+            "predictions": dict(Counter(predictions)),
+        },
+    }
+
+    base_name = result_file_path.replace(".json", "")
+
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, "w", encoding="utf-8") as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, "w", encoding="utf-8") as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+    problem_samples = [item for item in detailed_results if not item["correct"]]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, "w", encoding="utf-8") as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)},see {problem_report_file}")
+
+    return evaluation_result
+
+
+
+if __name__ == "__main__":
+    result_file = "model_result.json"
+
+    try:
+        evaluation_result = evaluate_face_expression_emotion_detection(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: File not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: {result_file} Invalid format")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")
+
+

code/evaluation_code/level1/evaluation_ISA.py

@@ -0,0 +1,211 @@
+import json
+import re
+from collections import Counter, defaultdict
+from datetime import datetime
+
+import numpy as np
+from sklearn.metrics import (
+    accuracy_score,
+    classification_report,
+    confusion_matrix,
+    f1_score,
+)
+
+
+def extract_emotion_from_output(model_output):
+
+    if not model_output:
+        return None, False, "empty_output"
+
+    valid_emotions = [
+        "amusement",
+        "anger",
+        "awe",
+        "contentment",
+        "disgust",
+        "excitement",
+        "fear",
+        "sadness",
+    ]
+
+    patterns = [
+        r"['\"]emotion['\"]:\s*['\"](\w+)['\"]",  
+        r"emotion['\"]?\s*:\s*['\"]?(\w+)['\"]?",  
+        r"\b(amusement|anger|awe|contentment|disgust|excitement|fear|sadness)\b",  
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, model_output.lower())
+        if match:
+            emotion = match.group(1).lower()
+            if emotion in valid_emotions:
+                return emotion, True, None
+
+    
+    if re.search(r"['\"]emotion['\"]", model_output.lower()):
+        return None, False, "invalid_emotion_label"
+    elif any(word in model_output.lower() for word in valid_emotions):
+        return None, False, "emotion_found_but_not_extracted"
+    else:
+        return None, False, "no_emotion_pattern"
+
+
+def evaluate_image_sentiment_analysis(result_file_path):
+
+
+
+    with open(result_file_path, "r", encoding="utf-8") as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    prediction_errors = defaultdict(list)
+
+
+    emotion_labels = [
+        "amusement",
+        "anger",
+        "awe",
+        "contentment",
+        "disgust",
+        "excitement",
+        "fear",
+        "sadness",
+    ]
+
+    for item in results:
+        item_id = item["id"]
+        model_output = item["model_output"]
+        gt_label = item["ground_truth"].lower()
+
+        pred_label, is_valid, error_type = extract_emotion_from_output(model_output)
+
+        detailed_item = {
+            "id": item_id,
+            "model_output": model_output,
+            "extracted_prediction": pred_label,
+            "ground_truth": gt_label,
+            "correct": pred_label == gt_label if pred_label else False,
+            "valid": is_valid,
+        }
+        detailed_results.append(detailed_item)
+
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+        elif pred_label != gt_label:
+            error_pattern = f"{gt_label}_to_{pred_label}"
+            prediction_errors[error_pattern].append(item_id)
+
+
+        if is_valid:
+            predictions.append(pred_label)
+            ground_truths.append(gt_label)
+
+
+    if len(predictions) == 0:
+        return {
+            "error": "No valid predictions found",
+            "total_samples": len(results),
+            "extraction_errors": dict(extraction_errors),
+        }
+
+
+    accuracy = accuracy_score(ground_truths, predictions)
+    weighted_f1 = f1_score(ground_truths, predictions, average="weighted")
+    macro_f1 = f1_score(ground_truths, predictions, average="macro")
+
+
+    cm = confusion_matrix(ground_truths, predictions, labels=emotion_labels)
+
+    class_report = classification_report(
+        ground_truths,
+        predictions,
+        target_names=emotion_labels,
+        output_dict=True,
+        zero_division=0,
+    )
+
+    evaluation_result = {
+        "task_info": {
+            "task_name": "image.sentiment.analysis",
+            "dataset": "EmoSet",
+            "evaluation_time": datetime.now().isoformat(),
+            "total_samples": len(results),
+            "valid_predictions": len(predictions),
+            "extraction_success_rate": round(len(predictions) / len(results), 4),
+        },
+        "metrics": {
+            "ACC": round(accuracy, 4),
+            "WAF": round(weighted_f1, 4),
+            "Macro_F1": round(macro_f1, 4),
+        },
+        "per_class_metrics": {
+            label: {
+                "precision": round(class_report[label]["precision"], 4),
+                "recall": round(class_report[label]["recall"], 4),
+                "f1_score": round(class_report[label]["f1-score"], 4),
+                "support": int(class_report[label]["support"]),
+            }
+            for label in emotion_labels
+            if label in class_report
+        },
+        "confusion_matrix": {"labels": emotion_labels, "matrix": cm.tolist()},
+        "error_analysis": {
+            "extraction_errors": {
+                error_type: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_type, sample_ids in extraction_errors.items()
+            },
+            "prediction_errors": {
+                error_pattern: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_pattern, sample_ids in prediction_errors.items()
+            },
+        },
+        "distribution": {
+            "ground_truth": dict(Counter(ground_truths)),
+            "predictions": dict(Counter(predictions)),
+        },
+    }
+
+    base_name = result_file_path.replace(".json", "")
+
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, "w", encoding="utf-8") as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, "w", encoding="utf-8") as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+    problem_samples = [item for item in detailed_results if not item["correct"]]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, "w", encoding="utf-8") as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+
+    print(f"Evaluation completed: {len(results)} samples")
+    print(
+        f"Key metrics: ACC={evaluation_result['metrics']['ACC']}, WAF={evaluation_result['metrics']['WAF']}"
+    )
+    print(f"Extraction success rate: {evaluation_result['task_info']['extraction_success_rate']}")
+    print(f"Results saved to: {eval_output_file}")
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)},see {problem_report_file}")
+
+    return evaluation_result
+
+
+if __name__ == "__main__":
+    result_file = "model_result.json"  
+
+    try:
+        evaluation_result = evaluate_image_sentiment_analysis(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: File not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: {result_file} Invalid format")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")

code/evaluation_code/level1/evaluation_MER.py

@@ -0,0 +1,206 @@
+import json
+import re
+from collections import Counter, defaultdict
+from datetime import datetime
+
+import numpy as np
+from sklearn.metrics import (
+    accuracy_score,
+    classification_report,
+    confusion_matrix,
+    f1_score,
+)
+
+
+def extract_emotion_from_output(model_output):
+
+    if not model_output:
+        return None, False, "empty_output"
+
+
+    valid_emotions = ["happy", "sad", "neutral", "angry", "worried", "surprise"]
+
+    patterns = [
+        r"['\"]emotion['\"]:\s*['\"](\w+)['\"]",                          
+        r"emotion['\"]?\s*:\s*['\"]?(\w+)['\"]?",                    
+        r"\b(happy|sad|neutral|angry|worried|surprise)\b",           
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, model_output.lower())
+        if match:
+            emotion = match.group(1).lower()
+            if emotion in valid_emotions:
+                return emotion, True, None
+
+               
+    if re.search(r"['\"]emotion['\"]", model_output.lower()):
+        return None, False, "invalid_emotion_label"
+    elif any(word in model_output.lower() for word in valid_emotions):
+        return None, False, "emotion_found_but_not_extracted"
+    else:
+        return None, False, "no_emotion_pattern"
+
+
+def evaluate_multimodal_emotion_recognition(result_file_path):
+    
+
+            
+    with open(result_file_path, "r", encoding="utf-8") as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    prediction_errors = defaultdict(list)
+
+            
+    emotion_labels = ["happy", "sad", "neutral", "angry", "worried", "surprise"]
+
+            
+    for item in results:
+        item_id = item["id"]
+        model_output = item["model_output"]
+        gt_label = item["ground_truth"].lower()
+
+                
+        pred_label, is_valid, error_type = extract_emotion_from_output(model_output)
+
+                
+        detailed_item = {
+            "id": item_id,
+            "model_output": model_output,
+            "extracted_prediction": pred_label,
+            "ground_truth": gt_label,
+            "correct": pred_label == gt_label if pred_label else False,
+            "valid": is_valid,
+        }
+        detailed_results.append(detailed_item)
+
+                
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+        elif pred_label != gt_label:
+            error_pattern = f"{gt_label}_to_{pred_label}"
+            prediction_errors[error_pattern].append(item_id)
+
+                      
+        if is_valid:
+            predictions.append(pred_label)
+            ground_truths.append(gt_label)
+
+               
+    if len(predictions) == 0:
+        return {
+            "error": "No valid predictions found",
+            "total_samples": len(results),
+            "extraction_errors": dict(extraction_errors),
+        }
+
+            
+    accuracy = accuracy_score(ground_truths, predictions)
+    weighted_f1 = f1_score(ground_truths, predictions, average="weighted")
+    macro_f1 = f1_score(ground_truths, predictions, average="macro")
+
+          
+    cm = confusion_matrix(ground_truths, predictions, labels=emotion_labels)
+
+            
+    class_report = classification_report(
+        ground_truths,
+        predictions,
+        target_names=emotion_labels,
+        output_dict=True,
+        zero_division=0,
+    )
+
+            
+    evaluation_result = {
+        "task_info": {
+            "task_name": "multimodal.emotion.recognition",
+            "dataset": "MER2023",
+            "evaluation_time": datetime.now().isoformat(),
+            "total_samples": len(results),
+            "valid_predictions": len(predictions),
+            "extraction_success_rate": round(len(predictions) / len(results), 4),
+        },
+        "metrics": {
+            "ACC": round(accuracy, 4),
+            "WAF": round(weighted_f1, 4),
+            "Macro_F1": round(macro_f1, 4),
+        },
+        "per_class_metrics": {
+            label: {
+                "precision": round(class_report[label]["precision"], 4),
+                "recall": round(class_report[label]["recall"], 4),
+                "f1_score": round(class_report[label]["f1-score"], 4),
+                "support": int(class_report[label]["support"]),
+            }
+            for label in emotion_labels
+            if label in class_report
+        },
+        "confusion_matrix": {"labels": emotion_labels, "matrix": cm.tolist()},
+        "error_analysis": {
+            "extraction_errors": {
+                error_type: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_type, sample_ids in extraction_errors.items()
+            },
+            "prediction_errors": {
+                error_pattern: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_pattern, sample_ids in prediction_errors.items()
+            },
+        },
+        "distribution": {
+            "ground_truth": dict(Counter(ground_truths)),
+            "predictions": dict(Counter(predictions)),
+        },
+    }
+
+             
+    base_name = result_file_path.replace(".json", "")
+
+                 
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, "w", encoding="utf-8") as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+                    
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, "w", encoding="utf-8") as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+                 
+    problem_samples = [item for item in detailed_results if not item["correct"]]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, "w", encoding="utf-8") as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+              
+    print(f"Evaluation completed: {len(results)} samples")
+    print(
+        f"Key metrics: ACC={evaluation_result['metrics']['ACC']}, WAF={evaluation_result['metrics']['WAF']}"
+    )
+    print(f"Extraction success rate: {evaluation_result['task_info']['extraction_success_rate']}")
+    print(f"Results saved to: {eval_output_file}")
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)},see {problem_report_file}")
+
+    return evaluation_result
+
+
+      
+if __name__ == "__main__":
+    result_file = "model_result.json"             
+
+    try:
+        evaluation_result = evaluate_multimodal_emotion_recognition(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: File not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: {result_file} Invalid format")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")
+

code/evaluation_code/level1/evaluation_MESA.py

@@ -0,0 +1,215 @@
+import json
+import re
+from collections import Counter, defaultdict
+from datetime import datetime
+
+import numpy as np
+from sklearn.metrics import (
+    accuracy_score,
+    classification_report,
+    confusion_matrix,
+    f1_score,
+)
+
+
+def extract_emotion_from_output(model_output):
+
+    if not model_output:
+        return None, False, "empty_output"
+
+               
+    valid_emotions = [
+        "very_positive",
+        "positive",
+        "neutral",
+        "negative",
+        "very_negative",
+    ]
+
+                     
+    patterns = [
+        r"['\"]emotion['\"]:\s*['\"](\w+)['\"]",                          
+        r"['\"]emotion['\"]:\s*['\"]([a-z_]+)['\"]",                                        
+        r"emotion['\"]?\s*:\s*['\"]?(\w+)['\"]?",                    
+        r"emotion['\"]?\s*:\s*['\"]?([a-z_]+)['\"]?",                                  
+        r"\b(very_positive|very_negative|positive|negative|neutral)\b",           
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, model_output.lower())
+        if match:
+            emotion = match.group(1).lower()
+            if emotion in valid_emotions:
+                return emotion, True, None
+
+               
+    if re.search(r"['\"]emotion['\"]", model_output.lower()):
+        return None, False, "invalid_emotion_label"
+    elif any(word in model_output.lower() for word in valid_emotions):
+        return None, False, "emotion_found_but_not_extracted"
+    else:
+        return None, False, "no_emotion_pattern"
+
+
+def evaluate_meme_sentiment_analysis(result_file_path):
+
+
+            
+    with open(result_file_path, "r", encoding="utf-8") as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    prediction_errors = defaultdict(list)
+
+            
+    sentiment_labels = [
+        "very_positive",
+        "positive",
+        "neutral",
+        "negative",
+        "very_negative",
+    ]
+
+            
+    for item in results:
+        item_id = item["id"]
+        model_output = item["model_output"]
+        gt_label = item["ground_truth"].lower()
+
+                
+        pred_label, is_valid, error_type = extract_emotion_from_output(model_output)
+
+                
+        detailed_item = {
+            "id": item_id,
+            "model_output": model_output,
+            "extracted_prediction": pred_label,
+            "ground_truth": gt_label,
+            "correct": pred_label == gt_label if pred_label else False,
+            "valid": is_valid,
+        }
+        detailed_results.append(detailed_item)
+
+                
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+        elif pred_label != gt_label:
+            error_pattern = f"{gt_label}_to_{pred_label}"
+            prediction_errors[error_pattern].append(item_id)
+
+                      
+        if is_valid:
+            predictions.append(pred_label)
+            ground_truths.append(gt_label)
+
+               
+    if len(predictions) == 0:
+        return {
+            "error": "No valid predictions found",
+            "total_samples": len(results),
+            "extraction_errors": dict(extraction_errors),
+        }
+
+            
+    accuracy = accuracy_score(ground_truths, predictions)
+    weighted_f1 = f1_score(ground_truths, predictions, average="weighted")
+    macro_f1 = f1_score(ground_truths, predictions, average="macro")
+
+          
+    cm = confusion_matrix(ground_truths, predictions, labels=sentiment_labels)
+
+            
+    class_report = classification_report(
+        ground_truths,
+        predictions,
+        target_names=sentiment_labels,
+        output_dict=True,
+        zero_division=0,
+    )
+
+            
+    evaluation_result = {
+        "task_info": {
+            "task_name": "meme.sentiment.analysis",
+            "dataset": "Memotion",
+            "evaluation_time": datetime.now().isoformat(),
+            "total_samples": len(results),
+            "valid_predictions": len(predictions),
+            "extraction_success_rate": round(len(predictions) / len(results), 4),
+        },
+        "metrics": {
+            "ACC": round(accuracy, 4),
+            "WAF": round(weighted_f1, 4),
+            "Macro_F1": round(macro_f1, 4),
+        },
+        "per_class_metrics": {
+            label: {
+                "precision": round(class_report[label]["precision"], 4),
+                "recall": round(class_report[label]["recall"], 4),
+                "f1_score": round(class_report[label]["f1-score"], 4),
+                "support": int(class_report[label]["support"]),
+            }
+            for label in sentiment_labels
+            if label in class_report
+        },
+        "confusion_matrix": {"labels": sentiment_labels, "matrix": cm.tolist()},
+        "error_analysis": {
+            "extraction_errors": {
+                error_type: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_type, sample_ids in extraction_errors.items()
+            },
+            "prediction_errors": {
+                error_pattern: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_pattern, sample_ids in prediction_errors.items()
+            },
+        },
+        "distribution": {
+            "ground_truth": dict(Counter(ground_truths)),
+            "predictions": dict(Counter(predictions)),
+        },
+    }
+
+             
+    base_name = result_file_path.replace(".json", "")
+
+                 
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, "w", encoding="utf-8") as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+                    
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, "w", encoding="utf-8") as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+                 
+    problem_samples = [item for item in detailed_results if not item["correct"]]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, "w", encoding="utf-8") as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+              
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)},see {problem_report_file}")
+
+    return evaluation_result
+
+
+      
+if __name__ == "__main__":
+    result_file = "model_result.json"             
+
+    try:
+        evaluation_result = evaluate_meme_sentiment_analysis(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: File not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: {result_file} Invalid format")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")
+

code/evaluation_code/level1/evaluation_MSA.py

@@ -0,0 +1,200 @@
+import json
+import re
+from collections import Counter, defaultdict
+from datetime import datetime
+
+import numpy as np
+from sklearn.metrics import (
+    accuracy_score,
+    classification_report,
+    confusion_matrix,
+    f1_score,
+)
+
+
+def extract_emotion_from_output(model_output):
+
+    if not model_output:
+        return None, False, "empty_output"
+
+               
+    valid_emotions = ["neutral", "negative", "positive"]
+
+                     
+    patterns = [
+        r"['\"]emotion['\"]:\s*['\"](\w+)['\"]",                          
+        r"emotion['\"]?\s*:\s*['\"]?(\w+)['\"]?",                    
+        r"\b(neutral|negative|positive)\b",           
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, model_output.lower())
+        if match:
+            emotion = match.group(1).lower()
+            if emotion in valid_emotions:
+                return emotion, True, None
+
+               
+    if re.search(r"['\"]emotion['\"]", model_output.lower()):
+        return None, False, "invalid_emotion_label"
+    elif any(word in model_output.lower() for word in valid_emotions):
+        return None, False, "emotion_found_but_not_extracted"
+    else:
+        return None, False, "no_emotion_pattern"
+
+
+def evaluate_multimodal_sentiment_analysis(result_file_path):
+
+
+            
+    with open(result_file_path, "r", encoding="utf-8") as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    prediction_errors = defaultdict(list)
+
+            
+    sentiment_labels = ["positive", "neutral", "negative"]
+
+            
+    for item in results:
+        item_id = item["id"]
+        model_output = item["model_output"]
+        gt_label = item["ground_truth"].lower()
+
+                
+        pred_label, is_valid, error_type = extract_emotion_from_output(model_output)
+
+                
+        detailed_item = {
+            "id": item_id,
+            "model_output": model_output,
+            "extracted_prediction": pred_label,
+            "ground_truth": gt_label,
+            "correct": pred_label == gt_label if pred_label else False,
+            "valid": is_valid,
+        }
+        detailed_results.append(detailed_item)
+
+                
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+        elif pred_label != gt_label:
+            error_pattern = f"{gt_label}_to_{pred_label}"
+            prediction_errors[error_pattern].append(item_id)
+
+                      
+        if is_valid:
+            predictions.append(pred_label)
+            ground_truths.append(gt_label)
+
+               
+    if len(predictions) == 0:
+        return {
+            "error": "No valid predictions found",
+            "total_samples": len(results),
+            "extraction_errors": dict(extraction_errors),
+        }
+
+            
+    accuracy = accuracy_score(ground_truths, predictions)
+    weighted_f1 = f1_score(ground_truths, predictions, average="weighted")
+    macro_f1 = f1_score(ground_truths, predictions, average="macro")
+
+          
+    cm = confusion_matrix(ground_truths, predictions, labels=sentiment_labels)
+
+            
+    class_report = classification_report(
+        ground_truths,
+        predictions,
+        target_names=sentiment_labels,
+        output_dict=True,
+        zero_division=0,
+    )
+
+            
+    evaluation_result = {
+        "task_info": {
+            "task_name": "multimodal.sentiment.analysis",
+            "dataset": "CH-SIMSv2",
+            "evaluation_time": datetime.now().isoformat(),
+            "total_samples": len(results),
+            "valid_predictions": len(predictions),
+            "extraction_success_rate": round(len(predictions) / len(results), 4),
+        },
+        "metrics": {
+            "ACC": round(accuracy, 4),
+            "WAF": round(weighted_f1, 4),
+            "Macro_F1": round(macro_f1, 4),
+        },
+        "per_class_metrics": {
+            label: {
+                "precision": round(class_report[label]["precision"], 4),
+                "recall": round(class_report[label]["recall"], 4),
+                "f1_score": round(class_report[label]["f1-score"], 4),
+                "support": int(class_report[label]["support"]),
+            }
+            for label in sentiment_labels
+            if label in class_report
+        },
+        "confusion_matrix": {"labels": sentiment_labels, "matrix": cm.tolist()},
+        "error_analysis": {
+            "extraction_errors": {
+                error_type: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_type, sample_ids in extraction_errors.items()
+            },
+            "prediction_errors": {
+                error_pattern: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_pattern, sample_ids in prediction_errors.items()
+            },
+        },
+        "distribution": {
+            "ground_truth": dict(Counter(ground_truths)),
+            "predictions": dict(Counter(predictions)),
+        },
+    }
+
+             
+    base_name = result_file_path.replace(".json", "")
+
+                 
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, "w", encoding="utf-8") as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+                    
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, "w", encoding="utf-8") as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+                 
+    problem_samples = [item for item in detailed_results if not item["correct"]]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, "w", encoding="utf-8") as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+              
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)},see {problem_report_file}")
+
+    return evaluation_result
+
+
+      
+if __name__ == "__main__":
+    result_file = "model_result.json"             
+
+    try:
+        evaluation_result = evaluate_multimodal_sentiment_analysis(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: File not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: {result_file} Invalid format")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")

code/evaluation_code/level1/evaluation_OSA.py

@@ -0,0 +1,200 @@
+import json
+import re
+from collections import Counter, defaultdict
+from datetime import datetime
+
+import numpy as np
+from sklearn.metrics import (
+    accuracy_score,
+    classification_report,
+    confusion_matrix,
+    f1_score,
+)
+
+
+def extract_emotion_from_output(model_output):
+    
+    if not model_output:
+        return None, False, "empty_output"
+
+               
+    valid_emotions = ["neutral", "negative", "positive"]
+
+                     
+    patterns = [
+        r"['\"]emotion['\"]:\s*['\"](\w+)['\"]",                          
+        r"emotion['\"]?\s*:\s*['\"]?(\w+)['\"]?",                    
+        r"\b(neutral|negative|positive)\b",           
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, model_output.lower())
+        if match:
+            emotion = match.group(1).lower()
+            if emotion in valid_emotions:
+                return emotion, True, None
+
+               
+    if re.search(r"['\"]emotion['\"]", model_output.lower()):
+        return None, False, "invalid_emotion_label"
+    elif any(word in model_output.lower() for word in valid_emotions):
+        return None, False, "emotion_found_but_not_extracted"
+    else:
+        return None, False, "no_emotion_pattern"
+
+
+def evaluate_opinion_sentiment_analysis(result_file_path):
+    
+
+            
+    with open(result_file_path, "r", encoding="utf-8") as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    prediction_errors = defaultdict(list)
+
+            
+    sentiment_labels = ["positive", "neutral", "negative"]
+
+            
+    for item in results:
+        item_id = item["id"]
+        model_output = item["model_output"]
+        gt_label = item["ground_truth"].lower()
+
+                
+        pred_label, is_valid, error_type = extract_emotion_from_output(model_output)
+
+                
+        detailed_item = {
+            "id": item_id,
+            "model_output": model_output,
+            "extracted_prediction": pred_label,
+            "ground_truth": gt_label,
+            "correct": pred_label == gt_label if pred_label else False,
+            "valid": is_valid,
+        }
+        detailed_results.append(detailed_item)
+
+                
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+        elif pred_label != gt_label:
+            error_pattern = f"{gt_label}_to_{pred_label}"
+            prediction_errors[error_pattern].append(item_id)
+
+                      
+        if is_valid:
+            predictions.append(pred_label)
+            ground_truths.append(gt_label)
+
+               
+    if len(predictions) == 0:
+        return {
+            "error": "No valid predictions found",
+            "total_samples": len(results),
+            "extraction_errors": dict(extraction_errors),
+        }
+
+            
+    accuracy = accuracy_score(ground_truths, predictions)
+    weighted_f1 = f1_score(ground_truths, predictions, average="weighted")
+    macro_f1 = f1_score(ground_truths, predictions, average="macro")
+
+          
+    cm = confusion_matrix(ground_truths, predictions, labels=sentiment_labels)
+
+            
+    class_report = classification_report(
+        ground_truths,
+        predictions,
+        target_names=sentiment_labels,
+        output_dict=True,
+        zero_division=0,
+    )
+
+            
+    evaluation_result = {
+        "task_info": {
+            "task_name": "opinion.sentiment.analysis",
+            "dataset": "CMU-MOSI",
+            "evaluation_time": datetime.now().isoformat(),
+            "total_samples": len(results),
+            "valid_predictions": len(predictions),
+            "extraction_success_rate": round(len(predictions) / len(results), 4),
+        },
+        "metrics": {
+            "ACC": round(accuracy, 4),
+            "WAF": round(weighted_f1, 4),
+            "Macro_F1": round(macro_f1, 4),
+        },
+        "per_class_metrics": {
+            label: {
+                "precision": round(class_report[label]["precision"], 4),
+                "recall": round(class_report[label]["recall"], 4),
+                "f1_score": round(class_report[label]["f1-score"], 4),
+                "support": int(class_report[label]["support"]),
+            }
+            for label in sentiment_labels
+            if label in class_report
+        },
+        "confusion_matrix": {"labels": sentiment_labels, "matrix": cm.tolist()},
+        "error_analysis": {
+            "extraction_errors": {
+                error_type: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_type, sample_ids in extraction_errors.items()
+            },
+            "prediction_errors": {
+                error_pattern: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_pattern, sample_ids in prediction_errors.items()
+            },
+        },
+        "distribution": {
+            "ground_truth": dict(Counter(ground_truths)),
+            "predictions": dict(Counter(predictions)),
+        },
+    }
+
+             
+    base_name = result_file_path.replace(".json", "")
+
+                 
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, "w", encoding="utf-8") as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+                    
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, "w", encoding="utf-8") as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+                 
+    problem_samples = [item for item in detailed_results if not item["correct"]]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, "w", encoding="utf-8") as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+              
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)},see {problem_report_file}")
+
+    return evaluation_result
+
+
+      
+if __name__ == "__main__":
+    result_file = "model_result.json"             
+
+    try:
+        evaluation_result = evaluate_opinion_sentiment_analysis(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: File not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: {result_file} Invalid format")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")

code/evaluation_code/level1/evaluation_SCEA.py

@@ -0,0 +1,193 @@
+import json
+import re
+from sklearn.metrics import accuracy_score, f1_score, classification_report, confusion_matrix
+from collections import Counter, defaultdict
+from datetime import datetime
+import numpy as np
+
+def extract_emotion_from_output(model_output):
+
+    if not model_output:
+        return None, False, "empty_output"
+    
+               
+    valid_emotions = ['weak negative', 'strong negative', 'neutral', 'strong positive', 'weak positive']
+    
+                     
+    patterns = [
+        r"['\"]emotion['\"]:\s*['\"]([^'\"]+)['\"]",                                       
+        r"emotion['\"]?\s*:\s*['\"]?([^'\"]+)['\"]?",                                 
+        r"\b(weak\s+negative|strong\s+negative|neutral|strong\s+positive|weak\s+positive)\b"           
+    ]
+    
+    for pattern in patterns:
+        match = re.search(pattern, model_output.lower(), re.IGNORECASE)
+        if match:
+            emotion = match.group(1).lower().strip()
+            if emotion in valid_emotions:
+                return emotion, True, None
+    
+               
+    if re.search(r"['\"]emotion['\"]", model_output.lower()):
+        return None, False, "invalid_emotion_label"
+    elif any(word in model_output.lower() for word in ['negative', 'positive', 'neutral']):
+        return None, False, "emotion_found_but_not_extracted"
+    else:
+        return None, False, "no_emotion_pattern"
+
+def evaluate_stock_comment_emotion_analysis(result_file_path):
+
+    
+            
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+    
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    prediction_errors = defaultdict(list)
+    
+                      
+    sentiment_labels = ['strong negative', 'weak negative', 'neutral', 'weak positive', 'strong positive']
+    
+            
+    for item in results:
+        item_id = item['id']
+        model_output = item['model_output']
+        gt_label = item['ground_truth'].lower()
+        
+                
+        pred_label, is_valid, error_type = extract_emotion_from_output(model_output)
+        
+                
+        detailed_item = {
+            'id': item_id,
+            'model_output': model_output,
+            'extracted_prediction': pred_label,
+            'ground_truth': gt_label,
+            'correct': pred_label == gt_label if pred_label else False,
+            'valid': is_valid
+        }
+        detailed_results.append(detailed_item)
+        
+                
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+        elif pred_label != gt_label:
+            error_pattern = f"{gt_label}_to_{pred_label}"
+            prediction_errors[error_pattern].append(item_id)
+        
+                      
+        if is_valid:
+            predictions.append(pred_label)
+            ground_truths.append(gt_label)
+    
+               
+    if len(predictions) == 0:
+        return {
+            'error': 'No valid predictions found',
+            'total_samples': len(results),
+            'extraction_errors': dict(extraction_errors)
+        }
+    
+            
+    accuracy = accuracy_score(ground_truths, predictions)
+    weighted_f1 = f1_score(ground_truths, predictions, average='weighted')
+    macro_f1 = f1_score(ground_truths, predictions, average='macro')
+    
+          
+    cm = confusion_matrix(ground_truths, predictions, labels=sentiment_labels)
+    
+            
+    class_report = classification_report(ground_truths, predictions, 
+                                       target_names=sentiment_labels, 
+                                       output_dict=True,
+                                       zero_division=0)
+    
+            
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'stock.comment.emotion.analysis',
+            'dataset': 'FMSA-SC',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_predictions': len(predictions),
+            'extraction_success_rate': round(len(predictions) / len(results), 4)
+        },
+        'metrics': {
+            'ACC': round(accuracy, 4),
+            'WAF': round(weighted_f1, 4),
+            'Macro_F1': round(macro_f1, 4)
+        },
+        'per_class_metrics': {
+            label: {
+                'precision': round(class_report[label]['precision'], 4),
+                'recall': round(class_report[label]['recall'], 4),
+                'f1_score': round(class_report[label]['f1-score'], 4),
+                'support': int(class_report[label]['support'])
+            } for label in sentiment_labels if label in class_report
+        },
+        'confusion_matrix': {
+            'labels': sentiment_labels,
+            'matrix': cm.tolist()
+        },
+        'error_analysis': {
+            'extraction_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_type, sample_ids in extraction_errors.items()
+            },
+            'prediction_errors': {
+                error_pattern: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_pattern, sample_ids in prediction_errors.items()
+            }
+        },
+        'distribution': {
+            'ground_truth': dict(Counter(ground_truths)),
+            'predictions': dict(Counter(predictions))
+        }
+    }
+    
+             
+    base_name = result_file_path.replace('.json', '')
+    
+                 
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+    
+                    
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+    
+                 
+    problem_samples = [item for item in detailed_results if not item['correct']]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, 'w', encoding='utf-8') as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+    
+              
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)},see {problem_report_file}")
+
+    return evaluation_result
+
+      
+if __name__ == "__main__":
+    result_file = "model_result.json"             
+    
+    try:
+        evaluation_result = evaluate_stock_comment_emotion_analysis(result_file)
+        
+    except FileNotFoundError:
+        print(f"Error: File not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: {result_file} Invalid format")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")

code/evaluation_code/level1/evaluation_SIA.py

@@ -0,0 +1,218 @@
+import json
+import re
+from collections import Counter, defaultdict
+from datetime import datetime
+
+import numpy as np
+from sklearn.metrics import (
+    accuracy_score,
+    classification_report,
+    confusion_matrix,
+    f1_score,
+)
+
+
+def extract_emotion_from_output(model_output):
+
+    if not model_output:
+        return None, False, "empty_output"
+
+                 
+    valid_emotions = [
+        "strong negative",
+        "moderate negative",
+        "slight negative",
+        "neutral",
+        "slight positive",
+        "moderate positive",
+        "strong positive",
+    ]
+
+                     
+    patterns = [
+        r"['\"]emotion['\"]:\s*['\"]([^'\"]+)['\"]",                                         
+        r"emotion['\"]?\s*:\s*['\"]?([^'\"]+)['\"]?",                                   
+        r"\b(strong\s+negative|moderate\s+negative|slight\s+negative|neutral|slight\s+positive|moderate\s+positive|strong\s+positive)\b",           
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, model_output.lower(), re.IGNORECASE)
+        if match:
+            emotion = match.group(1).lower().strip()
+            if emotion in valid_emotions:
+                return emotion, True, None
+
+               
+    if re.search(r"['\"]emotion['\"]", model_output.lower()):
+        return None, False, "invalid_emotion_label"
+    elif any(
+        word in model_output.lower() for word in ["negative", "positive", "neutral"]
+    ):
+        return None, False, "emotion_found_but_not_extracted"
+    else:
+        return None, False, "no_emotion_pattern"
+
+
+def evaluate_sentiment_intensity_analysis(result_file_path):
+
+
+            
+    with open(result_file_path, "r", encoding="utf-8") as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    prediction_errors = defaultdict(list)
+
+                      
+    intensity_labels = [
+        "strong negative",
+        "moderate negative",
+        "slight negative",
+        "neutral",
+        "slight positive",
+        "moderate positive",
+        "strong positive",
+    ]
+
+            
+    for item in results:
+        item_id = item["id"]
+        model_output = item["model_output"]
+        gt_label = item["ground_truth"].lower()
+
+                
+        pred_label, is_valid, error_type = extract_emotion_from_output(model_output)
+
+                
+        detailed_item = {
+            "id": item_id,
+            "model_output": model_output,
+            "extracted_prediction": pred_label,
+            "ground_truth": gt_label,
+            "correct": pred_label == gt_label if pred_label else False,
+            "valid": is_valid,
+        }
+        detailed_results.append(detailed_item)
+
+                
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+        elif pred_label != gt_label:
+            error_pattern = f"{gt_label}_to_{pred_label}"
+            prediction_errors[error_pattern].append(item_id)
+
+                      
+        if is_valid:
+            predictions.append(pred_label)
+            ground_truths.append(gt_label)
+
+               
+    if len(predictions) == 0:
+        return {
+            "error": "No valid predictions found",
+            "total_samples": len(results),
+            "extraction_errors": dict(extraction_errors),
+        }
+
+            
+    accuracy = accuracy_score(ground_truths, predictions)
+    weighted_f1 = f1_score(ground_truths, predictions, average="weighted")
+    macro_f1 = f1_score(ground_truths, predictions, average="macro")
+
+          
+    cm = confusion_matrix(ground_truths, predictions, labels=intensity_labels)
+
+            
+    class_report = classification_report(
+        ground_truths,
+        predictions,
+        target_names=intensity_labels,
+        output_dict=True,
+        zero_division=0,
+    )
+
+            
+    evaluation_result = {
+        "task_info": {
+            "task_name": "sentiment.intensity.analysis",
+            "dataset": "CMU-MOSEI",
+            "evaluation_time": datetime.now().isoformat(),
+            "total_samples": len(results),
+            "valid_predictions": len(predictions),
+            "extraction_success_rate": round(len(predictions) / len(results), 4),
+        },
+        "metrics": {
+            "ACC": round(accuracy, 4),
+            "WAF": round(weighted_f1, 4),
+            "Macro_F1": round(macro_f1, 4),
+        },
+        "per_class_metrics": {
+            label: {
+                "precision": round(class_report[label]["precision"], 4),
+                "recall": round(class_report[label]["recall"], 4),
+                "f1_score": round(class_report[label]["f1-score"], 4),
+                "support": int(class_report[label]["support"]),
+            }
+            for label in intensity_labels
+            if label in class_report
+        },
+        "confusion_matrix": {"labels": intensity_labels, "matrix": cm.tolist()},
+        "error_analysis": {
+            "extraction_errors": {
+                error_type: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_type, sample_ids in extraction_errors.items()
+            },
+            "prediction_errors": {
+                error_pattern: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_pattern, sample_ids in prediction_errors.items()
+            },
+        },
+        "distribution": {
+            "ground_truth": dict(Counter(ground_truths)),
+            "predictions": dict(Counter(predictions)),
+        },
+    }
+
+             
+    base_name = result_file_path.replace(".json", "")
+
+                 
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, "w", encoding="utf-8") as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+                    
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, "w", encoding="utf-8") as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+                 
+    problem_samples = [item for item in detailed_results if not item["correct"]]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, "w", encoding="utf-8") as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)},see {problem_report_file}")
+
+    return evaluation_result
+
+
+      
+if __name__ == "__main__":
+    result_file = "model_result.json"             
+
+    try:
+        evaluation_result = evaluate_sentiment_intensity_analysis(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: File not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: {result_file} Invalid format")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")

code/evaluation_code/level1/evaluation_SOER.py

@@ -0,0 +1,199 @@
+import json
+import re
+from collections import Counter, defaultdict
+from datetime import datetime
+
+import numpy as np
+from sklearn.metrics import (
+    accuracy_score,
+    classification_report,
+    confusion_matrix,
+    f1_score,
+)
+
+
+def extract_emotion_from_output(model_output):
+
+    if not model_output:
+        return None, False, "empty_output"
+
+               
+    valid_emotions = ["neutral", "calm", "happy", "sad", "angry", "fearful"]
+
+                     
+    patterns = [
+        r"['\"]emotion['\"]:\s*['\"](\w+)['\"]",                          
+        r"emotion['\"]?\s*:\s*['\"]?(\w+)['\"]?",                    
+        r"\b(neutral|calm|happy|sad|angry|fearful)\b",           
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, model_output.lower())
+        if match:
+            emotion = match.group(1).lower()
+            if emotion in valid_emotions:
+                return emotion, True, None
+
+               
+    if re.search(r"['\"]emotion['\"]", model_output.lower()):
+        return None, False, "invalid_emotion_label"
+    elif any(word in model_output.lower() for word in valid_emotions):
+        return None, False, "emotion_found_but_not_extracted"
+    else:
+        return None, False, "no_emotion_pattern"
+
+
+def evaluate_song_emotion_recognition(result_file_path):
+
+
+            
+    with open(result_file_path, "r", encoding="utf-8") as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    prediction_errors = defaultdict(list)
+
+            
+    emotion_labels = ["neutral", "calm", "happy", "sad", "angry", "fearful"]
+
+            
+    for item in results:
+        item_id = item["id"]
+        model_output = item["model_output"]
+        gt_label = item["ground_truth"].lower()
+
+                
+        pred_label, is_valid, error_type = extract_emotion_from_output(model_output)
+
+                
+        detailed_item = {
+            "id": item_id,
+            "model_output": model_output,
+            "extracted_prediction": pred_label,
+            "ground_truth": gt_label,
+            "correct": pred_label == gt_label if pred_label else False,
+            "valid": is_valid,
+        }
+        detailed_results.append(detailed_item)
+
+                
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+        elif pred_label != gt_label:
+            error_pattern = f"{gt_label}_to_{pred_label}"
+            prediction_errors[error_pattern].append(item_id)
+
+                      
+        if is_valid:
+            predictions.append(pred_label)
+            ground_truths.append(gt_label)
+
+               
+    if len(predictions) == 0:
+        return {
+            "error": "No valid predictions found",
+            "total_samples": len(results),
+            "extraction_errors": dict(extraction_errors),
+        }
+
+            
+    accuracy = accuracy_score(ground_truths, predictions)
+    weighted_f1 = f1_score(ground_truths, predictions, average="weighted")
+    macro_f1 = f1_score(ground_truths, predictions, average="macro")
+
+          
+    cm = confusion_matrix(ground_truths, predictions, labels=emotion_labels)
+
+            
+    class_report = classification_report(
+        ground_truths,
+        predictions,
+        target_names=emotion_labels,
+        output_dict=True,
+        zero_division=0,
+    )
+
+            
+    evaluation_result = {
+        "task_info": {
+            "task_name": "song.emotion.recognition",
+            "dataset": "RAVDESS",
+            "evaluation_time": datetime.now().isoformat(),
+            "total_samples": len(results),
+            "valid_predictions": len(predictions),
+            "extraction_success_rate": round(len(predictions) / len(results), 4),
+        },
+        "metrics": {
+            "ACC": round(accuracy, 4),
+            "WAF": round(weighted_f1, 4),
+            "Macro_F1": round(macro_f1, 4),
+        },
+        "per_class_metrics": {
+            label: {
+                "precision": round(class_report[label]["precision"], 4),
+                "recall": round(class_report[label]["recall"], 4),
+                "f1_score": round(class_report[label]["f1-score"], 4),
+                "support": int(class_report[label]["support"]),
+            }
+            for label in emotion_labels
+            if label in class_report
+        },
+        "confusion_matrix": {"labels": emotion_labels, "matrix": cm.tolist()},
+        "error_analysis": {
+            "extraction_errors": {
+                error_type: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_type, sample_ids in extraction_errors.items()
+            },
+            "prediction_errors": {
+                error_pattern: {"count": len(sample_ids), "sample_ids": sample_ids}
+                for error_pattern, sample_ids in prediction_errors.items()
+            },
+        },
+        "distribution": {
+            "ground_truth": dict(Counter(ground_truths)),
+            "predictions": dict(Counter(predictions)),
+        },
+    }
+
+             
+    base_name = result_file_path.replace(".json", "")
+
+                 
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, "w", encoding="utf-8") as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+                    
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, "w", encoding="utf-8") as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+                 
+    problem_samples = [item for item in detailed_results if not item["correct"]]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, "w", encoding="utf-8") as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)},see {problem_report_file}")
+
+    return evaluation_result
+
+
+      
+if __name__ == "__main__":
+    result_file = "model_result.json"             
+
+    try:
+        evaluation_result = evaluate_song_emotion_recognition(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: File not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: {result_file} Invalid format")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")

code/evaluation_code/level1/evaluation_SPER.py

@@ -0,0 +1,195 @@
+import json
+import re
+from sklearn.metrics import accuracy_score, f1_score, classification_report, confusion_matrix
+from collections import Counter, defaultdict
+from datetime import datetime
+import numpy as np
+
+def extract_emotion_from_output(model_output):
+
+    if not model_output:
+        return None, False, "empty_output"
+    
+               
+    valid_emotions = ['neutral', 'calm', 'happy', 'sad', 'angry', 'fearful', 'surprised', 'surprise','disgust']
+    
+                     
+    patterns = [
+        r"['\"]emotion['\"]:\s*['\"](\w+)['\"]",                          
+        r"emotion['\"]?\s*:\s*['\"]?(\w+)['\"]?",                    
+        r"\b(neutral|calm|happy|sad|angry|fearful|surprised|disgust)\b"           
+    ]
+    
+    for pattern in patterns:
+        match = re.search(pattern, model_output.lower())
+        if match:
+            emotion = match.group(1).lower()
+            if emotion in valid_emotions:
+                return emotion, True, None
+    
+               
+    if re.search(r"['\"]emotion['\"]", model_output.lower()):
+        return None, False, "invalid_emotion_label"
+    elif any(word in model_output.lower() for word in valid_emotions):
+        return None, False, "emotion_found_but_not_extracted"
+    else:
+        return None, False, "no_emotion_pattern"
+
+def evaluate_speech_emotion_recognition(result_file_path):
+
+    
+            
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+    
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    prediction_errors = defaultdict(list)
+    
+            
+    emotion_labels = ['neutral', 'calm', 'happy', 'sad', 'angry', 'fearful', 'surprised', 'disgust']
+    
+            
+    for item in results:
+        item_id = item['id']
+        model_output = item['model_output']
+        gt_label = item['ground_truth'].lower()
+        
+                
+        pred_label, is_valid, error_type = extract_emotion_from_output(model_output)
+        
+                
+        detailed_item = {
+            'id': item_id,
+            'model_output': model_output,
+            'extracted_prediction': pred_label,
+            'ground_truth': gt_label,
+            'correct': pred_label == gt_label if pred_label else False,
+            'valid': is_valid
+        }
+        detailed_results.append(detailed_item)
+        
+                
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+        elif pred_label != gt_label:
+            error_pattern = f"{gt_label}_to_{pred_label}"
+            prediction_errors[error_pattern].append(item_id)
+        
+                      
+        if is_valid:
+            predictions.append(pred_label)
+            ground_truths.append(gt_label)
+    
+               
+    if len(predictions) == 0:
+        return {
+            'error': 'No valid predictions found',
+            'total_samples': len(results),
+            'extraction_errors': dict(extraction_errors)
+        }
+    
+            
+    accuracy = accuracy_score(ground_truths, predictions)
+    weighted_f1 = f1_score(ground_truths, predictions, average='weighted')
+    macro_f1 = f1_score(ground_truths, predictions, average='macro')
+    
+          
+    cm = confusion_matrix(ground_truths, predictions, labels=emotion_labels)
+    
+            
+    class_report = classification_report(ground_truths, predictions, 
+                                       target_names=emotion_labels, 
+                                       output_dict=True,
+                                       zero_division=0)
+    
+            
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'speech.emotion.recognition',
+            'dataset': 'RAVDESS',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_predictions': len(predictions),
+            'extraction_success_rate': round(len(predictions) / len(results), 4)
+        },
+        'metrics': {
+            'ACC': round(accuracy, 4),
+            'WAF': round(weighted_f1, 4),
+            'Macro_F1': round(macro_f1, 4)
+        },
+        'per_class_metrics': {
+            label: {
+                'precision': round(class_report[label]['precision'], 4),
+                'recall': round(class_report[label]['recall'], 4),
+                'f1_score': round(class_report[label]['f1-score'], 4),
+                'support': int(class_report[label]['support'])
+            } for label in emotion_labels if label in class_report
+        },
+        'confusion_matrix': {
+            'labels': emotion_labels,
+            'matrix': cm.tolist()
+        },
+        'error_analysis': {
+            'extraction_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_type, sample_ids in extraction_errors.items()
+            },
+            'prediction_errors': {
+                error_pattern: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_pattern, sample_ids in prediction_errors.items()
+            }
+        },
+        'distribution': {
+            'ground_truth': dict(Counter(ground_truths)),
+            'predictions': dict(Counter(predictions))
+        }
+    }
+    
+             
+    base_name = result_file_path.replace('.json', '')
+    
+                 
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+    
+                    
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+    
+                 
+    problem_samples = [item for item in detailed_results if not item['correct']]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, 'w', encoding='utf-8') as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+    
+              
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)},see {problem_report_file}")
+
+    return evaluation_result
+    
+    return evaluation_result
+
+      
+if __name__ == "__main__":
+    result_file = "model_result.json"             
+    
+    try:
+        evaluation_result = evaluate_speech_emotion_recognition(result_file)
+        
+    except FileNotFoundError:
+        print(f"Error: File not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: {result_file} Invalid format")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")

code/evaluation_code/level2/evaluation_DPTM.py

@@ -0,0 +1,263 @@
+import json
+import re
+import ast
+from sklearn.metrics import f1_score, precision_score, recall_score, classification_report
+from collections import Counter, defaultdict
+from datetime import datetime
+import numpy as np
+
+def extract_techniques_from_output(model_output):
+
+    if not model_output:
+        return [], False, "empty_output"
+
+
+    valid_techniques = [
+        "Appeal to authority", "Appeal to fear/prejudice", "Black-and-white Fallacy/Dictatorship",
+        "Causal Oversimplification", "Doubt", "Exaggeration/Minimisation", "Flag-waving",
+        "Glittering generalities (Virtue)", "Loaded Language",
+        "Misrepresentation of Someone's Position (Straw Man)", "Name calling/Labeling",
+        "Obfuscation, Intentional vagueness, Confusion", "Presenting Irrelevant Data (Red Herring)",
+        "Reductio ad hitlerum", "Repetition", "Slogans", "Smears", "Thought-terminating cliché",
+        "Whataboutism", "Bandwagon", "Transfer", "Appeal to (Strong) Emotions"
+    ]
+
+    try:
+
+        if "{'techniques':" in model_output or '{"techniques":' in model_output:
+
+            cleaned_output = model_output.strip()
+            if not cleaned_output.startswith('{'):
+
+                json_match = re.search(r'\{[^}]*\}', cleaned_output)
+                if json_match:
+                    cleaned_output = json_match.group()
+
+
+            try:
+                parsed = ast.literal_eval(cleaned_output)
+            except:
+
+                parsed = json.loads(cleaned_output)
+
+            if 'techniques' in parsed and isinstance(parsed['techniques'], list):
+                techniques = [tech.strip() for tech in parsed['techniques']]
+
+                valid_techniques_found = [tech for tech in techniques if tech in valid_techniques]
+                invalid_techniques = [tech for tech in techniques if tech not in valid_techniques]
+
+                if invalid_techniques:
+                    return valid_techniques_found, False, "invalid_technique_labels"
+                return valid_techniques_found, True, None
+
+
+        found_techniques = []
+        for technique in valid_techniques:
+            if technique in model_output:
+                found_techniques.append(technique)
+
+        if found_techniques:
+            return found_techniques, False, "techniques_found_but_not_properly_formatted"
+
+        return [], False, "no_techniques_pattern"
+
+    except Exception as e:
+        return [], False, f"parsing_error_{str(e)}"
+
+def calculate_multilabel_metrics(y_true_list, y_pred_list, all_labels):
+
+
+    y_true_binary = []
+    y_pred_binary = []
+
+    for y_true, y_pred in zip(y_true_list, y_pred_list):
+        true_vector = [1 if label in y_true else 0 for label in all_labels]
+        pred_vector = [1 if label in y_pred else 0 for label in all_labels]
+        y_true_binary.append(true_vector)
+        y_pred_binary.append(pred_vector)
+
+    y_true_binary = np.array(y_true_binary)
+    y_pred_binary = np.array(y_pred_binary)
+
+
+    micro_f1 = f1_score(y_true_binary, y_pred_binary, average='micro')
+    macro_f1 = f1_score(y_true_binary, y_pred_binary, average='macro')
+    micro_precision = precision_score(y_true_binary, y_pred_binary, average='micro')
+    micro_recall = recall_score(y_true_binary, y_pred_binary, average='micro')
+
+
+    per_label_f1 = f1_score(y_true_binary, y_pred_binary, average=None)
+    per_label_precision = precision_score(y_true_binary, y_pred_binary, average=None)
+    per_label_recall = recall_score(y_true_binary, y_pred_binary, average=None)
+
+    return {
+        'micro_f1': micro_f1,
+        'macro_f1': macro_f1,
+        'micro_precision': micro_precision,
+        'micro_recall': micro_recall,
+        'per_label_metrics': {
+            all_labels[i]: {
+                'f1': per_label_f1[i],
+                'precision': per_label_precision[i],
+                'recall': per_label_recall[i]
+            } for i in range(len(all_labels))
+        }
+    }
+
+def evaluate_persuasion_techniques_detection(result_file_path):
+
+
+
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+
+
+    all_techniques = [
+        "Appeal to authority", "Appeal to fear/prejudice", "Black-and-white Fallacy/Dictatorship",
+        "Causal Oversimplification", "Doubt", "Exaggeration/Minimisation", "Flag-waving",
+        "Glittering generalities (Virtue)", "Loaded Language",
+        "Misrepresentation of Someone's Position (Straw Man)", "Name calling/Labeling",
+        "Obfuscation, Intentional vagueness, Confusion", "Presenting Irrelevant Data (Red Herring)",
+        "Reductio ad hitlerum", "Repetition", "Slogans", "Smears", "Thought-terminating cliché",
+        "Whataboutism", "Bandwagon", "Transfer", "Appeal to (Strong) Emotions"
+    ]
+
+
+    for item in results:
+        item_id = item['id']
+        model_output = item['model_output']
+        gt_techniques = item['ground_truth']['techniques'] if isinstance(item['ground_truth'], dict) else item['ground_truth']
+
+
+        pred_techniques, is_valid, error_type = extract_techniques_from_output(model_output)
+
+
+        detailed_item = {
+            'id': item_id,
+            'model_output': model_output,
+            'extracted_prediction': pred_techniques,
+            'ground_truth': gt_techniques,
+            'exact_match': set(pred_techniques) == set(gt_techniques) if is_valid else False,
+            'valid': is_valid
+        }
+        detailed_results.append(detailed_item)
+
+
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+
+
+        if is_valid:
+            predictions.append(pred_techniques)
+            ground_truths.append(gt_techniques)
+
+
+    if len(predictions) == 0:
+        return {
+            'error': 'No valid predictions found',
+            'total_samples': len(results),
+            'extraction_errors': dict(extraction_errors)
+        }
+
+
+    metrics = calculate_multilabel_metrics(ground_truths, predictions, all_techniques)
+
+
+    exact_matches = sum(1 for item in detailed_results if item['exact_match'])
+    exact_match_accuracy = exact_matches / len([item for item in detailed_results if item['valid']])
+
+
+    all_true_labels = [label for labels in ground_truths for label in labels]
+    all_pred_labels = [label for labels in predictions for label in labels]
+
+
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'detection.of.persuasion.techniques.in.memes',
+            'dataset': 'SemEval-2021 Task 6',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_predictions': len(predictions),
+            'extraction_success_rate': round(len(predictions) / len(results), 4)
+        },
+        'metrics': {
+            'Micro_F1': round(metrics['micro_f1'], 4),
+            'Macro_F1': round(metrics['macro_f1'], 4),
+            'Micro_Precision': round(metrics['micro_precision'], 4),
+            'Micro_Recall': round(metrics['micro_recall'], 4),
+            'Exact_Match_Accuracy': round(exact_match_accuracy, 4)
+        },
+        'per_label_metrics': {
+            label: {
+                'f1': round(metrics['per_label_metrics'][label]['f1'], 4),
+                'precision': round(metrics['per_label_metrics'][label]['precision'], 4),
+                'recall': round(metrics['per_label_metrics'][label]['recall'], 4)
+            } for label in all_techniques
+        },
+        'error_analysis': {
+            'extraction_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_type, sample_ids in extraction_errors.items()
+            }
+        },
+        'label_statistics': {
+            'ground_truth_distribution': dict(Counter(all_true_labels)),
+            'prediction_distribution': dict(Counter(all_pred_labels)),
+            'avg_labels_per_sample': {
+                'ground_truth': round(np.mean([len(labels) for labels in ground_truths]), 2),
+                'predictions': round(np.mean([len(labels) for labels in predictions]), 2)
+            }
+        }
+    }
+
+
+    base_name = result_file_path.replace('.json', '')
+
+
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+
+    problem_samples = [item for item in detailed_results if not item['exact_match']]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, 'w', encoding='utf-8') as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+
+    print(f"Evaluation complete: {len(results)} samples")
+    print(f"Key metrics: Micro F1={evaluation_result['metrics']['Micro_F1']}, Exact Match Acc={evaluation_result['metrics']['Exact_Match_Accuracy']}")
+    print(f"Extraction success rate: {evaluation_result['task_info']['extraction_success_rate']}")
+    print(f"Results saved to: {eval_output_file}")
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)}; see {problem_report_file} for details")
+
+    return evaluation_result
+
+
+if __name__ == "__main__":
+    result_file = "model_result.json"
+
+    try:
+        evaluation_result = evaluate_persuasion_techniques_detection(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: file not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: invalid format for {result_file}")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")
+

code/evaluation_code/level2/evaluation_EBIA.py

@@ -0,0 +1,325 @@
+import json
+import re
+import ast
+from sklearn.metrics import accuracy_score, f1_score, classification_report, confusion_matrix
+from collections import Counter, defaultdict
+from datetime import datetime
+import numpy as np
+
+def extract_emotion_intent_from_output(model_output):
+
+    if not model_output:
+        return None, None, False, "empty_output"
+
+
+    valid_emotions = ['happy', 'surprise', 'sad', 'disgust', 'anger', 'fear', 'neutral']
+    valid_intents = ['questioning', 'agreeing', 'acknowledging', 'encouraging',
+                    'consoling', 'suggesting', 'wishing', 'neutral']
+
+    try:
+
+        if "{'emotion':" in model_output or '{"emotion":' in model_output:
+
+            cleaned_output = model_output.strip()
+
+
+            cleaned_output = re.sub(r"'intent'(\s*,\s*)'", r"'intent':\1'", cleaned_output)
+            cleaned_output = re.sub(r'"intent"(\s*,\s*)"', r'"intent":\1"', cleaned_output)
+
+            if not cleaned_output.startswith('{'):
+
+                json_match = re.search(r'\{[^}]*\}', cleaned_output)
+                if json_match:
+                    cleaned_output = json_match.group()
+
+
+            try:
+                parsed = ast.literal_eval(cleaned_output)
+            except:
+
+                parsed = json.loads(cleaned_output)
+
+            if 'emotion' in parsed and 'intent' in parsed:
+                emotion = parsed['emotion'].lower().strip()
+                intent = parsed['intent'].lower().strip()
+
+                emotion_valid = emotion in valid_emotions
+                intent_valid = intent in valid_intents
+
+                if emotion_valid and intent_valid:
+                    return emotion, intent, True, None
+                elif not emotion_valid and not intent_valid:
+                    return emotion, intent, False, "invalid_emotion_and_intent"
+                elif not emotion_valid:
+                    return emotion, intent, False, "invalid_emotion"
+                else:
+                    return emotion, intent, False, "invalid_intent"
+
+
+        emotion_found = None
+        intent_found = None
+
+        for emotion in valid_emotions:
+            if emotion in model_output.lower():
+                emotion_found = emotion
+                break
+
+        for intent in valid_intents:
+            if intent in model_output.lower():
+                intent_found = intent
+                break
+
+        if emotion_found and intent_found:
+            return emotion_found, intent_found, False, "labels_found_but_not_properly_formatted"
+        elif emotion_found:
+            return emotion_found, None, False, "only_emotion_found"
+        elif intent_found:
+            return None, intent_found, False, "only_intent_found"
+
+        return None, None, False, "no_labels_pattern"
+
+    except Exception as e:
+        return None, None, False, f"parsing_error_{str(e)}"
+
+def parse_ground_truth(ground_truth):
+
+    if isinstance(ground_truth, dict):
+        return ground_truth.get('emotion', '').lower(), ground_truth.get('intent', '').lower()
+    elif isinstance(ground_truth, str):
+
+        cleaned_gt = ground_truth.strip()
+        cleaned_gt = re.sub(r"'intent'(\s*,\s*)'", r"'intent':\1'", cleaned_gt)
+
+        try:
+            parsed = ast.literal_eval(cleaned_gt)
+            return parsed.get('emotion', '').lower(), parsed.get('intent', '').lower()
+        except:
+            return '', ''
+    else:
+        return '', ''
+
+def evaluate_emotion_based_intent_analysis(result_file_path):
+
+
+
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+
+    emotion_predictions = []
+    emotion_ground_truths = []
+    intent_predictions = []
+    intent_ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    prediction_errors = defaultdict(list)
+
+
+    emotion_labels = ['happy', 'surprise', 'sad', 'disgust', 'anger', 'fear', 'neutral']
+    intent_labels = ['questioning', 'agreeing', 'acknowledging', 'encouraging',
+                    'consoling', 'suggesting', 'wishing', 'neutral']
+
+
+    for item in results:
+        item_id = item['id']
+        model_output = item['model_output']
+        gt_emotion, gt_intent = parse_ground_truth(item['ground_truth'])
+
+
+        pred_emotion, pred_intent, is_valid, error_type = extract_emotion_intent_from_output(model_output)
+
+
+        detailed_item = {
+            'id': item_id,
+            'model_output': model_output,
+            'extracted_prediction': {
+                'emotion': pred_emotion,
+                'intent': pred_intent
+            },
+            'ground_truth': {
+                'emotion': gt_emotion,
+                'intent': gt_intent
+            },
+            'emotion_correct': pred_emotion == gt_emotion if pred_emotion else False,
+            'intent_correct': pred_intent == gt_intent if pred_intent else False,
+            'both_correct': (pred_emotion == gt_emotion and pred_intent == gt_intent) if (pred_emotion and pred_intent) else False,
+            'valid': is_valid
+        }
+        detailed_results.append(detailed_item)
+
+
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+        else:
+            if pred_emotion != gt_emotion:
+                error_pattern = f"emotion_{gt_emotion}_to_{pred_emotion}"
+                prediction_errors[error_pattern].append(item_id)
+            if pred_intent != gt_intent:
+                error_pattern = f"intent_{gt_intent}_to_{pred_intent}"
+                prediction_errors[error_pattern].append(item_id)
+
+
+        if is_valid:
+            emotion_predictions.append(pred_emotion)
+            emotion_ground_truths.append(gt_emotion)
+            intent_predictions.append(pred_intent)
+            intent_ground_truths.append(gt_intent)
+
+
+    if len(emotion_predictions) == 0:
+        return {
+            'error': 'No valid predictions found',
+            'total_samples': len(results),
+            'extraction_errors': dict(extraction_errors)
+        }
+
+
+    emotion_accuracy = accuracy_score(emotion_ground_truths, emotion_predictions)
+    emotion_weighted_f1 = f1_score(emotion_ground_truths, emotion_predictions, average='weighted')
+    emotion_macro_f1 = f1_score(emotion_ground_truths, emotion_predictions, average='macro')
+
+
+    intent_accuracy = accuracy_score(intent_ground_truths, intent_predictions)
+    intent_weighted_f1 = f1_score(intent_ground_truths, intent_predictions, average='weighted')
+    intent_macro_f1 = f1_score(intent_ground_truths, intent_predictions, average='macro')
+
+
+    both_correct = sum(1 for item in detailed_results if item['both_correct'])
+    joint_accuracy = both_correct / len([item for item in detailed_results if item['valid']])
+
+
+    emotion_cm = confusion_matrix(emotion_ground_truths, emotion_predictions, labels=emotion_labels)
+    intent_cm = confusion_matrix(intent_ground_truths, intent_predictions, labels=intent_labels)
+
+
+    emotion_class_report = classification_report(emotion_ground_truths, emotion_predictions,
+                                               target_names=emotion_labels,
+                                               output_dict=True, zero_division=0)
+    intent_class_report = classification_report(intent_ground_truths, intent_predictions,
+                                              target_names=intent_labels,
+                                              output_dict=True, zero_division=0)
+
+
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'emotion.based.intent.analysis',
+            'dataset': 'MC-EIU',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_predictions': len(emotion_predictions),
+            'extraction_success_rate': round(len(emotion_predictions) / len(results), 4)
+        },
+        'metrics': {
+            'emotion_metrics': {
+                'ACC': round(emotion_accuracy, 4),
+                'WAF': round(emotion_weighted_f1, 4),
+                'Macro_F1': round(emotion_macro_f1, 4)
+            },
+            'intent_metrics': {
+                'ACC': round(intent_accuracy, 4),
+                'WAF': round(intent_weighted_f1, 4),
+                'Macro_F1': round(intent_macro_f1, 4)
+            },
+            'joint_metrics': {
+                'Joint_ACC': round(joint_accuracy, 4)
+            }
+        },
+        'per_class_metrics': {
+            'emotion': {
+                label: {
+                    'precision': round(emotion_class_report[label]['precision'], 4),
+                    'recall': round(emotion_class_report[label]['recall'], 4),
+                    'f1_score': round(emotion_class_report[label]['f1-score'], 4),
+                    'support': int(emotion_class_report[label]['support'])
+                } for label in emotion_labels if label in emotion_class_report
+            },
+            'intent': {
+                label: {
+                    'precision': round(intent_class_report[label]['precision'], 4),
+                    'recall': round(intent_class_report[label]['recall'], 4),
+                    'f1_score': round(intent_class_report[label]['f1-score'], 4),
+                    'support': int(intent_class_report[label]['support'])
+                } for label in intent_labels if label in intent_class_report
+            }
+        },
+        'confusion_matrices': {
+            'emotion': {
+                'labels': emotion_labels,
+                'matrix': emotion_cm.tolist()
+            },
+            'intent': {
+                'labels': intent_labels,
+                'matrix': intent_cm.tolist()
+            }
+        },
+        'error_analysis': {
+            'extraction_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_type, sample_ids in extraction_errors.items()
+            },
+            'prediction_errors': {
+                error_pattern: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_pattern, sample_ids in prediction_errors.items()
+            }
+        },
+        'distribution': {
+            'emotion': {
+                'ground_truth': dict(Counter(emotion_ground_truths)),
+                'predictions': dict(Counter(emotion_predictions))
+            },
+            'intent': {
+                'ground_truth': dict(Counter(intent_ground_truths)),
+                'predictions': dict(Counter(intent_predictions))
+            }
+        }
+    }
+
+
+    base_name = result_file_path.replace('.json', '')
+
+
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+
+    problem_samples = [item for item in detailed_results if not item['both_correct']]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, 'w', encoding='utf-8') as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+
+    print(f"Evaluation complete: {len(results)} samples")
+    print(f"Emotion metrics: ACC={evaluation_result['metrics']['emotion_metrics']['ACC']}, WAF={evaluation_result['metrics']['emotion_metrics']['WAF']}")
+    print(f"Intent metrics: ACC={evaluation_result['metrics']['intent_metrics']['ACC']}, WAF={evaluation_result['metrics']['intent_metrics']['WAF']}")
+    print(f"Joint accuracy: {evaluation_result['metrics']['joint_metrics']['Joint_ACC']}")
+    print(f"Extraction success rate: {evaluation_result['task_info']['extraction_success_rate']}")
+    print(f"Results saved to: {eval_output_file}")
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)}; see {problem_report_file} for details")
+
+    return evaluation_result
+
+
+if __name__ == "__main__":
+    result_file = "model_result.json"
+
+    try:
+        evaluation_result = evaluate_emotion_based_intent_analysis(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: file not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: invalid format for {result_file}")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")
+

code/evaluation_code/level2/evaluation_HU.py

@@ -0,0 +1,228 @@
+import json
+import re
+from sklearn.metrics import accuracy_score, f1_score, classification_report, confusion_matrix
+from collections import Counter, defaultdict
+from datetime import datetime
+import numpy as np
+
+def extract_humor_label_from_output(model_output):
+
+    if not model_output:
+        return None, False, "empty_output"
+
+
+    valid_labels = ['true', 'false']
+
+
+    cleaned_output = model_output.strip().lower()
+
+
+    patterns = [
+        r'^(true|false)$',
+        r'\b(true|false)\b',
+        r'answer[:\s]*(true|false)',
+        r'final[:\s]*(true|false)',
+        r'(true|false)\.?$',
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, cleaned_output)
+        if match:
+            label = match.group(1).lower()
+            if label in valid_labels:
+                return label, True, None
+
+
+    if 'yes' in cleaned_output or 'humor' in cleaned_output:
+        if 'no' not in cleaned_output and 'not' not in cleaned_output:
+            return 'true', False, "inferred_from_yes_or_humor"
+    elif 'no' in cleaned_output or 'not humor' in cleaned_output:
+        return 'false', False, "inferred_from_no_or_not_humor"
+
+
+    if any(word in cleaned_output for word in ['true', 'false']):
+        return None, False, "label_found_but_not_extracted"
+    else:
+        return None, False, "no_label_pattern"
+
+def evaluate_humor_understanding(result_file_path):
+
+
+
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    prediction_errors = defaultdict(list)
+
+
+    humor_labels = ['false', 'true']
+
+
+    for item in results:
+        item_id = item['id']
+        model_output = item['model_output']
+        gt_label = item['ground_truth'].lower().strip()
+
+
+        pred_label, is_valid, error_type = extract_humor_label_from_output(model_output)
+
+
+        detailed_item = {
+            'id': item_id,
+            'model_output': model_output,
+            'extracted_prediction': pred_label,
+            'ground_truth': gt_label,
+            'correct': pred_label == gt_label if pred_label else False,
+            'valid': is_valid
+        }
+        detailed_results.append(detailed_item)
+
+
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+        elif pred_label != gt_label:
+            error_pattern = f"{gt_label}_to_{pred_label}"
+            prediction_errors[error_pattern].append(item_id)
+
+
+        if pred_label:
+            predictions.append(pred_label)
+            ground_truths.append(gt_label)
+
+
+    if len(predictions) == 0:
+        return {
+            'error': 'No valid predictions found',
+            'total_samples': len(results),
+            'extraction_errors': dict(extraction_errors)
+        }
+
+
+    accuracy = accuracy_score(ground_truths, predictions)
+    weighted_f1 = f1_score(ground_truths, predictions, average='weighted')
+    macro_f1 = f1_score(ground_truths, predictions, average='macro')
+
+
+    cm = confusion_matrix(ground_truths, predictions, labels=humor_labels)
+
+
+    class_report = classification_report(ground_truths, predictions,
+                                       target_names=humor_labels,
+                                       output_dict=True,
+                                       zero_division=0)
+
+
+    true_positives = cm[1, 1]
+    false_positives = cm[0, 1]
+    false_negatives = cm[1, 0]
+    true_negatives = cm[0, 0]
+
+    humor_precision = true_positives / (true_positives + false_positives) if (true_positives + false_positives) > 0 else 0
+    humor_recall = true_positives / (true_positives + false_negatives) if (true_positives + false_negatives) > 0 else 0
+    humor_f1 = 2 * humor_precision * humor_recall / (humor_precision + humor_recall) if (humor_precision + humor_recall) > 0 else 0
+
+
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'humor.understanding',
+            'dataset': 'UR-FUNNY',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_predictions': len(predictions),
+            'extraction_success_rate': round(len(predictions) / len(results), 4)
+        },
+        'metrics': {
+            'ACC': round(accuracy, 4),
+            'WAF': round(weighted_f1, 4),
+            'Macro_F1': round(macro_f1, 4),
+            'Humor_Precision': round(humor_precision, 4),
+            'Humor_Recall': round(humor_recall, 4),
+            'Humor_F1': round(humor_f1, 4)
+        },
+        'per_class_metrics': {
+            label: {
+                'precision': round(class_report[label]['precision'], 4),
+                'recall': round(class_report[label]['recall'], 4),
+                'f1_score': round(class_report[label]['f1-score'], 4),
+                'support': int(class_report[label]['support'])
+            } for label in humor_labels if label in class_report
+        },
+        'confusion_matrix': {
+            'labels': humor_labels,
+            'matrix': cm.tolist(),
+            'detailed': {
+                'true_positives': int(true_positives),
+                'false_positives': int(false_positives),
+                'false_negatives': int(false_negatives),
+                'true_negatives': int(true_negatives)
+            }
+        },
+        'error_analysis': {
+            'extraction_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_type, sample_ids in extraction_errors.items()
+            },
+            'prediction_errors': {
+                error_pattern: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_pattern, sample_ids in prediction_errors.items()
+            }
+        },
+        'distribution': {
+            'ground_truth': dict(Counter(ground_truths)),
+            'predictions': dict(Counter(predictions))
+        }
+    }
+
+
+    base_name = result_file_path.replace('.json', '')
+
+
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+
+    problem_samples = [item for item in detailed_results if not item['correct']]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, 'w', encoding='utf-8') as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+
+    print(f"Evaluation complete: {len(results)} samples")
+    print(f"Key metrics: ACC={evaluation_result['metrics']['ACC']}, WAF={evaluation_result['metrics']['WAF']}")
+    print(f"Humor detection: Precision={evaluation_result['metrics']['Humor_Precision']}, Recall={evaluation_result['metrics']['Humor_Recall']}, F1={evaluation_result['metrics']['Humor_F1']}")
+    print(f"Extraction success rate: {evaluation_result['task_info']['extraction_success_rate']}")
+    print(f"Results saved to: {eval_output_file}")
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)}; see {problem_report_file} for details")
+
+    return evaluation_result
+
+
+if __name__ == "__main__":
+    result_file = "model_result.json"
+
+    try:
+        evaluation_result = evaluate_humor_understanding(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: file not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: invalid format for {result_file}")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")
+

code/evaluation_code/level2/evaluation_IAVE.py

@@ -0,0 +1,316 @@
+import json
+import re
+from sklearn.metrics import accuracy_score, f1_score, classification_report, confusion_matrix
+from collections import Counter, defaultdict
+from datetime import datetime
+import numpy as np
+
+
+ONTOLOGY = {
+    "Clothing": {
+        "Sleeve Style": ["3/4 Sleeve", "Long Sleeve", "Short Sleeve", "Sleeveless", "Strappy"],
+        "Neckline": ["Button Down", "Cowl Neck", "Crew Neck", "Halter", "Henley", "Polo", "Scoop Neck", "Square Neck", "Strapless", "Turtleneck", "V-Neck"],
+        "Length": ["Capri", "Long Dress/Gown", "Midi", "Mini/Short"],
+        "Shoulder Style": ["Cold Shoulder", "Off Shoulder", "One Shoulder"],
+    },
+    "Footwear": {
+        "Shaft Height": ["Ankle Boot", "Bootie", "Knee High", "Mid Calf", "Over The Knee"],
+        "Athletic Shoe Style": ["Basketball", "Climbing Shoe", "Cycling", "Golf", "Hiking Boot", "Running Shoe", "Skateboarding Shoe", "Soccer", "Tennis", "Training Shoe", "Volleyball", "Walking"],
+        "Boot Style": ["Chelsea", "Combat", "Western/Cowboy", "Motorcycle", "Rain Boots", "Snow Boots"],
+        "Heel Height": ["Flat", "High Heel", "Low Heel", "Mid Heel"],
+        "Toe Style": ["Pointed Toe", "Round Toe"],
+    }
+}
+
+def extract_attribute_type_from_prompt(prompt):
+
+
+    attribute_patterns = [
+        r"What is ([^?]+) of this product",
+        r"What ([^?]+) does this product have",
+        r"Identify the ([^?]+) of this product"
+    ]
+
+    for pattern in attribute_patterns:
+        match = re.search(pattern, prompt, re.IGNORECASE)
+        if match:
+            attribute_type = match.group(1).strip()
+
+
+            for category in ONTOLOGY.values():
+                if attribute_type in category:
+                    return attribute_type, category[attribute_type]
+
+
+            for category in ONTOLOGY.values():
+                for attr_name, values in category.items():
+                    if attr_name.lower() in attribute_type.lower() or attribute_type.lower() in attr_name.lower():
+                        return attr_name, values
+
+
+    choices_match = re.search(r"Answer with the option from the given choices directly:([^.]+)", prompt)
+    if choices_match:
+        choices_text = choices_match.group(1).strip()
+        choices = [choice.strip() for choice in choices_text.split(',')]
+
+
+        for category in ONTOLOGY.values():
+            for attr_name, values in category.items():
+                if set(choices) == set(values) or len(set(choices) & set(values)) > len(choices) * 0.8:
+                    return attr_name, values
+
+    return "Unknown", []
+
+def extract_value_from_output(model_output, valid_values):
+ 
+    if not model_output:
+        return None, False, "empty_output"
+
+
+    cleaned_output = model_output.strip()
+
+
+    for value in valid_values:
+        if cleaned_output == value:
+            return value, True, None
+
+
+    for value in valid_values:
+        if cleaned_output.lower() == value.lower():
+            return value, True, None
+
+
+    for value in valid_values:
+        if value in cleaned_output or cleaned_output in value:
+            return value, True, None
+
+
+    cleaned_normalized = re.sub(r'[^\w\s]', '', cleaned_output.lower())
+    for value in valid_values:
+        value_normalized = re.sub(r'[^\w\s]', '', value.lower())
+        if cleaned_normalized == value_normalized:
+            return value, True, None
+
+
+    for value in valid_values:
+        value_words = value.lower().split()
+        if all(word in cleaned_output.lower() for word in value_words):
+            return value, False, "keyword_match"
+
+
+    if any(word in cleaned_output.lower() for value in valid_values for word in value.lower().split()):
+        return None, False, "partial_match_failed"
+    else:
+        return None, False, "no_valid_value_found"
+
+def evaluate_implicit_attribute_value_extraction(result_file_path):
+
+
+
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+
+
+    attribute_results = defaultdict(lambda: {
+        'predictions': [],
+        'ground_truths': [],
+        'detailed_results': [],
+        'extraction_errors': defaultdict(list),
+        'prediction_errors': defaultdict(list)
+    })
+
+    overall_predictions = []
+    overall_ground_truths = []
+    overall_detailed_results = []
+    overall_extraction_errors = defaultdict(list)
+
+
+    for item in results:
+        item_id = item['id']
+        prompt = item['prompt']
+        model_output = item['model_output']
+        gt_value = item['ground_truth'].strip()
+
+
+        attribute_type, valid_values = extract_attribute_type_from_prompt(prompt)
+
+
+        pred_value, is_valid, error_type = extract_value_from_output(model_output, valid_values)
+
+
+        detailed_item = {
+            'id': item_id,
+            'attribute_type': attribute_type,
+            'valid_values': valid_values,
+            'model_output': model_output,
+            'extracted_prediction': pred_value,
+            'ground_truth': gt_value,
+            'correct': pred_value == gt_value if pred_value else False,
+            'valid': is_valid
+        }
+
+
+        attribute_results[attribute_type]['detailed_results'].append(detailed_item)
+        overall_detailed_results.append(detailed_item)
+
+
+        if not is_valid:
+            attribute_results[attribute_type]['extraction_errors'][error_type].append(item_id)
+            overall_extraction_errors[error_type].append(item_id)
+        elif pred_value != gt_value:
+            error_pattern = f"{gt_value}_to_{pred_value}"
+            attribute_results[attribute_type]['prediction_errors'][error_pattern].append(item_id)
+
+
+        if pred_value:
+            attribute_results[attribute_type]['predictions'].append(pred_value)
+            attribute_results[attribute_type]['ground_truths'].append(gt_value)
+            overall_predictions.append(pred_value)
+            overall_ground_truths.append(gt_value)
+
+
+    if len(overall_predictions) == 0:
+        return {
+            'error': 'No valid predictions found',
+            'total_samples': len(results),
+            'extraction_errors': dict(overall_extraction_errors)
+        }
+
+
+    overall_accuracy = accuracy_score(overall_ground_truths, overall_predictions)
+    overall_weighted_f1 = f1_score(overall_ground_truths, overall_predictions, average='weighted')
+    overall_macro_f1 = f1_score(overall_ground_truths, overall_predictions, average='macro')
+
+
+    attribute_metrics = {}
+    for attr_type, attr_data in attribute_results.items():
+        if len(attr_data['predictions']) > 0:
+            attr_accuracy = accuracy_score(attr_data['ground_truths'], attr_data['predictions'])
+            attr_weighted_f1 = f1_score(attr_data['ground_truths'], attr_data['predictions'], average='weighted')
+
+
+            all_values = list(set(attr_data['ground_truths'] + attr_data['predictions']))
+
+
+            attr_cm = confusion_matrix(attr_data['ground_truths'], attr_data['predictions'], labels=all_values)
+
+
+            attr_class_report = classification_report(attr_data['ground_truths'], attr_data['predictions'],
+                                                   target_names=all_values,
+                                                   output_dict=True, zero_division=0)
+
+            attribute_metrics[attr_type] = {
+                'ACC': round(attr_accuracy, 4),
+                'WAF': round(attr_weighted_f1, 4),
+                'total_samples': len(attr_data['detailed_results']),
+                'valid_predictions': len(attr_data['predictions']),
+                'per_class_metrics': {
+                    label: {
+                        'precision': round(attr_class_report[label]['precision'], 4),
+                        'recall': round(attr_class_report[label]['recall'], 4),
+                        'f1_score': round(attr_class_report[label]['f1-score'], 4),
+                        'support': int(attr_class_report[label]['support'])
+                    } for label in all_values if label in attr_class_report
+                },
+                'confusion_matrix': {
+                    'labels': all_values,
+                    'matrix': attr_cm.tolist()
+                },
+                'distribution': {
+                    'ground_truth': dict(Counter(attr_data['ground_truths'])),
+                    'predictions': dict(Counter(attr_data['predictions']))
+                }
+            }
+
+
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'implicit.attribute.value.extraction',
+            'dataset': 'ImplicitAVE',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_predictions': len(overall_predictions),
+            'extraction_success_rate': round(len(overall_predictions) / len(results), 4),
+            'attribute_types_count': len(attribute_results)
+        },
+        'overall_metrics': {
+            'ACC': round(overall_accuracy, 4),
+            'WAF': round(overall_weighted_f1, 4),
+            'Macro_F1': round(overall_macro_f1, 4)
+        },
+        'attribute_metrics': attribute_metrics,
+        'error_analysis': {
+            'overall_extraction_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_type, sample_ids in overall_extraction_errors.items()
+            }
+        },
+        'overall_distribution': {
+            'ground_truth': dict(Counter(overall_ground_truths)),
+            'predictions': dict(Counter(overall_predictions))
+        }
+    }
+
+
+    base_name = result_file_path.replace('.json', '')
+
+
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(overall_detailed_results, f, ensure_ascii=False, indent=2)
+
+
+    attribute_detailed_file = f"{base_name}_attribute_detailed_results.json"
+    with open(attribute_detailed_file, 'w', encoding='utf-8') as f:
+        formatted_attr_results = {}
+        for attr_type, attr_data in attribute_results.items():
+            formatted_attr_results[attr_type] = {
+                'detailed_results': attr_data['detailed_results'],
+                'extraction_errors': dict(attr_data['extraction_errors']),
+                'prediction_errors': dict(attr_data['prediction_errors'])
+            }
+        json.dump(formatted_attr_results, f, ensure_ascii=False, indent=2)
+
+
+    problem_samples = [item for item in overall_detailed_results if not item['correct']]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, 'w', encoding='utf-8') as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+
+    print(f"Evaluation complete: {len(results)} samples")
+    print(f"Overall metrics: ACC={evaluation_result['overall_metrics']['ACC']}, WAF={evaluation_result['overall_metrics']['WAF']}")
+    print(f"Number of attribute types: {evaluation_result['task_info']['attribute_types_count']}")
+    print(f"Extraction success rate: {evaluation_result['task_info']['extraction_success_rate']}")
+    print(f"Results saved to: {eval_output_file}")
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)}; see {problem_report_file} for details")
+
+
+    print("\nPerformance by attribute type:")
+    for attr_type, metrics in attribute_metrics.items():
+        print(f"  {attr_type}: ACC={metrics['ACC']}, WAF={metrics['WAF']}, Samples={metrics['total_samples']}")
+
+    return evaluation_result
+
+
+if __name__ == "__main__":
+    result_file = "model_result.json"
+
+    try:
+        evaluation_result = evaluate_implicit_attribute_value_extraction(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: file not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: invalid format for {result_file}")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")

code/evaluation_code/level2/evaluation_MABSA.py

@@ -0,0 +1,341 @@
+import json
+import re
+import ast
+from sklearn.metrics import f1_score, precision_score, recall_score, classification_report
+from collections import Counter, defaultdict
+from datetime import datetime
+import numpy as np
+
+def extract_targets_from_prompt(prompt):
+
+
+    targets_match = re.search(r"Targets:\s*([^\n]+)", prompt)
+    if targets_match:
+        targets_text = targets_match.group(1).strip()
+
+        targets = [target.strip() for target in re.split(r'[,;]', targets_text)]
+        return targets
+    return []
+
+def extract_sentiment_dict_from_output(model_output):
+
+    if not model_output:
+        return {}, False, "empty_output"
+
+
+    valid_sentiments = ['positive', 'neutral', 'negative']
+
+    try:
+
+        if "{" in model_output and "}" in model_output:
+
+            cleaned_output = model_output.strip()
+
+
+            json_match = re.search(r'\{[^}]*\}', cleaned_output)
+            if json_match:
+                cleaned_output = json_match.group()
+
+
+            try:
+                parsed = ast.literal_eval(cleaned_output)
+            except:
+
+                parsed = json.loads(cleaned_output)
+
+            if isinstance(parsed, dict):
+
+                sentiment_dict = {}
+                all_valid = True
+
+                for target, sentiment in parsed.items():
+                    if isinstance(sentiment, str) and sentiment.lower() in valid_sentiments:
+                        sentiment_dict[target] = sentiment.lower()
+                    else:
+                        all_valid = False
+
+                if all_valid and len(sentiment_dict) > 0:
+                    return sentiment_dict, True, None
+                else:
+                    return sentiment_dict, False, "invalid_sentiment_labels"
+
+
+
+        pairs = re.findall(r"([^:{},'\"]+):\s*['\"]?(positive|neutral|negative)['\"]?", model_output.lower())
+        if pairs:
+            sentiment_dict = {}
+            for target, sentiment in pairs:
+                target = target.strip(' \'"')
+                sentiment_dict[target] = sentiment
+            return sentiment_dict, False, "extracted_from_text_patterns"
+
+        return {}, False, "no_sentiment_pattern"
+
+    except Exception as e:
+        return {}, False, f"parsing_error_{str(e)}"
+
+def parse_ground_truth_dict(ground_truth):
+
+    if isinstance(ground_truth, dict):
+        return {k: v.lower() for k, v in ground_truth.items()}
+    elif isinstance(ground_truth, str):
+        try:
+            parsed = ast.literal_eval(ground_truth)
+            if isinstance(parsed, dict):
+                return {k: v.lower() for k, v in parsed.items()}
+        except:
+            pass
+    return {}
+
+def calculate_multimodal_absa_metrics(predictions, ground_truths):
+
+
+    all_pred_sentiments = []
+    all_true_sentiments = []
+
+    for pred_pairs, true_pairs in zip(predictions, ground_truths):
+        pred_dict = dict(pred_pairs)
+        true_dict = dict(true_pairs)
+
+
+        common_targets = set(pred_dict.keys()) & set(true_dict.keys())
+
+        for target in common_targets:
+            all_pred_sentiments.append(pred_dict[target])
+            all_true_sentiments.append(true_dict[target])
+
+    if len(all_pred_sentiments) == 0:
+        return {
+            'micro_f1': 0.0,
+            'macro_f1': 0.0,
+            'micro_precision': 0.0,
+            'micro_recall': 0.0,
+            'per_class_metrics': {},
+            'valid_pairs': 0
+        }
+
+
+    labels = ['positive', 'neutral', 'negative']
+    micro_f1 = f1_score(all_true_sentiments, all_pred_sentiments, average='micro')
+    macro_f1 = f1_score(all_true_sentiments, all_pred_sentiments, average='macro')
+    micro_precision = precision_score(all_true_sentiments, all_pred_sentiments, average='micro')
+    micro_recall = recall_score(all_true_sentiments, all_pred_sentiments, average='micro')
+
+
+    class_report = classification_report(all_true_sentiments, all_pred_sentiments,
+                                       target_names=labels,
+                                       output_dict=True, zero_division=0)
+
+    per_class_metrics = {}
+    for label in labels:
+        if label in class_report:
+            per_class_metrics[label] = {
+                'precision': class_report[label]['precision'],
+                'recall': class_report[label]['recall'],
+                'f1_score': class_report[label]['f1-score'],
+                'support': int(class_report[label]['support'])
+            }
+
+    return {
+        'micro_f1': micro_f1,
+        'macro_f1': macro_f1,
+        'micro_precision': micro_precision,
+        'micro_recall': micro_recall,
+        'per_class_metrics': per_class_metrics,
+        'valid_pairs': len(all_pred_sentiments)
+    }
+
+def evaluate_multimodal_aspect_based_sentiment_analysis(result_file_path):
+
+
+
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    target_level_errors = defaultdict(list)
+
+
+    for item in results:
+        item_id = item['id']
+        prompt = item['prompt']
+        model_output = item['model_output']
+        gt_dict = parse_ground_truth_dict(item['ground_truth'])
+
+
+        targets = extract_targets_from_prompt(prompt)
+
+
+        pred_dict, is_valid, error_type = extract_sentiment_dict_from_output(model_output)
+
+
+        pred_pairs = []
+        true_pairs = []
+        target_results = {}
+
+        for target in targets:
+            if target in gt_dict:
+                true_sentiment = gt_dict[target]
+                true_pairs.append((target, true_sentiment))
+
+                if target in pred_dict:
+                    pred_sentiment = pred_dict[target]
+                    pred_pairs.append((target, pred_sentiment))
+                    target_results[target] = {
+                        'predicted': pred_sentiment,
+                        'ground_truth': true_sentiment,
+                        'correct': pred_sentiment == true_sentiment
+                    }
+
+
+                    if pred_sentiment != true_sentiment:
+                        error_pattern = f"{true_sentiment}_to_{pred_sentiment}"
+                        target_level_errors[error_pattern].append(f"{item_id}_{target}")
+                else:
+                    target_results[target] = {
+                        'predicted': None,
+                        'ground_truth': true_sentiment,
+                        'correct': False
+                    }
+
+
+        detailed_item = {
+            'id': item_id,
+            'targets': targets,
+            'model_output': model_output,
+            'extracted_prediction': pred_dict,
+            'ground_truth': gt_dict,
+            'target_results': target_results,
+            'all_targets_correct': all(result['correct'] for result in target_results.values()),
+            'valid': is_valid
+        }
+        detailed_results.append(detailed_item)
+
+
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+
+
+        if len(pred_pairs) > 0:
+            predictions.append(pred_pairs)
+            ground_truths.append(true_pairs)
+
+
+    if len(predictions) == 0:
+        return {
+            'error': 'No valid predictions found',
+            'total_samples': len(results),
+            'extraction_errors': dict(extraction_errors)
+        }
+
+
+    metrics = calculate_multimodal_absa_metrics(predictions, ground_truths)
+
+
+    all_correct_samples = sum(1 for item in detailed_results if item['all_targets_correct'])
+    sample_level_accuracy = all_correct_samples / len(detailed_results)
+
+
+    all_true_sentiments = []
+    all_pred_sentiments = []
+    for item in detailed_results:
+        for target, result in item['target_results'].items():
+            if result['ground_truth']:
+                all_true_sentiments.append(result['ground_truth'])
+            if result['predicted']:
+                all_pred_sentiments.append(result['predicted'])
+
+
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'multimodal.aspect.based.sentiment.analysis',
+            'dataset': 'Twitter2015/2017',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_samples': len(predictions),
+            'extraction_success_rate': round(len(predictions) / len(results), 4),
+            'total_target_pairs': metrics['valid_pairs']
+        },
+        'metrics': {
+            'Micro_F1': round(metrics['micro_f1'], 4),
+            'Macro_F1': round(metrics['macro_f1'], 4),
+            'Micro_Precision': round(metrics['micro_precision'], 4),
+            'Micro_Recall': round(metrics['micro_recall'], 4),
+            'Sample_Level_Accuracy': round(sample_level_accuracy, 4)
+        },
+        'per_class_metrics': {
+            label: {
+                'precision': round(metrics['per_class_metrics'][label]['precision'], 4),
+                'recall': round(metrics['per_class_metrics'][label]['recall'], 4),
+                'f1_score': round(metrics['per_class_metrics'][label]['f1_score'], 4),
+                'support': metrics['per_class_metrics'][label]['support']
+            } for label in metrics['per_class_metrics']
+        },
+        'error_analysis': {
+            'extraction_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_type, sample_ids in extraction_errors.items()
+            },
+            'target_level_errors': {
+                error_pattern: {
+                    'count': len(target_ids),
+                    'target_ids': target_ids
+                } for error_pattern, target_ids in target_level_errors.items()
+            }
+        },
+        'distribution': {
+            'ground_truth_sentiments': dict(Counter(all_true_sentiments)),
+            'predicted_sentiments': dict(Counter(all_pred_sentiments))
+        }
+    }
+
+
+    base_name = result_file_path.replace('.json', '')
+
+
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+
+    problem_samples = [item for item in detailed_results if not item['all_targets_correct']]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, 'w', encoding='utf-8') as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+
+    print(f"Evaluation complete: {len(results)} samples")
+    print(f"Key metrics: Micro F1={evaluation_result['metrics']['Micro_F1']}, Sample-level Accuracy={evaluation_result['metrics']['Sample_Level_Accuracy']}")
+    print(f"Number of target pairs: {evaluation_result['task_info']['total_target_pairs']}")
+    print(f"Extraction success rate: {evaluation_result['task_info']['extraction_success_rate']}")
+    print(f"Results saved to: {eval_output_file}")
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)}; see {problem_report_file} for details")
+
+    return evaluation_result
+
+
+if __name__ == "__main__":
+    result_file = "model_result.json"
+
+    try:
+        evaluation_result = evaluate_multimodal_aspect_based_sentiment_analysis(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: file not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: invalid format for {result_file}")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")
+

code/evaluation_code/level2/evaluation_MDER.py

@@ -0,0 +1,257 @@
+import json
+import re
+import ast
+from sklearn.metrics import accuracy_score, f1_score, classification_report, confusion_matrix
+from collections import Counter, defaultdict
+from datetime import datetime
+import numpy as np
+
+def extract_emotion_from_output(model_output):
+
+    if not model_output:
+        return None, False, "empty_output"
+
+
+    valid_emotions = ['neutral', 'surprise', 'fear', 'sadness', 'joy', 'disgust', 'anger']
+
+    try:
+
+        if "{'emotion':" in model_output or '{"emotion":' in model_output:
+
+            cleaned_output = model_output.strip()
+
+
+            json_match = re.search(r'\{[^}]*\}', cleaned_output)
+            if json_match:
+                cleaned_output = json_match.group()
+
+
+            try:
+                parsed = ast.literal_eval(cleaned_output)
+            except:
+
+                parsed = json.loads(cleaned_output)
+
+            if 'emotion' in parsed and isinstance(parsed['emotion'], str):
+                emotion = parsed['emotion'].lower().strip()
+                if emotion in valid_emotions:
+                    return emotion, True, None
+                else:
+                    return emotion, False, "invalid_emotion_label"
+
+
+        cleaned_output = model_output.lower().strip()
+
+
+        for emotion in valid_emotions:
+            if cleaned_output == emotion:
+                return emotion, True, None
+
+
+        for emotion in valid_emotions:
+            if emotion in cleaned_output:
+                return emotion, False, "emotion_found_but_not_properly_formatted"
+
+        return None, False, "no_valid_emotion_found"
+
+    except Exception as e:
+        return None, False, f"parsing_error_{str(e)}"
+
+def evaluate_multiparty_dialogue_emotion_recognition(result_file_path):
+
+
+
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    prediction_errors = defaultdict(list)
+
+
+    emotion_labels = ['neutral', 'surprise', 'fear', 'sadness', 'joy', 'disgust', 'anger']
+
+
+    for item in results:
+        item_id = item['id']
+        model_output = item['model_output']
+        gt_emotion = item['ground_truth'].lower().strip()
+
+
+        pred_emotion, is_valid, error_type = extract_emotion_from_output(model_output)
+
+
+        detailed_item = {
+            'id': item_id,
+            'model_output': model_output,
+            'extracted_prediction': pred_emotion,
+            'ground_truth': gt_emotion,
+            'correct': pred_emotion == gt_emotion if pred_emotion else False,
+            'valid': is_valid
+        }
+        detailed_results.append(detailed_item)
+
+
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+        elif pred_emotion != gt_emotion:
+            error_pattern = f"{gt_emotion}_to_{pred_emotion}"
+            prediction_errors[error_pattern].append(item_id)
+
+
+        if is_valid:
+            predictions.append(pred_emotion)
+            ground_truths.append(gt_emotion)
+
+
+    if len(predictions) == 0:
+        return {
+            'error': 'No valid predictions found',
+            'total_samples': len(results),
+            'extraction_errors': dict(extraction_errors)
+        }
+
+
+    accuracy = accuracy_score(ground_truths, predictions)
+    weighted_f1 = f1_score(ground_truths, predictions, average='weighted')
+    macro_f1 = f1_score(ground_truths, predictions, average='macro')
+    micro_f1 = f1_score(ground_truths, predictions, average='micro')
+
+
+    cm = confusion_matrix(ground_truths, predictions, labels=emotion_labels)
+
+
+    class_report = classification_report(ground_truths, predictions,
+                                       target_names=emotion_labels,
+                                       output_dict=True,
+                                       zero_division=0)
+
+
+    per_class_metrics = {}
+    for i, label in enumerate(emotion_labels):
+        if label in class_report:
+            true_positives = cm[i, i]
+            false_positives = np.sum(cm[:, i]) - true_positives
+            false_negatives = np.sum(cm[i, :]) - true_positives
+
+            per_class_metrics[label] = {
+                'precision': round(class_report[label]['precision'], 4),
+                'recall': round(class_report[label]['recall'], 4),
+                'f1_score': round(class_report[label]['f1-score'], 4),
+                'support': int(class_report[label]['support']),
+                'true_positives': int(true_positives),
+                'false_positives': int(false_positives),
+                'false_negatives': int(false_negatives)
+            }
+
+
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'multiparty.dialogue.emotion.recognition',
+            'dataset': 'MELD',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_predictions': len(predictions),
+            'extraction_success_rate': round(len(predictions) / len(results), 4)
+        },
+        'metrics': {
+            'ACC': round(accuracy, 4),
+            'WAF': round(weighted_f1, 4),
+            'Macro_F1': round(macro_f1, 4),
+            'Micro_F1': round(micro_f1, 4)
+        },
+        'per_class_metrics': per_class_metrics,
+        'confusion_matrix': {
+            'labels': emotion_labels,
+            'matrix': cm.tolist(),
+            'normalized': (cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]).round(4).tolist()
+        },
+        'error_analysis': {
+            'extraction_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_type, sample_ids in extraction_errors.items()
+            },
+            'prediction_errors': {
+                error_pattern: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_pattern, sample_ids in prediction_errors.items()
+            }
+        },
+        'distribution': {
+            'ground_truth': dict(Counter(ground_truths)),
+            'predictions': dict(Counter(predictions))
+        }
+    }
+
+
+    confusion_pairs = []
+    for i, label1 in enumerate(emotion_labels):
+        for j, label2 in enumerate(emotion_labels):
+            if i != j and cm[i, j] > 0:
+                confusion_pairs.append({
+                    'true_emotion': label1,
+                    'predicted_emotion': label2,
+                    'count': int(cm[i, j]),
+                    'percentage': round(cm[i, j] / np.sum(cm[i, :]) * 100, 2)
+                })
+
+    confusion_pairs.sort(key=lambda x: x['count'], reverse=True)
+    evaluation_result['emotion_confusion_analysis'] = {
+        'most_confused_pairs': confusion_pairs[:10]
+    }
+
+
+    base_name = result_file_path.replace('.json', '')
+
+
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+
+    problem_samples = [item for item in detailed_results if not item['correct']]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, 'w', encoding='utf-8') as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+
+    print(f"Evaluation complete: {len(results)} samples")
+    print(f"Key metrics: ACC={evaluation_result['metrics']['ACC']}, WAF={evaluation_result['metrics']['WAF']}")
+    print(f"Extraction success rate: {evaluation_result['task_info']['extraction_success_rate']}")
+    print(f"Results saved to: {eval_output_file}")
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)}; see {problem_report_file} for details")
+
+
+    if confusion_pairs:
+        print("\nMost confusable emotion pairs:")
+        for pair in confusion_pairs[:5]:
+            print(f"  {pair['true_emotion']} → {pair['predicted_emotion']}: {pair['count']} times ({pair['percentage']}%)")
+
+    return evaluation_result
+
+
+if __name__ == "__main__":
+    result_file = "model_result.json"
+
+    try:
+        evaluation_result = evaluate_multiparty_dialogue_emotion_recognition(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: file not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: invalid format for {result_file}")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")
+

code/evaluation_code/level2/evaluation_MQE.py

@@ -0,0 +1,369 @@
+import json
+import re
+import ast
+from sklearn.metrics import f1_score, precision_score, recall_score
+from collections import Counter, defaultdict
+from datetime import datetime
+import numpy as np
+
+def parse_quintuple_list(output_text):
+
+    if not output_text:
+        return [], False, "empty_output"
+
+    try:
+
+        cleaned_output = output_text.strip()
+
+
+        list_match = re.search(r'\[(.*)\]', cleaned_output, re.DOTALL)
+        if not list_match:
+            return [], False, "no_list_structure"
+
+        list_content = list_match.group(1).strip()
+        if not list_content:
+            return [], True, None
+
+
+        try:
+            full_list = ast.literal_eval('[' + list_content + ']')
+        except:
+
+
+            fixed_content = list_content
+
+            fixed_content = re.sub(r'"([^"]*)"', r"'\1'", fixed_content)
+
+            try:
+                full_list = ast.literal_eval('[' + fixed_content + ']')
+            except:
+
+                return parse_tuples_manually(list_content)
+
+
+        quintuples = []
+        for item in full_list:
+            if isinstance(item, (tuple, list)) and len(item) >= 5:
+
+                quintuple = tuple(str(element).strip() for element in item[:5])
+                quintuples.append(quintuple)
+            else:
+                return [], False, "invalid_tuple_structure"
+
+        return quintuples, True, None
+
+    except Exception as e:
+        return [], False, f"parsing_error_{str(e)}"
+
+def parse_tuples_manually(list_content):
+
+    try:
+
+        tuple_pattern = r'\(\s*([^)]+)\s*\)'
+        matches = re.findall(tuple_pattern, list_content)
+
+        quintuples = []
+        for match in matches:
+
+            elements = []
+            current_element = ""
+            in_quotes = False
+            quote_char = None
+
+            i = 0
+            while i < len(match):
+                char = match[i]
+
+                if char in ['"', "'"] and (i == 0 or match[i-1] != '\\'):
+                    if not in_quotes:
+                        in_quotes = True
+                        quote_char = char
+                    elif char == quote_char:
+                        in_quotes = False
+                        quote_char = None
+                elif char == ',' and not in_quotes:
+                    elements.append(current_element.strip().strip('"\''))
+                    current_element = ""
+                    i += 1
+                    continue
+
+                current_element += char
+                i += 1
+
+
+            if current_element:
+                elements.append(current_element.strip().strip('"\''))
+
+
+            if len(elements) >= 5:
+                quintuple = tuple(elements[:5])
+                quintuples.append(quintuple)
+
+        return quintuples, len(quintuples) > 0, "manual_parsing" if len(quintuples) > 0 else "manual_parsing_failed"
+
+    except Exception as e:
+        return [], False, f"manual_parsing_error_{str(e)}"
+
+def normalize_quintuple(quintuple):
+
+    holder, target, aspect, opinion, sentiment = quintuple
+
+
+    sentiment_lower = sentiment.lower().strip()
+    if sentiment_lower in ['positive', 'pos']:
+        sentiment = 'positive'
+    elif sentiment_lower in ['negative', 'neg']:
+        sentiment = 'negative'
+    elif sentiment_lower in ['neutral', 'neu']:
+        sentiment = 'neutral'
+    else:
+        sentiment = sentiment_lower
+
+
+    holder = holder.strip()
+    target = target.strip()
+    aspect = aspect.strip()
+    opinion = opinion.strip()
+
+    return (holder, target, aspect, opinion, sentiment)
+
+def calculate_quintuple_metrics(predictions, ground_truths):
+
+    total_pred = 0
+    total_true = 0
+    total_correct = 0
+
+    exact_matches = 0
+    partial_matches = {'holder': 0, 'target': 0, 'aspect': 0, 'opinion': 0, 'sentiment': 0}
+
+    for pred_list, true_list in zip(predictions, ground_truths):
+
+        pred_normalized = [normalize_quintuple(q) for q in pred_list]
+        true_normalized = [normalize_quintuple(q) for q in true_list]
+
+        total_pred += len(pred_normalized)
+        total_true += len(true_normalized)
+
+
+        pred_set = set(pred_normalized)
+        true_set = set(true_normalized)
+        exact_matches += len(pred_set & true_set)
+        total_correct += len(pred_set & true_set)
+
+
+        for pred_q in pred_normalized:
+            for true_q in true_normalized:
+                if pred_q == true_q:
+                    continue
+                for i, (field_name, pred_field, true_field) in enumerate(
+                    zip(['holder', 'target', 'aspect', 'opinion', 'sentiment'], pred_q, true_q)):
+                    if pred_field.lower() == true_field.lower():
+                        partial_matches[field_name] += 1
+
+
+    precision = total_correct / total_pred if total_pred > 0 else 0
+    recall = total_correct / total_true if total_true > 0 else 0
+    f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
+
+    return {
+        'micro_f1': f1,
+        'micro_precision': precision,
+        'micro_recall': recall,
+        'exact_matches': exact_matches,
+        'total_predicted': total_pred,
+        'total_ground_truth': total_true,
+        'partial_matches': partial_matches
+    }
+
+def evaluate_multimodal_quintuple_extraction(result_file_path):
+
+
+
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+
+
+    for item in results:
+        item_id = item['id']
+        model_output = item['model_output']
+
+
+        if isinstance(item['ground_truth'], str):
+            gt_quintuples, gt_valid, gt_error = parse_quintuple_list(item['ground_truth'])
+        elif isinstance(item['ground_truth'], list):
+            gt_quintuples = []
+            for gt_item in item['ground_truth']:
+                if isinstance(gt_item, (tuple, list)) and len(gt_item) >= 5:
+                    gt_quintuples.append(tuple(str(element).strip() for element in gt_item[:5]))
+            gt_valid = True
+            gt_error = None
+        else:
+            gt_quintuples = []
+            gt_valid = False
+            gt_error = "invalid_ground_truth_format"
+
+
+        pred_quintuples, pred_valid, pred_error = parse_quintuple_list(model_output)
+
+
+        detailed_item = {
+            'id': item_id,
+            'model_output': model_output,
+            'extracted_prediction': pred_quintuples,
+            'ground_truth': gt_quintuples,
+            'prediction_count': len(pred_quintuples),
+            'ground_truth_count': len(gt_quintuples),
+            'exact_matches': len(set(pred_quintuples) & set(gt_quintuples)) if pred_valid and gt_valid else 0,
+            'valid': pred_valid and gt_valid
+        }
+        detailed_results.append(detailed_item)
+
+
+        if not pred_valid:
+            extraction_errors[pred_error].append(item_id)
+        elif not gt_valid:
+            extraction_errors[f"gt_{gt_error}"].append(item_id)
+
+
+        if pred_valid and gt_valid:
+            predictions.append(pred_quintuples)
+            ground_truths.append(gt_quintuples)
+
+
+    if len(predictions) == 0:
+        return {
+            'error': 'No valid predictions found',
+            'total_samples': len(results),
+            'extraction_errors': dict(extraction_errors)
+        }
+
+
+    metrics = calculate_quintuple_metrics(predictions, ground_truths)
+
+
+    sample_with_predictions = sum(1 for item in detailed_results if item['prediction_count'] > 0)
+    sample_with_correct_predictions = sum(1 for item in detailed_results if item['exact_matches'] > 0)
+
+
+    all_pred_holders = []
+    all_pred_targets = []
+    all_pred_sentiments = []
+    all_true_holders = []
+    all_true_targets = []
+    all_true_sentiments = []
+
+    for pred_list, true_list in zip(predictions, ground_truths):
+        for quintuple in pred_list:
+            all_pred_holders.append(quintuple[0])
+            all_pred_targets.append(quintuple[1])
+            all_pred_sentiments.append(quintuple[4])
+
+        for quintuple in true_list:
+            all_true_holders.append(quintuple[0])
+            all_true_targets.append(quintuple[1])
+            all_true_sentiments.append(quintuple[4])
+
+
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'multimodal.quintuple.extraction',
+            'dataset': 'PanoSent',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_samples': len(predictions),
+            'extraction_success_rate': round(len(predictions) / len(results), 4)
+        },
+        'metrics': {
+            'Micro_F1': round(metrics['micro_f1'], 4),
+            'Micro_Precision': round(metrics['micro_precision'], 4),
+            'Micro_Recall': round(metrics['micro_recall'], 4),
+            'Exact_Matches': metrics['exact_matches'],
+            'Total_Predicted': metrics['total_predicted'],
+            'Total_Ground_Truth': metrics['total_ground_truth']
+        },
+        'sample_level_stats': {
+            'samples_with_predictions': sample_with_predictions,
+            'samples_with_correct_predictions': sample_with_correct_predictions,
+            'avg_predictions_per_sample': round(metrics['total_predicted'] / len(predictions), 2) if len(predictions) > 0 else 0,
+            'avg_ground_truth_per_sample': round(metrics['total_ground_truth'] / len(predictions), 2) if len(predictions) > 0 else 0
+        },
+        'partial_match_analysis': {
+            field: {
+                'matches': metrics['partial_matches'][field],
+                'rate': round(metrics['partial_matches'][field] / max(metrics['total_predicted'], 1), 4)
+            } for field in ['holder', 'target', 'aspect', 'opinion', 'sentiment']
+        },
+        'error_analysis': {
+            'extraction_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_type, sample_ids in extraction_errors.items()
+            }
+        },
+        'distribution': {
+            'holders': {
+                'ground_truth': dict(Counter(all_true_holders)),
+                'predictions': dict(Counter(all_pred_holders))
+            },
+            'targets': {
+                'ground_truth': dict(Counter(all_true_targets)),
+                'predictions': dict(Counter(all_pred_targets))
+            },
+            'sentiments': {
+                'ground_truth': dict(Counter(all_true_sentiments)),
+                'predictions': dict(Counter(all_pred_sentiments))
+            }
+        }
+    }
+
+
+    base_name = result_file_path.replace('.json', '')
+
+
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+
+    problem_samples = [item for item in detailed_results if item['exact_matches'] == 0 and item['ground_truth_count'] > 0]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, 'w', encoding='utf-8') as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+
+    print(f"Evaluation complete: {len(results)} samples")
+    print(f"Key metric: Micro F1={evaluation_result['metrics']['Micro_F1']}")
+    print(f"Exact matches: {evaluation_result['metrics']['Exact_Matches']}/{evaluation_result['metrics']['Total_Ground_Truth']}")
+    print(f"Average predictions per sample: {evaluation_result['sample_level_stats']['avg_predictions_per_sample']}")
+    print(f"Extraction success rate: {evaluation_result['task_info']['extraction_success_rate']}")
+    print(f"Results saved to: {eval_output_file}")
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)}; see {problem_report_file} for details")
+
+    return evaluation_result
+
+
+if __name__ == "__main__":
+    result_file = "model_result.json"
+
+    try:
+        evaluation_result = evaluate_multimodal_quintuple_extraction(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: file not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: invalid format for {result_file}")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")

code/evaluation_code/level2/evaluation_MSD.py

@@ -0,0 +1,301 @@
+import json
+import re
+import ast
+from sklearn.metrics import accuracy_score, f1_score, classification_report, confusion_matrix
+from collections import Counter, defaultdict
+from datetime import datetime
+import numpy as np
+
+def extract_stance_from_output(model_output):
+
+    if not model_output:
+        return None, False, "empty_output"
+
+
+    valid_stances = ['support', 'refute', 'comment', 'unrelated']
+
+    try:
+
+        if "{'stance':" in model_output or '{"stance":' in model_output:
+
+            cleaned_output = model_output.strip()
+
+
+            json_match = re.search(r'\{[^}]*\}', cleaned_output)
+            if json_match:
+                cleaned_output = json_match.group()
+
+
+            try:
+                parsed = ast.literal_eval(cleaned_output)
+            except:
+
+                parsed = json.loads(cleaned_output)
+
+            if 'stance' in parsed and isinstance(parsed['stance'], str):
+                stance = parsed['stance'].lower().strip()
+                if stance in valid_stances:
+                    return stance, True, None
+                else:
+                    return stance, False, "invalid_stance_label"
+
+
+        cleaned_output = model_output.lower().strip()
+
+
+        for stance in valid_stances:
+            if cleaned_output == stance:
+                return stance, True, None
+
+
+        for stance in valid_stances:
+            if stance in cleaned_output:
+                return stance, False, "stance_found_in_text"
+
+
+        if 'oppose' in cleaned_output or 'against' in cleaned_output or 'deny' in cleaned_output:
+            return 'refute', False, "inferred_from_synonyms"
+        elif 'agree' in cleaned_output or 'favor' in cleaned_output or 'endorse' in cleaned_output:
+            return 'support', False, "inferred_from_synonyms"
+        elif 'neutral' in cleaned_output or 'discuss' in cleaned_output or 'mention' in cleaned_output:
+            return 'comment', False, "inferred_from_synonyms"
+        elif 'irrelevant' in cleaned_output or 'unconnected' in cleaned_output or 'off-topic' in cleaned_output:
+            return 'unrelated', False, "inferred_from_synonyms"
+
+        return None, False, "no_stance_pattern"
+
+    except Exception as e:
+        return None, False, f"parsing_error_{str(e)}"
+
+def parse_ground_truth_stance(ground_truth):
+
+    if isinstance(ground_truth, dict):
+        return ground_truth.get('stance', '').lower().strip()
+    elif isinstance(ground_truth, str):
+
+        try:
+            parsed = ast.literal_eval(ground_truth)
+            if isinstance(parsed, dict) and 'stance' in parsed:
+                return parsed['stance'].lower().strip()
+        except:
+            pass
+
+        return ground_truth.lower().strip()
+    else:
+        return ''
+
+def evaluate_multimodal_stance_detection(result_file_path):
+
+
+
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    prediction_errors = defaultdict(list)
+
+
+    stance_labels = ['support', 'refute', 'comment', 'unrelated']
+
+
+    for item in results:
+        item_id = item['id']
+        model_output = item['model_output']
+        gt_stance = parse_ground_truth_stance(item['ground_truth'])
+
+
+        pred_stance, is_valid, error_type = extract_stance_from_output(model_output)
+
+
+        detailed_item = {
+            'id': item_id,
+            'model_output': model_output,
+            'extracted_prediction': pred_stance,
+            'ground_truth': gt_stance,
+            'correct': pred_stance == gt_stance if pred_stance else False,
+            'valid': is_valid
+        }
+        detailed_results.append(detailed_item)
+
+
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+        elif pred_stance != gt_stance:
+            error_pattern = f"{gt_stance}_to_{pred_stance}"
+            prediction_errors[error_pattern].append(item_id)
+
+
+        if pred_stance:
+            predictions.append(pred_stance)
+            ground_truths.append(gt_stance)
+
+
+    if len(predictions) == 0:
+        return {
+            'error': 'No valid predictions found',
+            'total_samples': len(results),
+            'extraction_errors': dict(extraction_errors)
+        }
+
+
+    accuracy = accuracy_score(ground_truths, predictions)
+    micro_f1 = f1_score(ground_truths, predictions, average='micro')
+    macro_f1 = f1_score(ground_truths, predictions, average='macro')
+    weighted_f1 = f1_score(ground_truths, predictions, average='weighted')
+
+
+    cm = confusion_matrix(ground_truths, predictions, labels=stance_labels)
+
+
+    class_report = classification_report(ground_truths, predictions,
+                                       target_names=stance_labels,
+                                       output_dict=True,
+                                       zero_division=0)
+
+
+    per_class_metrics = {}
+    for i, label in enumerate(stance_labels):
+        if label in class_report:
+            true_positives = cm[i, i]
+            false_positives = np.sum(cm[:, i]) - true_positives
+            false_negatives = np.sum(cm[i, :]) - true_positives
+
+            per_class_metrics[label] = {
+                'precision': round(class_report[label]['precision'], 4),
+                'recall': round(class_report[label]['recall'], 4),
+                'f1_score': round(class_report[label]['f1-score'], 4),
+                'support': int(class_report[label]['support']),
+                'true_positives': int(true_positives),
+                'false_positives': int(false_positives),
+                'false_negatives': int(false_negatives)
+            }
+
+
+
+    support_refute_predictions = []
+    support_refute_ground_truths = []
+    for pred, true in zip(predictions, ground_truths):
+        if true in ['support', 'refute']:
+            support_refute_predictions.append(pred if pred in ['support', 'refute'] else 'other')
+            support_refute_ground_truths.append(true)
+
+    support_refute_accuracy = 0
+    if len(support_refute_ground_truths) > 0:
+        support_refute_accuracy = accuracy_score(support_refute_ground_truths, support_refute_predictions)
+
+
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'multimodal.stance.detection',
+            'dataset': 'MMWTWT',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_predictions': len(predictions),
+            'extraction_success_rate': round(len(predictions) / len(results), 4)
+        },
+        'metrics': {
+            'ACC': round(accuracy, 4),
+            'Micro_F1': round(micro_f1, 4),
+            'Macro_F1': round(macro_f1, 4),
+            'Weighted_F1': round(weighted_f1, 4),
+            'Support_Refute_ACC': round(support_refute_accuracy, 4)
+        },
+        'per_class_metrics': per_class_metrics,
+        'confusion_matrix': {
+            'labels': stance_labels,
+            'matrix': cm.tolist(),
+            'normalized': (cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]).round(4).tolist()
+        },
+        'error_analysis': {
+            'extraction_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_type, sample_ids in extraction_errors.items()
+            },
+            'prediction_errors': {
+                error_pattern: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_pattern, sample_ids in prediction_errors.items()
+            }
+        },
+        'distribution': {
+            'ground_truth': dict(Counter(ground_truths)),
+            'predictions': dict(Counter(predictions))
+        },
+        'stance_analysis': {
+            'support_vs_refute_samples': len(support_refute_ground_truths),
+            'comment_samples': ground_truths.count('comment'),
+            'unrelated_samples': ground_truths.count('unrelated'),
+            'most_confused_pairs': []
+        }
+    }
+
+
+    confusion_pairs = []
+    for i, label1 in enumerate(stance_labels):
+        for j, label2 in enumerate(stance_labels):
+            if i != j and cm[i, j] > 0:
+                confusion_pairs.append({
+                    'true_stance': label1,
+                    'predicted_stance': label2,
+                    'count': int(cm[i, j]),
+                    'percentage': round(cm[i, j] / np.sum(cm[i, :]) * 100, 2)
+                })
+
+    confusion_pairs.sort(key=lambda x: x['count'], reverse=True)
+    evaluation_result['stance_analysis']['most_confused_pairs'] = confusion_pairs[:5]
+
+
+    base_name = result_file_path.replace('.json', '')
+
+
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+
+    problem_samples = [item for item in detailed_results if not item['correct']]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, 'w', encoding='utf-8') as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+
+    print(f"Evaluation complete: {len(results)} samples")
+    print(f"Key metrics: ACC={evaluation_result['metrics']['ACC']}, Micro F1={evaluation_result['metrics']['Micro_F1']}")
+    print(f"Support/Refute accuracy: {evaluation_result['metrics']['Support_Refute_ACC']}")
+    print(f"Extraction success rate: {evaluation_result['task_info']['extraction_success_rate']}")
+    print(f"Results saved to: {eval_output_file}")
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)}; see {problem_report_file} for details")
+
+    if confusion_pairs:
+        print("\nMost confusable stance pairs:")
+        for pair in confusion_pairs[:3]:
+            print(f"  {pair['true_stance']} → {pair['predicted_stance']}: {pair['count']} times ({pair['percentage']}%)")
+
+    return evaluation_result
+
+
+if __name__ == "__main__":
+    result_file = "model_result.json"
+
+    try:
+        evaluation_result = evaluate_multimodal_stance_detection(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: file not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: invalid format for {result_file}")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")

code/evaluation_code/level3/evaluation_EER.py

@@ -0,0 +1,262 @@
+import json
+import re
+import ast
+from sklearn.metrics import accuracy_score, f1_score, classification_report, confusion_matrix
+from collections import Counter, defaultdict
+from datetime import datetime
+import numpy as np
+
+def extract_emotion_from_output(model_output):
+
+    if not model_output:
+        return None, False, "empty_output"
+
+
+    valid_emotions = ['Amusement', 'Anger', 'Disgust', 'Fear', 'Neutral', 'Sadness', 'Tenderness']
+
+    try:
+
+        if "{'emotion':" in model_output or '{"emotion":' in model_output:
+
+            cleaned_output = model_output.strip()
+
+
+            json_match = re.search(r'\{[^}]*\}', cleaned_output)
+            if json_match:
+                cleaned_output = json_match.group()
+
+
+            try:
+                parsed = ast.literal_eval(cleaned_output)
+            except:
+
+                parsed = json.loads(cleaned_output)
+
+            if 'emotion' in parsed and isinstance(parsed['emotion'], str):
+                emotion = parsed['emotion'].strip()
+                if emotion in valid_emotions:
+                    return emotion, True, None
+                else:
+                    return emotion, False, "invalid_emotion_label"
+
+
+        cleaned_output = model_output.strip()
+
+
+        for emotion in valid_emotions:
+            if cleaned_output == emotion:
+                return emotion, True, None
+
+
+        for emotion in valid_emotions:
+            if cleaned_output.lower() == emotion.lower():
+                return emotion, True, None
+
+
+        for emotion in valid_emotions:
+            if emotion.lower() in cleaned_output.lower():
+                return emotion, False, "emotion_found_but_not_properly_formatted"
+
+        return None, False, "no_valid_emotion_found"
+
+    except Exception as e:
+        return None, False, f"parsing_error_{str(e)}"
+
+def evaluate_emotion_elicitation_reasoning(result_file_path):
+
+
+
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+    prediction_errors = defaultdict(list)
+
+
+    emotion_labels = ['Amusement', 'Anger', 'Disgust', 'Fear', 'Neutral', 'Sadness', 'Tenderness']
+
+
+    for item in results:
+        item_id = item['id']
+        model_output = item['model_output']
+        gt_emotion = item['ground_truth'].strip()
+
+
+        pred_emotion, is_valid, error_type = extract_emotion_from_output(model_output)
+
+
+        detailed_item = {
+            'id': item_id,
+            'model_output': model_output,
+            'extracted_prediction': pred_emotion,
+            'ground_truth': gt_emotion,
+            'correct': pred_emotion == gt_emotion if pred_emotion else False,
+            'valid': is_valid
+        }
+        detailed_results.append(detailed_item)
+
+
+        if not is_valid:
+            extraction_errors[error_type].append(item_id)
+        elif pred_emotion != gt_emotion:
+            error_pattern = f"{gt_emotion}_to_{pred_emotion}"
+            prediction_errors[error_pattern].append(item_id)
+
+
+        if is_valid:
+            predictions.append(pred_emotion)
+            ground_truths.append(gt_emotion)
+
+
+    if len(predictions) == 0:
+        return {
+            'error': 'No valid predictions found',
+            'total_samples': len(results),
+            'extraction_errors': dict(extraction_errors)
+        }
+
+
+    accuracy = accuracy_score(ground_truths, predictions)
+    weighted_f1 = f1_score(ground_truths, predictions, average='weighted')
+    macro_f1 = f1_score(ground_truths, predictions, average='macro')
+    micro_f1 = f1_score(ground_truths, predictions, average='micro')
+
+
+    cm = confusion_matrix(ground_truths, predictions, labels=emotion_labels)
+
+
+    class_report = classification_report(ground_truths, predictions,
+                                       target_names=emotion_labels,
+                                       output_dict=True,
+                                       zero_division=0)
+
+
+    per_class_metrics = {}
+    for i, label in enumerate(emotion_labels):
+        if label in class_report:
+            true_positives = cm[i, i]
+            false_positives = np.sum(cm[:, i]) - true_positives
+            false_negatives = np.sum(cm[i, :]) - true_positives
+
+            per_class_metrics[label] = {
+                'precision': round(class_report[label]['precision'], 4),
+                'recall': round(class_report[label]['recall'], 4),
+                'f1_score': round(class_report[label]['f1-score'], 4),
+                'support': int(class_report[label]['support']),
+                'true_positives': int(true_positives),
+                'false_positives': int(false_positives),
+                'false_negatives': int(false_negatives)
+            }
+
+
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'emotion.elicitation.reasoning',
+            'dataset': 'FilmStim',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_predictions': len(predictions),
+            'extraction_success_rate': round(len(predictions) / len(results), 4)
+        },
+        'metrics': {
+            'ACC': round(accuracy, 4),
+            'WAF': round(weighted_f1, 4),
+            'Macro_F1': round(macro_f1, 4),
+            'Micro_F1': round(micro_f1, 4)
+        },
+        'per_class_metrics': per_class_metrics,
+        'confusion_matrix': {
+            'labels': emotion_labels,
+            'matrix': cm.tolist(),
+            'normalized': (cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]).round(4).tolist()
+        },
+        'error_analysis': {
+            'extraction_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_type, sample_ids in extraction_errors.items()
+            },
+            'prediction_errors': {
+                error_pattern: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_pattern, sample_ids in prediction_errors.items()
+            }
+        },
+        'distribution': {
+            'ground_truth': dict(Counter(ground_truths)),
+            'predictions': dict(Counter(predictions))
+        }
+    }
+
+
+    confusion_pairs = []
+    for i, label1 in enumerate(emotion_labels):
+        for j, label2 in enumerate(emotion_labels):
+            if i != j and cm[i, j] > 0:
+                confusion_pairs.append({
+                    'true_emotion': label1,
+                    'predicted_emotion': label2,
+                    'count': int(cm[i, j]),
+                    'percentage': round(cm[i, j] / np.sum(cm[i, :]) * 100, 2) if np.sum(cm[i, :]) > 0 else 0
+                })
+
+    confusion_pairs.sort(key=lambda x: x['count'], reverse=True)
+    evaluation_result['emotion_confusion_analysis'] = {
+        'most_confused_pairs': confusion_pairs[:10]
+    }
+
+
+    base_name = result_file_path.replace('.json', '')
+
+
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+
+    problem_samples = [item for item in detailed_results if not item['correct']]
+    if problem_samples:
+        problem_report_file = f"{base_name}_problem_samples.json"
+        with open(problem_report_file, 'w', encoding='utf-8') as f:
+            json.dump(problem_samples, f, ensure_ascii=False, indent=2)
+
+
+    print(f"Evaluation complete: {len(results)} samples")
+    print(f"Key metrics: ACC={evaluation_result['metrics']['ACC']}, WAF={evaluation_result['metrics']['WAF']}")
+    print(f"Extraction success rate: {evaluation_result['task_info']['extraction_success_rate']}")
+    print(f"Results saved to: {eval_output_file}")
+    if problem_samples:
+        print(f"Problematic samples: {len(problem_samples)}; see {problem_report_file} for details")
+
+
+    if confusion_pairs:
+        print("\nMost confusable emotion pairs:")
+        for pair in confusion_pairs[:5]:
+            print(f"  {pair['true_emotion']} → {pair['predicted_emotion']}: {pair['count']} times ({pair['percentage']}%)")
+
+    return evaluation_result
+
+
+if __name__ == "__main__":
+    result_file = "model_result.json"
+
+    try:
+        evaluation_result = evaluate_emotion_elicitation_reasoning(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: file not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: invalid format for {result_file}")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")
+

code/evaluation_code/level3/evaluation_EI.py

@@ -0,0 +1,269 @@
+import json
+import re
+import openai
+from collections import Counter, defaultdict
+from datetime import datetime
+import time
+
+def extract_numbered_list(text):
+
+    if not text:
+        return []
+
+
+    patterns = [
+        r'^\s*(\d+)\.\s*(.+)$',
+        r'^\s*(\d+)\)\s*(.+)$',
+        r'^\s*\((\d+)\)\s*(.+)$',
+    ]
+
+    items = []
+    lines = text.strip().split('\n')
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+
+        matched = False
+        for pattern in patterns:
+            match = re.match(pattern, line)
+            if match:
+                number = int(match.group(1))
+                content = match.group(2).strip()
+                items.append(content)
+                matched = True
+                break
+
+
+        if not matched and len(line) > 5:
+            items.append(line)
+
+    return items
+
+def evaluate_with_gpt4(prediction_text, ground_truth_text, emotion, client):
+
+    try:
+        prompt = f"""You are evaluating emotion interpretation explanations.
+
+Task: Compare the predicted explanation with the reference explanation for the emotion "{emotion}".
+
+Reference explanation:
+{ground_truth_text}
+
+Predicted explanation:
+{prediction_text}
+
+Evaluate if the predicted explanation is reasonable and accurate compared to the reference.
+
+Respond with only "CORRECT" or "INCORRECT" based on whether the predicted explanation is of acceptable quality compared to the reference."""
+
+        response = client.chat.completions.create(
+            model="gpt-4o",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.1,
+            max_tokens=10
+        )
+
+        result = response.choices[0].message.content.strip().upper()
+        is_correct = result == "CORRECT"
+
+        return {
+            "is_correct": is_correct,
+            "llm_response": result
+        }
+
+    except Exception as e:
+        return {
+            "is_correct": False,
+            "llm_response": f"Error: {str(e)}"
+        }
+
+def extract_emotion_from_prompt(prompt):
+ 
+    emotion_match = re.search(r"Emotion to explain:\s*(\w+)", prompt)
+    if emotion_match:
+        return emotion_match.group(1)
+    return "Unknown"
+
+def evaluate_emotion_interpretation(result_file_path, api_key):
+
+
+
+    client = openai.OpenAI(api_key=api_key)
+
+
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+
+    correct_count = 0
+    total_valid = 0
+
+
+    for i, item in enumerate(results):
+        item_id = item['id']
+        prompt = item['prompt']
+        model_output = item['model_output']
+        ground_truth = item['ground_truth']
+
+        print(f"Processing sample {i+1}/{len(results)}: {item_id}")
+
+        emotion = extract_emotion_from_prompt(prompt)
+
+
+        pred_items = extract_numbered_list(model_output)
+        gt_items = extract_numbered_list(ground_truth)
+
+
+        has_valid_format = len(pred_items) > 0
+
+
+        detailed_item = {
+            'id': item_id,
+            'emotion': emotion,
+            'model_output': model_output,
+            'ground_truth': ground_truth,
+            'extracted_prediction': pred_items,
+            'extracted_ground_truth': gt_items,
+            'prediction_count': len(pred_items),
+            'ground_truth_count': len(gt_items),
+            'has_valid_format': has_valid_format,
+            'llm_evaluation': None,
+            'is_correct': False
+        }
+
+
+        if has_valid_format:
+            llm_eval = evaluate_with_gpt4(model_output, ground_truth, emotion, client)
+            detailed_item['llm_evaluation'] = llm_eval
+            detailed_item['is_correct'] = llm_eval['is_correct']
+
+            if llm_eval['is_correct']:
+                correct_count += 1
+            total_valid += 1
+
+
+            time.sleep(0.5)
+        else:
+            extraction_errors['invalid_format'].append(item_id)
+
+        detailed_results.append(detailed_item)
+
+
+    format_success_rate = total_valid / len(results) if len(results) > 0 else 0
+    accuracy = correct_count / total_valid if total_valid > 0 else 0
+
+
+    emotion_distribution = Counter([item['emotion'] for item in detailed_results])
+
+
+    pred_lengths = [item['prediction_count'] for item in detailed_results if item['has_valid_format']]
+    gt_lengths = [item['ground_truth_count'] for item in detailed_results]
+
+    avg_pred_length = sum(pred_lengths) / len(pred_lengths) if pred_lengths else 0
+    avg_gt_length = sum(gt_lengths) / len(gt_lengths) if gt_lengths else 0
+
+
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'emotion.interpretation',
+            'dataset': 'EIBench',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_samples': total_valid,
+            'format_success_rate': round(format_success_rate, 4)
+        },
+        'metrics': {
+            'LLM_ACC': round(accuracy, 4),
+            'Correct_Count': correct_count,
+            'Total_Valid': total_valid
+        },
+        'content_analysis': {
+            'avg_prediction_length': round(avg_pred_length, 2),
+            'avg_ground_truth_length': round(avg_gt_length, 2),
+            'emotion_distribution': dict(emotion_distribution)
+        },
+        'error_analysis': {
+            'extraction_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_type, sample_ids in extraction_errors.items()
+            }
+        }
+    }
+
+
+    emotion_analysis = {}
+    for emotion in emotion_distribution.keys():
+        emotion_samples = [item for item in detailed_results if item['emotion'] == emotion and item['has_valid_format']]
+        if emotion_samples:
+            emotion_correct = sum(1 for item in emotion_samples if item['is_correct'])
+            emotion_total = len(emotion_samples)
+            emotion_acc = emotion_correct / emotion_total if emotion_total > 0 else 0
+
+            emotion_analysis[emotion] = {
+                'sample_count': emotion_total,
+                'correct_count': emotion_correct,
+                'accuracy': round(emotion_acc, 4),
+                'avg_prediction_length': round(sum([item['prediction_count'] for item in emotion_samples]) / len(emotion_samples), 2)
+            }
+
+    evaluation_result['emotion_analysis'] = emotion_analysis
+
+
+    base_name = result_file_path.replace('.json', '')
+
+
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+
+    incorrect_samples = [item for item in detailed_results if item['has_valid_format'] and not item['is_correct']]
+    if incorrect_samples:
+        incorrect_report_file = f"{base_name}_incorrect_samples.json"
+        with open(incorrect_report_file, 'w', encoding='utf-8') as f:
+            json.dump(incorrect_samples, f, ensure_ascii=False, indent=2)
+
+
+    print(f"\nEvaluation complete: {len(results)} samples")
+    print(f"Key metric: LLM_ACC={evaluation_result['metrics']['LLM_ACC']}")
+    print(f"Correct count: {evaluation_result['metrics']['Correct_Count']}/{evaluation_result['metrics']['Total_Valid']}")
+    print(f"Format success rate: {evaluation_result['task_info']['format_success_rate']}")
+    print(f"Average prediction length: {evaluation_result['content_analysis']['avg_prediction_length']}")
+    print(f"Results saved to: {eval_output_file}")
+    if incorrect_samples:
+        print(f"Incorrect samples: {len(incorrect_samples)}; see {incorrect_report_file} for details")
+
+
+    if emotion_analysis:
+        print("\nPerformance by emotion type:")
+        for emotion, analysis in emotion_analysis.items():
+            print(f"  {emotion}: ACC={analysis['accuracy']}, Samples={analysis['sample_count']}")
+
+    return evaluation_result
+
+
+if __name__ == "__main__":
+    result_file = "model_result.json"
+    api_key = "xxx"
+
+    try:
+        evaluation_result = evaluate_emotion_interpretation(result_file, api_key)
+
+    except FileNotFoundError:
+        print(f"Error: file not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: invalid format for {result_file}")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")
+

code/evaluation_code/level3/evaluation_LR.py

@@ -0,0 +1,226 @@
+import json
+import re
+import openai
+from collections import Counter, defaultdict
+from datetime import datetime
+import time
+
+def check_required_format(text):
+
+    if not text:
+        return False, ""
+
+
+    pattern = r'^The audience laughed because\s+'
+    match = re.search(pattern, text, re.IGNORECASE)
+
+    if match:
+
+        content = text[match.end():].strip()
+        return True, content
+    else:
+        return False, text.strip()
+
+def evaluate_with_gpt4(prediction_text, ground_truth_text, client):
+
+    try:
+        prompt = f"""Compare the predicted explanation with the reference explanation for why the audience laughed.
+
+Reference explanation:
+{ground_truth_text}
+
+Predicted explanation:
+{prediction_text}
+
+Does the predicted explanation correctly identify the reason for laughter? The prediction doesn't need to be identical to the reference, but should accurately capture why the audience laughed.
+
+Respond with only "CORRECT" or "INCORRECT"."""
+
+        response = client.chat.completions.create(
+            model="gpt-4",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.1,
+            max_tokens=10
+        )
+
+        result = response.choices[0].message.content.strip().upper()
+        is_correct = result == "CORRECT"
+
+        return {
+            "is_correct": is_correct,
+            "llm_response": result
+        }
+
+    except Exception as e:
+        return {
+            "is_correct": False,
+            "llm_response": f"Error: {str(e)}"
+        }
+
+def evaluate_laughter_reasoning(result_file_path, api_key):
+
+
+
+    client = openai.OpenAI(api_key=api_key)
+
+
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+
+    detailed_results = []
+    format_errors = defaultdict(list)
+
+    correct_count = 0
+    total_valid = 0
+
+
+    for i, item in enumerate(results):
+        item_id = item['id']
+        model_output = item['model_output']
+        ground_truth = item['ground_truth']
+
+        print(f"Processing sample {i+1}/{len(results)}: {item_id}")
+
+        has_correct_format, cleaned_content = check_required_format(model_output)
+
+
+        detailed_item = {
+            'id': item_id,
+            'model_output': model_output,
+            'ground_truth': ground_truth,
+            'has_correct_format': has_correct_format,
+            'cleaned_content': cleaned_content,
+            'llm_evaluation': None,
+            'is_correct': False
+        }
+
+
+        if has_correct_format and cleaned_content:
+
+            _, gt_cleaned = check_required_format(ground_truth)
+            if not gt_cleaned:
+                gt_cleaned = ground_truth
+
+            llm_eval = evaluate_with_gpt4(cleaned_content, gt_cleaned, client)
+            detailed_item['llm_evaluation'] = llm_eval
+            detailed_item['is_correct'] = llm_eval['is_correct']
+
+            if llm_eval['is_correct']:
+                correct_count += 1
+            total_valid += 1
+
+
+            time.sleep(0.5)
+        else:
+            if not has_correct_format:
+                format_errors['incorrect_format'].append(item_id)
+            else:
+                format_errors['empty_content'].append(item_id)
+
+        detailed_results.append(detailed_item)
+
+
+    format_success_rate = total_valid / len(results) if len(results) > 0 else 0
+    accuracy = correct_count / total_valid if total_valid > 0 else 0
+
+
+    valid_contents = [item['cleaned_content'] for item in detailed_results if item['has_correct_format'] and item['cleaned_content']]
+    avg_content_length = sum(len(content.split()) for content in valid_contents) / len(valid_contents) if valid_contents else 0
+
+
+    correct_samples = [item for item in detailed_results if item['has_correct_format'] and item['is_correct']]
+    incorrect_samples = [item for item in detailed_results if item['has_correct_format'] and not item['is_correct']]
+
+
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'laughter.reasoning',
+            'dataset': 'SMILE',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_samples': total_valid,
+            'format_success_rate': round(format_success_rate, 4)
+        },
+        'metrics': {
+            'LLM_ACC': round(accuracy, 4),
+            'Correct_Count': correct_count,
+            'Total_Valid': total_valid
+        },
+        'content_analysis': {
+            'avg_content_length_words': round(avg_content_length, 2)
+        },
+        'error_analysis': {
+            'format_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_type, sample_ids in format_errors.items()
+            }
+        }
+    }
+
+
+    if correct_samples:
+        correct_avg_length = sum(len(item['cleaned_content'].split()) for item in correct_samples) / len(correct_samples)
+        evaluation_result['content_analysis']['correct_samples_avg_length'] = round(correct_avg_length, 2)
+
+    if incorrect_samples:
+        incorrect_avg_length = sum(len(item['cleaned_content'].split()) for item in incorrect_samples) / len(incorrect_samples)
+        evaluation_result['content_analysis']['incorrect_samples_avg_length'] = round(incorrect_avg_length, 2)
+
+
+    base_name = result_file_path.replace('.json', '')
+
+
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+
+    if incorrect_samples:
+        incorrect_report_file = f"{base_name}_incorrect_samples.json"
+        with open(incorrect_report_file, 'w', encoding='utf-8') as f:
+            json.dump(incorrect_samples, f, ensure_ascii=False, indent=2)
+
+
+    format_error_samples = [item for item in detailed_results if not item['has_correct_format']]
+    if format_error_samples:
+        format_error_report_file = f"{base_name}_format_error_samples.json"
+        with open(format_error_report_file, 'w', encoding='utf-8') as f:
+            json.dump(format_error_samples, f, ensure_ascii=False, indent=2)
+
+
+    print(f"\nEvaluation complete: {len(results)} samples")
+    print(f"Key metric: LLM_ACC={evaluation_result['metrics']['LLM_ACC']}")
+    print(f"Correct count: {evaluation_result['metrics']['Correct_Count']}/{evaluation_result['metrics']['Total_Valid']}")
+    print(f"Format success rate: {evaluation_result['task_info']['format_success_rate']}")
+    print(f"Average content length: {evaluation_result['content_analysis']['avg_content_length_words']} words")
+    print(f"Results saved to: {eval_output_file}")
+
+    if incorrect_samples:
+        print(f"Incorrect samples: {len(incorrect_samples)}; see {incorrect_report_file} for details")
+    if format_error_samples:
+        print(f"Format-error samples: {len(format_error_samples)}; see {format_error_report_file} for details")
+
+    return evaluation_result
+
+
+if __name__ == "__main__":
+    result_file = "model_result.json"
+    api_key = "xxx"
+
+    try:
+        evaluation_result = evaluate_laughter_reasoning(result_file, api_key)
+
+    except FileNotFoundError:
+        print(f"Error: file not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: invalid format for {result_file}")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")
+

code/evaluation_code/level3/evaluation_MECPE.py

@@ -0,0 +1,304 @@
+import json
+import re
+import ast
+from collections import Counter, defaultdict
+from datetime import datetime
+
+
+from sklearn.metrics import f1_score, precision_score, recall_score
+
+def parse_emotion_cause_pairs(output_text):
+
+    if not output_text:
+        return {}, False, "empty_output"
+
+    valid_emotions = ['joy', 'sadness', 'anger', 'disgust', 'fear', 'surprise', 'neutral']
+
+    try:
+        cleaned_output = output_text.strip()
+
+
+        json_match = re.search(r'\{.*\}', cleaned_output, re.DOTALL)
+        if not json_match:
+            return {}, False, "no_json_structure"
+
+        json_content = json_match.group()
+
+        parsed = None
+
+
+        try:
+
+            parsed = ast.literal_eval(json_content)
+        except (ValueError, SyntaxError) as e:
+
+
+            if "EOF" in str(e) or "end of string" in str(e):
+
+
+                last_comma_index = json_content.rfind(',')
+                if last_comma_index != -1:
+
+                    content_after_comma = json_content[last_comma_index+1:].strip()
+                    if content_after_comma and content_after_comma != '}':
+                        truncated_content = json_content[:last_comma_index] + '}'
+                        try:
+
+                            parsed = ast.literal_eval(truncated_content)
+
+                        except (ValueError, SyntaxError):
+
+                            pass
+
+
+            if parsed is None:
+                try:
+
+                    json_content_fixed = json_content.replace("'", '"')
+                    parsed = json.loads(json_content_fixed)
+                except json.JSONDecodeError:
+
+                    raise e
+
+
+        if not isinstance(parsed, dict):
+            return {}, False, "not_dictionary"
+
+        validated_pairs = {}
+        for utterance_id, pair_data in parsed.items():
+
+            if not isinstance(pair_data, dict) or 'emotion' not in pair_data or 'cause_utterance_id' not in pair_data:
+                continue
+
+            emotion = str(pair_data['emotion']).lower().strip()
+            cause_id = str(pair_data['cause_utterance_id']).strip()
+
+
+            if emotion not in valid_emotions:
+                continue
+
+
+            try:
+                int(utterance_id)
+                int(cause_id)
+            except (ValueError, TypeError):
+                continue
+
+            validated_pairs[str(utterance_id)] = {
+                'emotion': emotion,
+                'cause_utterance_id': cause_id
+            }
+
+        return validated_pairs, len(validated_pairs) > 0, None
+
+    except Exception as e:
+
+        return {}, False, f"parsing_error_{type(e).__name__}"
+
+def calculate_pair_extraction_metrics(predictions, ground_truths):
+
+    total_tp = 0
+    total_fp = 0
+    total_fn = 0
+
+    emotion_correct_on_common = 0
+    cause_correct_on_common = 0
+    total_common_utterances = 0
+
+    all_true_emotions = []
+    all_pred_emotions = []
+
+    for pred_dict, true_dict in zip(predictions, ground_truths):
+
+        pred_pairs = {(str(uid), data['emotion'], str(data['cause_utterance_id'])) for uid, data in pred_dict.items()}
+        true_pairs = {(str(uid), data['emotion'], str(data['cause_utterance_id'])) for uid, data in true_dict.items()}
+
+
+        all_pred_emotions.extend([data['emotion'] for data in pred_dict.values()])
+        all_true_emotions.extend([data['emotion'] for data in true_dict.values()])
+
+
+        total_tp += len(pred_pairs.intersection(true_pairs))
+        total_fp += len(pred_pairs.difference(true_pairs))
+        total_fn += len(true_pairs.difference(pred_pairs))
+
+
+        common_ids = set(pred_dict.keys()) & set(true_dict.keys())
+        total_common_utterances += len(common_ids)
+        for uid in common_ids:
+            if pred_dict[uid]['emotion'] == true_dict[uid]['emotion']:
+                emotion_correct_on_common += 1
+            if pred_dict[uid]['cause_utterance_id'] == true_dict[uid]['cause_utterance_id']:
+                cause_correct_on_common += 1
+
+
+    micro_precision = total_tp / (total_tp + total_fp) if (total_tp + total_fp) > 0 else 0
+    micro_recall = total_tp / (total_tp + total_fn) if (total_tp + total_fn) > 0 else 0
+    micro_f1 = 2 * micro_precision * micro_recall / (micro_precision + micro_recall) if (micro_precision + micro_recall) > 0 else 0
+
+    emotion_accuracy_common = emotion_correct_on_common / total_common_utterances if total_common_utterances > 0 else 0
+    cause_accuracy_common = cause_correct_on_common / total_common_utterances if total_common_utterances > 0 else 0
+
+    return {
+        'micro_f1': micro_f1,
+        'micro_precision': micro_precision,
+        'micro_recall': micro_recall,
+        'emotion_accuracy_on_common_ids': emotion_accuracy_common,
+        'cause_accuracy_on_common_ids': cause_accuracy_common,
+        'total_predicted_pairs': total_tp + total_fp,
+        'total_ground_truth_pairs': total_tp + total_fn,
+        'exact_matches': total_tp,
+        'emotion_distribution': dict(Counter(all_true_emotions)),
+        'predicted_emotion_distribution': dict(Counter(all_pred_emotions))
+    }
+
+def evaluate_multimodal_emotion_cause_pair_extraction(result_file_path):
+
+
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    extraction_errors = defaultdict(list)
+
+    for item in results:
+        item_id = item.get('id', 'unknown')
+        model_output = item.get('model_output', '')
+        ground_truth = item.get('ground_truth', {})
+
+
+        pred_pairs, pred_valid, pred_error = parse_emotion_cause_pairs(model_output)
+
+
+        if isinstance(ground_truth, str):
+            gt_pairs, gt_valid, gt_error = parse_emotion_cause_pairs(ground_truth)
+        else:
+            gt_pairs, gt_valid, gt_error = parse_emotion_cause_pairs(json.dumps(ground_truth))
+
+        detailed_item = {
+            'id': item_id,
+            'model_output': model_output,
+            'ground_truth': ground_truth,
+            'extracted_prediction': pred_pairs,
+            'extracted_ground_truth': gt_pairs,
+            'prediction_valid': pred_valid,
+            'ground_truth_valid': gt_valid,
+            'predicted_pairs_count': len(pred_pairs),
+            'ground_truth_pairs_count': len(gt_pairs)
+        }
+        detailed_results.append(detailed_item)
+
+        if not pred_valid:
+            extraction_errors[pred_error].append(item_id)
+        if not gt_valid:
+
+            extraction_errors[f"gt_{gt_error}"].append(item_id)
+
+
+        if pred_valid and gt_valid:
+            predictions.append(pred_pairs)
+            ground_truths.append(gt_pairs)
+
+    if not predictions:
+        print("Error: No valid prediction–ground truth pairs were found for evaluation.")
+        print(f"Total samples: {len(results)}")
+        print("Parsing error stats:", json.dumps(dict(extraction_errors), indent=2))
+        return {
+            'error': 'No valid prediction and ground_truth pairs found for evaluation',
+            'total_samples': len(results),
+            'extraction_errors': dict(extraction_errors)
+    }
+
+
+    metrics = calculate_pair_extraction_metrics(predictions, ground_truths)
+
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'multimodal.emotion.cause.pair.extraction',
+            'dataset': 'ECF',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_samples_for_eval': len(predictions),
+            'extraction_success_rate': round(len(predictions) / len(results) if results else 0, 4)
+        },
+        'metrics': {
+            'Micro_F1': round(metrics['micro_f1'], 4),
+            'Micro_Precision': round(metrics['micro_precision'], 4),
+            'Micro_Recall': round(metrics['micro_recall'], 4),
+            'Emotion_ACC_on_Common_IDs': round(metrics['emotion_accuracy_on_common_ids'], 4),
+            'Cause_ACC_on_Common_IDs': round(metrics['cause_accuracy_on_common_ids'], 4),
+            'Total_Predicted_Pairs': metrics['total_predicted_pairs'],
+            'Total_Ground_Truth_Pairs': metrics['total_ground_truth_pairs'],
+            'Exact_Matches': metrics['exact_matches']
+        },
+        'distribution_analysis': {
+            'emotion_distribution': metrics['emotion_distribution'],
+            'predicted_emotion_distribution': metrics['predicted_emotion_distribution']
+        },
+        'error_analysis': {
+            'extraction_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids[:10]
+                } for error_type, sample_ids in extraction_errors.items()
+            }
+        }
+    }
+
+
+    base_name = result_file_path.rsplit('.', 1)[0]
+    eval_output_file = f"{base_name}_evaluation.json"
+    detailed_output_file = f"{base_name}_detailed_results.json"
+
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+
+    print("\n" + "="*50)
+    print("Evaluation Report")
+    print("="*50)
+    print(f"Evaluation complete: {len(results)} total samples")
+    print(f"Valid evaluation samples (both prediction and label parsed successfully): {len(predictions)} / {len(results)} (extraction success rate: {evaluation_result['task_info']['extraction_success_rate']:.2%})")
+    print("\n--- Primary Metrics ---")
+    print(f"Micro F1: {evaluation_result['metrics']['Micro_F1']:.4f}")
+    print(f"Micro Precision: {evaluation_result['metrics']['Micro_Precision']:.4f}")
+    print(f"Micro Recall: {evaluation_result['metrics']['Micro_Recall']:.4f}")
+    print("\n--- Auxiliary Metrics ---")
+    print(f"Emotion accuracy on common IDs (Emotion ACC): {evaluation_result['metrics']['Emotion_ACC_on_Common_IDs']:.4f}")
+    print(f"Cause accuracy on common IDs (Cause ACC): {evaluation_result['metrics']['Cause_ACC_on_Common_IDs']:.4f}")
+    print(f"Total predicted pairs: {evaluation_result['metrics']['Total_Predicted_Pairs']}")
+    print(f"Total ground-truth pairs: {evaluation_result['metrics']['Total_Ground_Truth_Pairs']}")
+    print(f"Exact matches: {evaluation_result['metrics']['Exact_Matches']}")
+
+    if extraction_errors:
+        print("\n--- Parsing Error Analysis ---")
+        for error_type, info in evaluation_result['error_analysis']['extraction_errors'].items():
+            print(f"- Type: {error_type}, Count: {info['count']}")
+
+    print(f"Detailed evaluation results saved to: {eval_output_file}")
+    print(f"Per-sample parsing details saved to: {detailed_output_file}")
+
+
+    return evaluation_result
+
+
+
+
+if __name__ == "__main__":
+
+    result_file = "model_result.json"
+
+    try:
+        evaluation_result = evaluate_multimodal_emotion_cause_pair_extraction(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: File '{result_file}' not found. Please check that the path is correct.")
+    except json.JSONDecodeError:
+        print(f"Error: File '{result_file}' is not valid JSON. Ensure the file is a JSON list (starts with '[' and ends with ']').")
+    except Exception as e:
+        print(f"An unknown error occurred during evaluation: {e}")

code/evaluation_code/level3/evaluation_SD.py

@@ -0,0 +1,264 @@
+import json
+import re
+from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix, classification_report
+from collections import Counter, defaultdict
+from datetime import datetime
+import numpy as np
+
+def parse_classification_output(output_text):
+
+    if not output_text:
+        return None, False, "empty_output"
+
+
+    cleaned_output = output_text.strip().lower()
+
+
+    if re.search(r'\btrue\b', cleaned_output):
+        return "true", True, None
+    elif re.search(r'\bfalse\b', cleaned_output):
+        return "false", True, None
+    else:
+        return None, False, "no_valid_label"
+
+def calculate_weighted_average_f1(y_true, y_pred, labels):
+
+    return f1_score(y_true, y_pred, labels=labels, average='weighted')
+
+def evaluate_sarcasm_detection(result_file_path):
+
+
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    parsing_errors = defaultdict(list)
+
+
+    for item in results:
+        item_id = item['id']
+        model_output = item['model_output']
+        ground_truth = item['ground_truth']
+
+
+        pred_label, pred_valid, pred_error = parse_classification_output(model_output)
+
+
+        gt_label = ground_truth.strip().lower() if isinstance(ground_truth, str) else str(ground_truth).strip().lower()
+
+
+        detailed_item = {
+            'id': item_id,
+            'model_output': model_output,
+            'ground_truth': ground_truth,
+            'extracted_prediction': pred_label,
+            'standardized_ground_truth': gt_label,
+            'prediction_valid': pred_valid,
+            'prediction_error': pred_error
+        }
+        detailed_results.append(detailed_item)
+
+
+        if not pred_valid:
+            parsing_errors[pred_error].append(item_id)
+
+
+        if pred_valid and gt_label in ['true', 'false']:
+            predictions.append(pred_label)
+            ground_truths.append(gt_label)
+
+
+    if len(predictions) == 0:
+        return {
+            'error': 'No valid predictions found',
+            'total_samples': len(results),
+            'parsing_errors': dict(parsing_errors)
+        }
+
+
+    labels = ['true', 'false']
+
+
+    accuracy = accuracy_score(ground_truths, predictions)
+    weighted_f1 = calculate_weighted_average_f1(ground_truths, predictions, labels)
+
+
+    precision_scores = precision_score(ground_truths, predictions, labels=labels, average=None, zero_division=0)
+    recall_scores = recall_score(ground_truths, predictions, labels=labels, average=None, zero_division=0)
+    f1_scores = f1_score(ground_truths, predictions, labels=labels, average=None, zero_division=0)
+
+
+    macro_precision = precision_score(ground_truths, predictions, average='macro', zero_division=0)
+    macro_recall = recall_score(ground_truths, predictions, average='macro', zero_division=0)
+    macro_f1 = f1_score(ground_truths, predictions, average='macro', zero_division=0)
+
+
+    cm = confusion_matrix(ground_truths, predictions, labels=labels)
+
+
+    true_distribution = Counter(ground_truths)
+    pred_distribution = Counter(predictions)
+
+
+    class_metrics = {}
+    for i, label in enumerate(labels):
+        class_metrics[label] = {
+            'precision': round(precision_scores[i], 4),
+            'recall': round(recall_scores[i], 4),
+            'f1_score': round(f1_scores[i], 4),
+            'support': true_distribution.get(label, 0)
+        }
+
+
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'sarcasm.detection',
+            'dataset': 'MUStARD',
+            'task_type': '2-CLS',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_samples': len(predictions),
+            'parsing_success_rate': round(len(predictions) / len(results), 4)
+        },
+        'metrics': {
+            'ACC': round(accuracy, 4),
+            'WAF': round(weighted_f1, 4),
+            'Macro_Precision': round(macro_precision, 4),
+            'Macro_Recall': round(macro_recall, 4),
+            'Macro_F1': round(macro_f1, 4)
+        },
+        'class_metrics': class_metrics,
+        'confusion_matrix': {
+            'matrix': cm.tolist(),
+            'labels': labels
+        },
+        'distribution_analysis': {
+            'ground_truth_distribution': dict(true_distribution),
+            'prediction_distribution': dict(pred_distribution)
+        },
+        'error_analysis': {
+            'parsing_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_type, sample_ids in parsing_errors.items()
+            }
+        }
+    }
+
+
+    if len(labels) == 2:
+
+        tn, fp, fn, tp = cm.ravel() if cm.size == 4 else [0, 0, 0, 0]
+
+
+        specificity = tn / (tn + fp) if (tn + fp) > 0 else 0
+        sensitivity = tp / (tp + fn) if (tp + fn) > 0 else 0
+
+        evaluation_result['binary_metrics'] = {
+            'true_positives': int(tp),
+            'true_negatives': int(tn),
+            'false_positives': int(fp),
+            'false_negatives': int(fn),
+            'sensitivity_recall': round(sensitivity, 4),
+            'specificity': round(specificity, 4)
+        }
+
+
+    error_samples = []
+    correct_samples = []
+
+    for i, (pred, true, item) in enumerate(zip(predictions, ground_truths,
+                                              [d for d in detailed_results if d['prediction_valid']])):
+        if pred != true:
+            error_samples.append({
+                'id': item['id'],
+                'predicted': pred,
+                'ground_truth': true,
+                'model_output': item['model_output']
+            })
+        else:
+            correct_samples.append(item['id'])
+
+    evaluation_result['sample_analysis'] = {
+        'correct_samples_count': len(correct_samples),
+        'error_samples_count': len(error_samples),
+        'error_rate': round(len(error_samples) / len(predictions), 4) if predictions else 0
+    }
+
+
+    base_name = result_file_path.replace('.json', '')
+
+
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+
+    if error_samples:
+        error_report_file = f"{base_name}_error_samples.json"
+        with open(error_report_file, 'w', encoding='utf-8') as f:
+            json.dump(error_samples, f, ensure_ascii=False, indent=2)
+
+
+    parsing_error_samples = [item for item in detailed_results if not item['prediction_valid']]
+    if parsing_error_samples:
+        parsing_error_report_file = f"{base_name}_parsing_error_samples.json"
+        with open(parsing_error_report_file, 'w', encoding='utf-8') as f:
+            json.dump(parsing_error_samples, f, ensure_ascii=False, indent=2)
+
+
+    print(f"Evaluation complete: {len(results)} samples")
+    print(f"Key metrics: ACC={evaluation_result['metrics']['ACC']}, WAF={evaluation_result['metrics']['WAF']}")
+    print(f"Macro-averaged metrics: Precision={evaluation_result['metrics']['Macro_Precision']}, Recall={evaluation_result['metrics']['Macro_Recall']}, F1={evaluation_result['metrics']['Macro_F1']}")
+    print(f"Parsing success rate: {evaluation_result['task_info']['parsing_success_rate']}")
+
+
+    print("\nPer-class metrics:")
+    for label, metrics in evaluation_result['class_metrics'].items():
+        print(f"  {label.upper()}: P={metrics['precision']}, R={metrics['recall']}, F1={metrics['f1_score']}, Support={metrics['support']}")
+
+
+    print(f"\nConfusion matrix:")
+    print(f"        Predicted")
+    print(f"Actual  false  true")
+    for i, true_label in enumerate(labels):
+        row_str = f"{true_label:>5}   "
+        for j, pred_label in enumerate(labels):
+            row_str += f"{cm[i][j]:>5}  "
+        print(row_str)
+
+
+    print(f"\nLabel distribution:")
+    print(f"True labels: {dict(true_distribution)}")
+    print(f"Predicted labels: {dict(pred_distribution)}")
+
+    print(f"\nResults saved to: {eval_output_file}")
+    if error_samples:
+        print(f"Error samples: {len(error_samples)}; see {error_report_file} for details")
+    if parsing_error_samples:
+        print(f"Parsing-error samples: {len(parsing_error_samples)}; see {parsing_error_report_file} for details")
+
+    return evaluation_result
+
+
+if __name__ == "__main__":
+    result_file = "model_result.json"
+
+    try:
+        evaluation_result = evaluate_sarcasm_detection(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: file not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: invalid format for {result_file}")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")
+

code/evaluation_code/level3/evaluation_SFA.py

@@ -0,0 +1,411 @@
+import json
+import re
+import ast
+from sklearn.metrics import f1_score, precision_score, recall_score
+from collections import Counter, defaultdict
+from datetime import datetime
+import numpy as np
+
+def parse_sentiment_flip_output(output_text):
+
+    if not output_text:
+        return [], False, "empty_output"
+
+
+    valid_sentiments = ['positive', 'negative', 'neutral']
+    valid_trigger_types = [
+        'Introduction of New Information',
+        'Logical Argumentation',
+        'Participant Feedback and Interaction',
+        'Personal Experience and Self-reflection'
+    ]
+
+    try:
+
+        cleaned_output = output_text.strip()
+
+
+        list_match = re.search(r'\[.*\]', cleaned_output, re.DOTALL)
+        if not list_match:
+            return [], False, "no_list_structure"
+
+        list_content = list_match.group()
+
+
+        try:
+            parsed = ast.literal_eval(list_content)
+        except:
+
+            list_content = re.sub(r"'", '"', list_content)
+            parsed = json.loads(list_content)
+
+        if not isinstance(parsed, list):
+            return [], False, "not_list"
+
+
+        validated_flips = []
+        for item in parsed:
+            if not isinstance(item, dict):
+                continue
+
+
+            required_fields = ['holder', 'initial_sentiment', 'flipped_sentiment', 'trigger_type']
+            if not all(field in item for field in required_fields):
+                continue
+
+            holder = str(item['holder']).strip()
+            initial_sentiment = str(item['initial_sentiment']).lower().strip()
+            flipped_sentiment = str(item['flipped_sentiment']).lower().strip()
+            trigger_type = str(item['trigger_type']).strip()
+
+
+            if initial_sentiment not in valid_sentiments or flipped_sentiment not in valid_sentiments:
+                continue
+
+
+            trigger_valid = False
+            for valid_trigger in valid_trigger_types:
+                if trigger_type.lower() in valid_trigger.lower() or valid_trigger.lower() in trigger_type.lower():
+                    trigger_type = valid_trigger
+                    trigger_valid = True
+                    break
+
+            if not trigger_valid:
+                continue
+
+
+            if not holder:
+                continue
+
+            validated_flips.append({
+                'holder': holder,
+                'initial_sentiment': initial_sentiment,
+                'flipped_sentiment': flipped_sentiment,
+                'trigger_type': trigger_type
+            })
+
+        return validated_flips, len(validated_flips) >= 0, None
+
+    except Exception as e:
+        return [], False, f"parsing_error_{str(e)}"
+
+def normalize_flip_for_comparison(flip):
+
+    return {
+        'holder': flip['holder'].lower().strip(),
+        'initial_sentiment': flip['initial_sentiment'].lower().strip(),
+        'flipped_sentiment': flip['flipped_sentiment'].lower().strip(),
+        'trigger_type': flip['trigger_type'].strip()
+    }
+
+def calculate_exact_match_f1(predictions, ground_truths):
+
+    total_pred_flips = 0
+    total_true_flips = 0
+    exact_matches = 0
+
+
+    all_metrics = []
+
+    for pred_flips, true_flips in zip(predictions, ground_truths):
+
+        norm_pred_flips = [normalize_flip_for_comparison(flip) for flip in pred_flips]
+        norm_true_flips = [normalize_flip_for_comparison(flip) for flip in true_flips]
+
+        total_pred_flips += len(pred_flips)
+        total_true_flips += len(true_flips)
+
+
+        sample_matches = 0
+        for true_flip in norm_true_flips:
+            if true_flip in norm_pred_flips:
+                sample_matches += 1
+                exact_matches += 1
+
+
+        sample_precision = sample_matches / len(pred_flips) if len(pred_flips) > 0 else 0
+        sample_recall = sample_matches / len(true_flips) if len(true_flips) > 0 else (1 if len(pred_flips) == 0 else 0)
+        sample_f1 = 2 * sample_precision * sample_recall / (sample_precision + sample_recall) if (sample_precision + sample_recall) > 0 else 0
+
+        all_metrics.append({
+            'precision': sample_precision,
+            'recall': sample_recall,
+            'f1': sample_f1,
+            'matches': sample_matches,
+            'pred_count': len(pred_flips),
+            'true_count': len(true_flips)
+        })
+
+
+    micro_precision = exact_matches / total_pred_flips if total_pred_flips > 0 else 0
+    micro_recall = exact_matches / total_true_flips if total_true_flips > 0 else 0
+    micro_f1 = 2 * micro_precision * micro_recall / (micro_precision + micro_recall) if (micro_precision + micro_recall) > 0 else 0
+
+
+    macro_precision = np.mean([m['precision'] for m in all_metrics]) if all_metrics else 0
+    macro_recall = np.mean([m['recall'] for m in all_metrics]) if all_metrics else 0
+    macro_f1 = np.mean([m['f1'] for m in all_metrics]) if all_metrics else 0
+
+    return {
+        'exact_match_f1': micro_f1,
+        'micro_precision': micro_precision,
+        'micro_recall': micro_recall,
+        'macro_precision': macro_precision,
+        'macro_recall': macro_recall,
+        'macro_f1': macro_f1,
+        'total_predicted_flips': total_pred_flips,
+        'total_ground_truth_flips': total_true_flips,
+        'exact_matches': exact_matches,
+        'sample_metrics': all_metrics
+    }
+
+def analyze_flip_patterns(predictions, ground_truths):
+
+    all_pred_sentiments = []
+    all_true_sentiments = []
+    all_pred_triggers = []
+    all_true_triggers = []
+    all_pred_holders = []
+    all_true_holders = []
+
+    for pred_flips, true_flips in zip(predictions, ground_truths):
+        for flip in pred_flips:
+            all_pred_sentiments.append(f"{flip['initial_sentiment']}->{flip['flipped_sentiment']}")
+            all_pred_triggers.append(flip['trigger_type'])
+            all_pred_holders.append(flip['holder'])
+
+        for flip in true_flips:
+            all_true_sentiments.append(f"{flip['initial_sentiment']}->{flip['flipped_sentiment']}")
+            all_true_triggers.append(flip['trigger_type'])
+            all_true_holders.append(flip['holder'])
+
+    return {
+        'sentiment_flip_patterns': {
+            'predicted': dict(Counter(all_pred_sentiments)),
+            'ground_truth': dict(Counter(all_true_sentiments))
+        },
+        'trigger_type_distribution': {
+            'predicted': dict(Counter(all_pred_triggers)),
+            'ground_truth': dict(Counter(all_true_triggers))
+        },
+        'holder_distribution': {
+            'predicted': dict(Counter(all_pred_holders)),
+            'ground_truth': dict(Counter(all_true_holders))
+        }
+    }
+
+def evaluate_sentiment_flip_analysis(result_file_path):
+
+
+
+    with open(result_file_path, 'r', encoding='utf-8') as f:
+        results = json.load(f)
+
+    predictions = []
+    ground_truths = []
+    detailed_results = []
+    parsing_errors = defaultdict(list)
+
+
+    for item in results:
+        item_id = item['id']
+        model_output = item['model_output']
+        ground_truth = item['ground_truth']
+
+
+        pred_flips, pred_valid, pred_error = parse_sentiment_flip_output(model_output)
+
+
+        if isinstance(ground_truth, str):
+            gt_flips, gt_valid, gt_error = parse_sentiment_flip_output(ground_truth)
+        elif isinstance(ground_truth, list):
+            gt_flips = ground_truth
+            gt_valid = True
+            gt_error = None
+        else:
+            gt_flips = []
+            gt_valid = False
+            gt_error = "invalid_ground_truth_format"
+
+
+        detailed_item = {
+            'id': item_id,
+            'model_output': model_output,
+            'ground_truth': ground_truth,
+            'extracted_prediction': pred_flips,
+            'extracted_ground_truth': gt_flips,
+            'prediction_valid': pred_valid,
+            'ground_truth_valid': gt_valid,
+            'predicted_flips_count': len(pred_flips),
+            'ground_truth_flips_count': len(gt_flips)
+        }
+        detailed_results.append(detailed_item)
+
+
+        if not pred_valid:
+            parsing_errors[pred_error].append(item_id)
+        elif not gt_valid:
+            parsing_errors[f"gt_{gt_error}"].append(item_id)
+
+
+        if pred_valid and gt_valid:
+            predictions.append(pred_flips)
+            ground_truths.append(gt_flips)
+
+
+    if len(predictions) == 0:
+        return {
+            'error': 'No valid predictions found',
+            'total_samples': len(results),
+            'parsing_errors': dict(parsing_errors)
+        }
+
+
+    metrics = calculate_exact_match_f1(predictions, ground_truths)
+
+
+    pattern_analysis = analyze_flip_patterns(predictions, ground_truths)
+
+
+    pred_flip_counts = [len(flips) for flips in predictions]
+    true_flip_counts = [len(flips) for flips in ground_truths]
+
+
+    evaluation_result = {
+        'task_info': {
+            'task_name': 'sentiment.flip.analysis',
+            'dataset': 'PanoSent',
+            'task_type': 'GEN',
+            'evaluation_time': datetime.now().isoformat(),
+            'total_samples': len(results),
+            'valid_samples': len(predictions),
+            'parsing_success_rate': round(len(predictions) / len(results), 4)
+        },
+        'metrics': {
+            'Exact_Match_F1': round(metrics['exact_match_f1'], 4),
+            'Micro_Precision': round(metrics['micro_precision'], 4),
+            'Micro_Recall': round(metrics['micro_recall'], 4),
+            'Macro_Precision': round(metrics['macro_precision'], 4),
+            'Macro_Recall': round(metrics['macro_recall'], 4),
+            'Macro_F1': round(metrics['macro_f1'], 4),
+            'Total_Predicted_Flips': metrics['total_predicted_flips'],
+            'Total_Ground_Truth_Flips': metrics['total_ground_truth_flips'],
+            'Exact_Matches': metrics['exact_matches']
+        },
+        'flip_count_analysis': {
+            'avg_predicted_flips_per_sample': round(np.mean(pred_flip_counts), 2),
+            'avg_ground_truth_flips_per_sample': round(np.mean(true_flip_counts), 2),
+            'predicted_flip_count_distribution': dict(Counter(pred_flip_counts)),
+            'ground_truth_flip_count_distribution': dict(Counter(true_flip_counts))
+        },
+        'pattern_analysis': pattern_analysis,
+        'error_analysis': {
+            'parsing_errors': {
+                error_type: {
+                    'count': len(sample_ids),
+                    'sample_ids': sample_ids
+                } for error_type, sample_ids in parsing_errors.items()
+            }
+        }
+    }
+
+
+    zero_pred_samples = sum(1 for count in pred_flip_counts if count == 0)
+    zero_true_samples = sum(1 for count in true_flip_counts if count == 0)
+
+    evaluation_result['zero_flip_analysis'] = {
+        'predicted_zero_flips': zero_pred_samples,
+        'ground_truth_zero_flips': zero_true_samples,
+        'zero_flip_accuracy': sum(1 for p, t in zip(pred_flip_counts, true_flip_counts) if p == 0 and t == 0) / len(predictions)
+    }
+
+
+    base_name = result_file_path.replace('.json', '')
+
+
+    eval_output_file = f"{base_name}_evaluation.json"
+    with open(eval_output_file, 'w', encoding='utf-8') as f:
+        json.dump(evaluation_result, f, ensure_ascii=False, indent=2)
+
+
+    detailed_output_file = f"{base_name}_detailed_results.json"
+    with open(detailed_output_file, 'w', encoding='utf-8') as f:
+        json.dump(detailed_results, f, ensure_ascii=False, indent=2)
+
+
+    low_score_samples = []
+    for i, sample_metric in enumerate(metrics['sample_metrics']):
+        if sample_metric['f1'] < 0.5:
+            low_score_samples.append({
+                'id': detailed_results[i]['id'],
+                'f1_score': sample_metric['f1'],
+                'precision': sample_metric['precision'],
+                'recall': sample_metric['recall'],
+                'predicted_flips': detailed_results[i]['extracted_prediction'],
+                'ground_truth_flips': detailed_results[i]['extracted_ground_truth']
+            })
+
+    if low_score_samples:
+        low_score_report_file = f"{base_name}_low_score_samples.json"
+        with open(low_score_report_file, 'w', encoding='utf-8') as f:
+            json.dump(low_score_samples, f, ensure_ascii=False, indent=2)
+
+
+    parsing_error_samples = [item for item in detailed_results if not item['prediction_valid']]
+    if parsing_error_samples:
+        parsing_error_report_file = f"{base_name}_parsing_error_samples.json"
+        with open(parsing_error_report_file, 'w', encoding='utf-8') as f:
+            json.dump(parsing_error_samples, f, ensure_ascii=False, indent=2)
+
+
+    print(f"Evaluation complete: {len(results)} samples")
+    print(f"Key metric: Exact Match F1={evaluation_result['metrics']['Exact_Match_F1']}")
+    print(f"Micro-averaged metrics: Precision={evaluation_result['metrics']['Micro_Precision']}, Recall={evaluation_result['metrics']['Micro_Recall']}")
+    print(f"Macro-averaged metrics: Precision={evaluation_result['metrics']['Macro_Precision']}, Recall={evaluation_result['metrics']['Macro_Recall']}, F1={evaluation_result['metrics']['Macro_F1']}")
+    print(f"Parsing success rate: {evaluation_result['task_info']['parsing_success_rate']}")
+
+
+    print(f"\nFlip statistics:")
+    print(f"Average predicted flips per sample: {evaluation_result['flip_count_analysis']['avg_predicted_flips_per_sample']}")
+    print(f"Average ground-truth flips per sample: {evaluation_result['flip_count_analysis']['avg_ground_truth_flips_per_sample']}")
+    print(f"Zero-flip accuracy: {evaluation_result['zero_flip_analysis']['zero_flip_accuracy']:.4f}")
+
+
+    print(f"\nSentiment flip patterns:")
+    gt_patterns = evaluation_result['pattern_analysis']['sentiment_flip_patterns']['ground_truth']
+    pred_patterns = evaluation_result['pattern_analysis']['sentiment_flip_patterns']['predicted']
+    for pattern in sorted(set(list(gt_patterns.keys()) + list(pred_patterns.keys()))):
+        gt_count = gt_patterns.get(pattern, 0)
+        pred_count = pred_patterns.get(pattern, 0)
+        print(f"  {pattern}: GT={gt_count}, Pred={pred_count}")
+
+
+    print(f"\nTrigger type distribution:")
+    gt_triggers = evaluation_result['pattern_analysis']['trigger_type_distribution']['ground_truth']
+    pred_triggers = evaluation_result['pattern_analysis']['trigger_type_distribution']['predicted']
+    for trigger in sorted(set(list(gt_triggers.keys()) + list(pred_triggers.keys()))):
+        gt_count = gt_triggers.get(trigger, 0)
+        pred_count = pred_triggers.get(trigger, 0)
+        print(f"  {trigger}: GT={gt_count}, Pred={pred_count}")
+
+    print(f"\nResults saved to: {eval_output_file}")
+    if low_score_samples:
+        print(f"Low-scoring samples: {len(low_score_samples)}; see {low_score_report_file} for details")
+    if parsing_error_samples:
+        print(f"Parsing-error samples: {len(parsing_error_samples)}; see {parsing_error_report_file} for details")
+
+    return evaluation_result
+
+
+if __name__ == "__main__":
+    result_file = "model_result.json"
+
+    try:
+        evaluation_result = evaluate_sentiment_flip_analysis(result_file)
+
+    except FileNotFoundError:
+        print(f"Error: file not found {result_file}")
+    except json.JSONDecodeError:
+        print(f"Error: invalid format for {result_file}")
+    except Exception as e:
+        print(f"Evaluation failed: {str(e)}")

code/test_code/test_affectgpt.py

@@ -0,0 +1,285 @@
+import os
+import json
+import argparse
+import time
+import sys
+from typing import Dict, Any
+from tqdm import tqdm
+import torch
+import cv2
+import tempfile
+import torch.backends.cudnn as cudnn
+import decord
+decord.bridge.set_bridge('torch')
+import torch.multiprocessing as mp
+
+# --- Worker Initialization for Multiprocessing Pool ---
+worker_chat = None
+worker_cfg = None
+
+def init_worker():
+    global worker_chat, worker_cfg
+    setup_seeds(42)
+    worker_chat, worker_cfg = load_affectgpt_model()
+    print(f"[Worker PID: {os.getpid()}] Model loaded successfully.")
+
+sys.path.append('AffectGPT')
+
+from my_affectgpt.common.config import Config
+from my_affectgpt.common.registry import registry
+from my_affectgpt.conversation.conversation_video import Chat
+
+# --- Configuration ---
+LEVEL_DIRS = ["level1", "level2", "level3"]
+GENERIC_RESULT_PATTERN = "_result.json"
+
+def get_media_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext in ['.mp4', '.avi', '.mov', '.mkv', '.webm']:
+        return 'video'
+    elif ext in ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp']:
+        return 'image'
+    else:
+        raise ValueError(f"Unsupported file format: {ext}")
+
+def setup_seeds(seed=42):
+    import random
+    random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed(seed)
+        torch.cuda.manual_seed_all(seed)
+    cudnn.benchmark = False
+    cudnn.deterministic = True
+
+def load_affectgpt_model():
+    print("Loading AffectGPT model...")
+    import config
+    config.PATH_TO_LLM['Qwen25'] = 'Qwen25'
+    config.PATH_TO_VISUAL['CLIP_VIT_LARGE'] = 'CLIP_VIT_LARGE'
+    config.PATH_TO_AUDIO['HUBERT_LARGE'] = 'HUBRT_LARGE'
+    cfg_path = "CFG_PATH"
+    class Args:
+        def __init__(self):
+            self.cfg_path = cfg_path
+            self.options = ["inference.test_epoch=60"]
+    args = Args()
+    cfg = Config(args)
+    model_cfg = cfg.model_cfg
+    device = 'cuda:7'
+    ckpt_path = "CKPT_PATH"
+    model_cfg.ckpt_3 = ckpt_path
+    model_cls = registry.get_model_class(model_cfg.arch)
+    model = model_cls.from_config(model_cfg)
+    model = model.to(device).eval()
+    chat = Chat(model, model_cfg, device=device)
+    print("AffectGPT model loaded!")
+    return chat, cfg
+
+def create_complete_dataset(cfg):
+    from my_affectgpt.processors import BaseProcessor
+    class CompleteDataset:
+        def __init__(self, cfg):
+            self.vis_processor = BaseProcessor()
+            self.img_processor = BaseProcessor()
+            self.n_frms = 8
+            inference_cfg = cfg.inference_cfg
+            vis_processor_cfg = inference_cfg.get("vis_processor")
+            img_processor_cfg = inference_cfg.get("img_processor")
+            if vis_processor_cfg is not None:
+                self.vis_processor = registry.get_processor_class(vis_processor_cfg.train.name).from_config(vis_processor_cfg.train)
+            if img_processor_cfg is not None:
+                self.img_processor = registry.get_processor_class(img_processor_cfg.train.name).from_config(img_processor_cfg.train)
+            self.n_frms = cfg.model_cfg.vis_processor.train.n_frms
+            
+        def read_frame_face_audio_text(self, video_path, face_npy, audio_path, image_path):
+            sample_data = {}
+            frame, raw_frame = None, None
+            if video_path is not None:
+                from my_affectgpt.processors.video_processor import load_video
+                raw_frame, msg = load_video(video_path=video_path, n_frms=self.n_frms, height=224, width=224, sampling="uniform", return_msg=True)
+                frame = self.vis_processor.transform(raw_frame)
+            sample_data['frame'] = frame
+            sample_data['raw_frame'] = raw_frame
+            sample_data['face'] = None
+            sample_data['raw_face'] = None
+            audio, raw_audio = None, None
+            if audio_path is not None and os.path.exists(audio_path):
+                from my_affectgpt.models.ImageBind.data import load_audio, transform_audio
+                raw_audio = load_audio([audio_path], "cpu", clips_per_video=8)[0]
+                audio = transform_audio(raw_audio, "cpu")
+            sample_data['audio'] = audio
+            sample_data['raw_audio'] = raw_audio
+            image, raw_image = None, None
+            if image_path is not None and os.path.exists(image_path):
+                from PIL import Image as PILImage
+                raw_image = PILImage.open(image_path).convert('RGB')
+                image = self.img_processor(raw_image)
+            sample_data['image'] = image
+            sample_data['raw_image'] = raw_image
+            return sample_data
+        def get_prompt_for_multimodal(self, face_or_frame, subtitle, user_message):
+            prompt = f"<FrameHere>{user_message}"
+            if subtitle:
+                prompt = f"Context: {subtitle}\n{prompt}"
+            return prompt
+    return CompleteDataset(cfg)
+
+def process_single_sample(chat, cfg, media_full_path, prompt_text):
+    try:
+        media_type = get_media_type(media_full_path)
+        if media_type == 'image':
+            temp_video = tempfile.mktemp(suffix='.mp4')
+            img = cv2.imread(media_full_path)
+            height, width, layers = img.shape
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            video_writer = cv2.VideoWriter(temp_video, fourcc, 1.0, (width, height))
+            for _ in range(30):
+                video_writer.write(img)
+            video_writer.release()
+            video_path, audio_path, image_path = temp_video, None, None
+        else:
+            video_path, audio_path, image_path = media_full_path, None, None
+        
+        dataset_cls = create_complete_dataset(cfg)
+        sample_data = dataset_cls.read_frame_face_audio_text(video_path, None, audio_path, image_path)
+        _, audio_llms = chat.postprocess_audio(sample_data)
+        _, frame_llms = chat.postprocess_frame(sample_data)
+        _, face_llms = chat.postprocess_face(sample_data)
+        _, image_llms = chat.postprocess_image(sample_data)
+        
+        img_list = {'audio': audio_llms, 'frame': frame_llms, 'face': face_llms, 'image': image_llms, 'multi': None}
+        
+        user_message = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+        prompt = dataset_cls.get_prompt_for_multimodal('frame', "", user_message)
+        
+        response = chat.answer_sample(prompt=prompt, img_list=img_list, num_beams=1, temperature=0.1, do_sample=False, top_p=0.9, max_new_tokens=512, max_length=2000)
+        
+        if media_type == 'image' and os.path.exists(temp_video):
+            os.remove(temp_video)
+        return response
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return f"ERROR: {str(e)}"
+
+def text_only_fallback_logic(chat, cfg, prompt_text: str) -> str:
+    print("Executing text-only fallback in worker...")
+    try:
+        dataset_cls = create_complete_dataset(cfg)
+        user_message = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+        prompt = dataset_cls.get_prompt_for_multimodal('frame', "", user_message)
+        img_list = {'audio': None, 'frame': None, 'face': None, 'image': None, 'multi': None}
+        response = chat.answer_sample(prompt=prompt, img_list=img_list, num_beams=1, temperature=0.1, do_sample=False, top_p=0.9, max_new_tokens=512, max_length=2000)
+        return response
+    except Exception as e:
+        return f"ERROR in text-only fallback: {str(e)}"
+
+# --- Worker Task Functions ---
+def run_inference_task(media_full_path, prompt_text):
+    global worker_chat, worker_cfg
+    if worker_chat is None or worker_cfg is None: return "ERROR: Worker model not initialized."
+    return process_single_sample(worker_chat, worker_cfg, media_full_path, prompt_text)
+
+def run_fallback_task(prompt_text):
+    global worker_chat, worker_cfg
+    if worker_chat is None or worker_cfg is None: return "ERROR: Worker model not initialized."
+    return text_only_fallback_logic(worker_chat, worker_cfg, prompt_text)
+
+def process_task(task_path: str, result_suffix: str, pool_ref: list):
+    source_json_files = [f for f in os.listdir(task_path) if f.endswith('.json') and GENERIC_RESULT_PATTERN not in f]
+    if not source_json_files:
+        print(f"   No source JSON files found in {task_path}.")
+        return
+
+    for json_filename in source_json_files:
+        dataset_json_path = os.path.join(task_path, json_filename)
+        result_json_path = os.path.join(task_path, f"{os.path.splitext(json_filename)[0]}{result_suffix}")
+        if os.path.exists(result_json_path):
+            print(f"  [INFO] Result file '{os.path.basename(result_json_path)}' already exists, skipping.")
+            continue
+
+        print(f"Reading and processing dataset: {json_filename}")
+        try:
+            with open(dataset_json_path, 'r', encoding='utf-8') as f: data = json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError) as e:
+            print(f"  Could not read or parse JSON file {dataset_json_path}: {e}")
+            continue
+
+        all_results = []
+        for item in tqdm(data, desc=f"  Processing {json_filename}"):
+            start_time = time.time()
+            model_output, prompt, ground_truth = "", "", ""
+            try:
+                prompt = item['conversations'][0]['value']
+                ground_truth = item['conversations'][1]['value']
+                media_relative_path = item.get('image') or item.get('video')
+                if not media_relative_path and 'conversations' in item and isinstance(item.get('conversations')[0], dict):
+                    media_relative_path = item['conversations'][0].get('image') or item['conversations'][0].get('video')
+
+                if not media_relative_path:
+                    model_output = pool_ref[0].apply(run_fallback_task, args=(prompt,))
+                else:
+                    media_full_path = os.path.join(task_path, media_relative_path)
+                    if not os.path.exists(media_full_path):
+                        model_output = pool_ref[0].apply(run_fallback_task, args=(prompt,))
+                    else:
+                        async_result = pool_ref[0].apply_async(run_inference_task, args=(media_full_path, prompt))
+                        try:
+                            result = async_result.get(timeout=60)
+                            if isinstance(result, str) and result.startswith("ERROR:"):
+                                pool_ref[0].terminate()
+                                pool_ref[0].join()
+                                pool_ref[0] = mp.Pool(processes=1, initializer=init_worker)
+                                model_output = pool_ref[0].apply(run_fallback_task, args=(prompt,))
+                            else:
+                                model_output = result
+                        except mp.TimeoutError:
+                            pool_ref[0].terminate()
+                            pool_ref[0].join()
+                            pool_ref[0] = mp.Pool(processes=1, initializer=init_worker)
+                            model_output = pool_ref[0].apply(run_fallback_task, args=(prompt,))
+            except Exception as e:
+                model_output = f"ERROR: Main loop error: {e}"
+                print(f"\n {model_output}")
+
+            end_time = time.time()
+            all_results.append({
+                "id": item.get('id', 'N/A'), "prompt": prompt, "model_output": model_output,
+                "ground_truth": ground_truth, "processing_time_seconds": round(end_time - start_time, 2)
+            })
+
+        with open(result_json_path, 'w', encoding='utf-8') as f:
+            json.dump(all_results, f, indent=4, ensure_ascii=False)
+        print(f"  Task complete. Results saved to: {result_json_path}")
+
+def main():
+    try:
+        mp.set_start_method('spawn', force=True)
+        print("Multiprocessing start method set to 'spawn'.")
+    except RuntimeError:
+        pass
+
+    parser = argparse.ArgumentParser(description="Test emotion.hallucination with AffectGPT.")
+    parser.add_argument("--result-suffix", default="_affectgpt_result.json", help="Result file suffix")
+    args = parser.parse_args()
+
+    pool = mp.Pool(processes=1, initializer=init_worker)
+    pool_ref = [pool] 
+
+    try:
+        dataset_dir = "emotion_task"
+        os.chdir(dataset_dir)
+        for level_dir in LEVEL_DIRS:
+            level_path = os.path.join(dataset_dir, level_dir)
+            if not os.path.isdir(level_path): continue
+            
+            task_dirs = sorted([d.path for d in os.scandir(level_path) if d.is_dir()])
+            for task_path in task_dirs:
+                process_task(task_path, args.result_suffix, pool_ref)
+    finally:
+        pool_ref[0].close()
+        pool_ref[0].join()
+
+if __name__ == "__main__":
+    main()

code/test_code/test_emotionllama.py

@@ -0,0 +1,364 @@
+import os
+os.environ.setdefault("CUDA_VISIBLE_DEVICES", "0")
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+
+import re
+import json
+import argparse
+import time
+import sys
+from typing import List, Dict, Any
+
+from tqdm import tqdm
+from PIL import Image
+import torch
+import torch.backends.cudnn as cudnn
+import numpy as np
+import signal
+import contextlib
+
+@contextlib.contextmanager
+def timeout(seconds: int, error_message: str = 'Function call timed out'):
+    def _handle_timeout(signum, frame):
+        raise TimeoutError(error_message)
+    signal.signal(signal.SIGALRM, _handle_timeout)
+    signal.alarm(seconds)
+    try:
+        yield
+    finally:
+        signal.alarm(0)
+
+class TimeoutError(Exception):
+    pass
+
+
+EMOTION_LLAMA_PATH = "PATH_TO_EMOTION_LLAMA_PROJECT"
+if EMOTION_LLAMA_PATH not in sys.path:
+    sys.path.append(EMOTION_LLAMA_PATH)
+
+from minigpt4.common.config import Config
+from minigpt4.common.registry import registry
+from minigpt4.conversation.conversation import Conversation, Chat, SeparatorStyle
+
+
+from minigpt4.datasets.builders import *   # noqa
+from minigpt4.models import *              # noqa
+from minigpt4.processors import *          # noqa
+from minigpt4.runners import *             # noqa
+from minigpt4.tasks import *               # noqa
+
+# --- Configuration ---
+LEVEL_DIRS = ["level1", "level2", "level3"]
+GENERIC_RESULT_PATTERN = "_result.json"
+RESULT_SUFFIX = "_emotionllama_result.json"
+
+
+_TAGS = [
+    r"<s>\s*[INST]\s*", r"[/INST]",                 
+    r"<image>.*?</image>", r"<img>.*?</img>",            
+    r"<video>.*?</video>", r"<feature>.*?</feature>",    
+    r"<VideoHere>", r"<FeatureHere>",                    
+    r"<image>", r"</image>", r"<video>", r"</video>", r"<feature>", r"</feature>",
+]
+_TAGS_RE = re.compile("|".join(_TAGS), flags=re.IGNORECASE | re.DOTALL)
+
+def clean_prompt_text(s: str) -> str:
+    s = _TAGS_RE.sub("", s).strip()
+    tail = '\nRespond ONLY with: {"emotion":"neutral|negative|positive"}'
+    if "Respond ONLY with" not in s:
+        s += tail
+    return s
+
+_JSON_RE = re.compile(r'\{\s*"emotion"\s*:\s*"(neutral|negative|positive)"\s*\}', re.IGNORECASE)
+def extract_emotion_json(text: str) -> str:
+    m = _JSON_RE.search(text)
+    if m:
+        return json.dumps({"emotion": m.group(1).lower()}, ensure_ascii=False)
+    low = text.lower()
+    if "negative" in low:
+        return json.dumps({"emotion": "negative"}, ensure_ascii=False)
+    if "positive" in low:
+        return json.dumps({"emotion": "positive"}, ensure_ascii=False)
+    return json.dumps({"emotion": "neutral"}, ensure_ascii=False)
+
+
+IMG_EXTS = {".jpg", ".jpeg", ".png", ".bmp", ".webp", ".gif"}
+VID_EXTS = {".mp4", ".avi", ".mov", ".mkv", ".webm"}
+
+
+def get_first_frame_pil(video_path: str):
+    import cv2
+    from PIL import Image
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise IOError(f"Cannot open video file: {video_path}")
+    ret, frame = cap.read()
+    cap.release()
+    if not ret:
+        raise IOError(f"Cannot read frame from video file: {video_path}")
+    return Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+
+def get_media_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext in VID_EXTS:
+        return 'video'
+    elif ext in IMG_EXTS:
+        return 'image'
+    else:
+        return 'unknown'
+
+@torch.inference_mode()
+def process_single_sample(chat: Chat, media_full_path: str, prompt_text: str) -> str:
+    try:
+        chat_state = Conversation(
+            system="",
+            roles=("<s>[INST] ", " [/INST]"),
+            messages=[],
+            offset=2,
+            sep_style=SeparatorStyle.SINGLE,
+            sep=""
+        )
+        img_list = []
+        media_type = get_media_type(media_full_path)
+        if media_type == 'unknown':
+            raise ValueError(f"Unsupported media type: {media_full_path}")
+
+        if media_type == 'video':
+            pil_image = get_first_frame_pil(media_full_path)
+        else:  # image
+            from PIL import Image
+            pil_image = Image.open(media_full_path).convert("RGB")
+        
+        chat.upload_img(pil_image, chat_state, img_list)
+        
+        if len(img_list) > 0:
+            chat.encode_img(img_list)
+
+        clean_prompt = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+        chat.ask(clean_prompt, chat_state)
+        
+        model_output = chat.answer(conv=chat_state, img_list=img_list, temperature=0.1, max_new_tokens=500, max_length=2000)[0]
+        return model_output
+    except Exception as e:
+        return f"ERROR: {str(e)}"
+
+def text_only_fallback(chat: Chat, prompt_text: str) -> str:
+
+    print("  [INFO] Executing text-only fallback...")
+    try:
+        img_list = [Image.new('RGB', (1, 1), 'black')]
+        
+        chat_state = Conversation(
+            system="",
+            roles=("<s>[INST] ", " [/INST]"),
+            messages=[],
+            offset=2,
+            sep_style=SeparatorStyle.SINGLE,
+            sep=""
+        )
+        
+        chat.encode_img(img_list)
+
+        clean_prompt = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+        chat.ask(clean_prompt, chat_state)
+        
+        model_output = chat.answer(conv=chat_state, img_list=[], temperature=0.1, max_new_tokens=500, max_length=2000)[0]
+        return model_output
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return f"ERROR in text-only fallback: {str(e)}"
+
+def process_task(task_path: str, chat: Chat):
+    print(f"\n--- Processing Task: {os.path.basename(task_path)} ---")
+
+    source_json_files = [
+        f for f in os.listdir(task_path)
+        if f.endswith(".json") and GENERIC_RESULT_PATTERN not in f and not f.endswith(RESULT_SUFFIX)
+    ]
+    if not source_json_files:
+        print(f"   No source JSON files found in {task_path}.")
+        return
+
+    for json_filename in source_json_files:
+        dataset_json_path = os.path.join(task_path, json_filename)
+        result_json_path = os.path.join(task_path, f"{os.path.splitext(json_filename)[0]}{RESULT_SUFFIX}")
+
+        if os.path.exists(result_json_path):
+            print(f"  Result file already exists, skipping: {os.path.basename(result_json_path)}")
+            continue
+
+        print(f"  Reading and processing dataset: {json_filename}")
+        try:
+            with open(dataset_json_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError) as e:
+            print(f"  Could not read or parse JSON file {dataset_json_path}: {e}")
+            continue
+
+        all_results: List[Dict[str, Any]] = []
+        for item in tqdm(data, desc=f"  Processing {json_filename}"):
+            start_time = time.time()
+            model_output = ""
+            prompt = ""
+            ground_truth = ""
+            try:
+                prompt = item["conversations"][0]["value"]
+                ground_truth = item["conversations"][1]["value"]
+
+                media_relative_path = None
+
+                if 'image' in item:
+                    media_relative_path = item.get('image')
+                elif 'video' in item:
+                    media_relative_path = item.get('video')
+              
+                elif 'conversations' in item and item['conversations'] and isinstance(item['conversations'][0], dict):
+                    conv0 = item['conversations'][0]
+                    if 'image' in conv0:
+                        media_relative_path = conv0.get('image')
+                    elif 'video' in conv0:
+                        media_relative_path = conv0.get('video')
+
+
+                if not media_relative_path:
+                    print(f"\n  Could not find media key for item {item.get('id', 'N/A')}. Falling back to text-only.")
+                    model_output = text_only_fallback(chat=chat, prompt_text=prompt)
+                else:
+                    media_full_path = os.path.join(task_path, media_relative_path)
+                    if not os.path.exists(media_full_path):
+                        raise FileNotFoundError(f"Media file not found: {media_full_path}")
+
+                    try:
+                        with timeout(seconds=300):
+                            model_output = process_single_sample(
+                                chat=chat,
+                                media_full_path=media_full_path,
+                                prompt_text=prompt,
+                            )
+                    except TimeoutError:
+                        print(f"\n  Processing timed out for item {item.get('id', 'N/A')}. Falling back to text-only.")
+                        model_output = text_only_fallback(
+                            chat=chat,
+                            prompt_text=prompt
+                        )
+            except Exception as e:
+                model_output = f"ERROR: {str(e)}"
+
+            end_time = time.time()
+            all_results.append({
+                "id": item.get("id", "N/A"),
+                "prompt": prompt,
+                "model_output": model_output,
+                "ground_truth": ground_truth,
+                "processing_time_seconds": round(end_time - start_time, 2),
+            })
+
+        with open(result_json_path, "w", encoding="utf-8") as f:
+            json.dump(all_results, f, indent=4, ensure_ascii=False)
+        print(f"Task complete. Results saved to: {result_json_path}")
+
+def init_model(cfg_path: str, device: str):
+
+    if not torch.cuda.is_available():
+        print("CUDA is not available.")
+        sys.exit(1)
+
+    args = argparse.Namespace(cfg_path=cfg_path, options=None)
+    cfg = Config(args)
+    model_config = cfg.model_cfg
+
+    model_config.low_resource = False
+
+    model_cls = registry.get_model_class(model_config.arch)
+    model = model_cls.from_config(model_config).to(device)
+
+
+    torch.backends.cuda.matmul.allow_tf32 = False
+    torch.backends.cudnn.allow_tf32 = False
+
+    import contextlib
+    @contextlib.contextmanager
+    def _fp16_autocast_cm():
+        with torch.amp.autocast('cuda', dtype=torch.float16):
+            yield
+    model.maybe_autocast = lambda *a, **k: _fp16_autocast_cm()
+
+    # Initialize visual processor
+    try:
+        vis_processor_cfg = cfg.datasets_cfg.feature_face_caption.vis_processor.train
+    except Exception:
+        vis_processor_cfg = cfg.datasets_cfg.cc_align.vis_processor.train
+    vis_processor = registry.get_processor_class(vis_processor_cfg.name).from_config(vis_processor_cfg)
+
+    model.eval()
+    chat = Chat(model, vis_processor, device=device)
+
+    if hasattr(chat, "answer_prepare"):
+        _orig_answer_prepare = chat.answer_prepare
+
+        def _answer_prepare_sane(*args, **kwargs):
+            out = _orig_answer_prepare(*args, **kwargs)
+            if isinstance(out, dict) and "inputs_embeds" in out:
+                emb = out["inputs_embeds"]
+                if isinstance(emb, torch.Tensor):
+                    ref_param = next(model.llama_model.parameters())
+                    target_device = ref_param.device
+                    target_dtype  = ref_param.dtype  
+                    emb = emb.to(device=target_device, dtype=target_dtype).contiguous()
+                    out["inputs_embeds"] = emb
+
+            for k in ("do_sample", "top_p", "repetition_penalty", "length_penalty", "num_beams"):
+                out.pop(k, None)
+            return out
+
+        chat.answer_prepare = _answer_prepare_sane
+    return chat, cfg
+
+# ---------------- Main Function ----------------
+def main():
+    parser = argparse.ArgumentParser(description="Batch inference for task with Emotion-LLaMA.")
+    parser.add_argument(
+        "--cfg-path",
+        default=os.path.join(EMOTION_LLAMA_PATH, " example_config/demo.yaml"),
+        help="Path to the Emotion-LLaMA configuration file.",
+    )
+    parser.add_argument("--max_new_tokens", type=int, default=32)
+    parser.add_argument("--max_length", type=int, default=1024)
+    parser.add_argument("--temperature", type=float, default=0.1)
+    parser.add_argument("--device", default="cuda:0", help="Device to run on.")
+    args = parser.parse_args()
+
+    if "cuda" in args.device:
+        if not torch.cuda.is_available():
+            print(f"CUDA device '{args.device}' is not available.")
+            sys.exit(1)
+        torch.cuda.set_device(args.device)
+
+    chat, cfg = init_model(args.cfg_path, args.device)
+
+
+    dataset_dir = os.getcwd()
+    print(f"Running in directory: {dataset_dir}")
+
+    for level_dir in LEVEL_DIRS:
+        level_path = os.path.join(dataset_dir, level_dir)
+        if not os.path.isdir(level_path):
+            continue
+
+        task_dirs = sorted([d.path for d in os.scandir(level_path) if d.is_dir()])
+        for task_path in task_dirs:
+            process_task(
+                task_path,
+                chat,
+            )
+
+
+if __name__ == "__main__":
+    random_seed = 42
+    np.random.seed(random_seed)
+    torch.manual_seed(random_seed)
+    cudnn.benchmark = False
+    cudnn.deterministic = True
+
+    main()

code/test_code/test_gemini_2.5_flash.py

@@ -0,0 +1,227 @@
+import os
+import json
+import argparse
+import time
+from typing import Optional
+from tqdm import tqdm
+from google import genai
+
+# --- Configuration ---
+LEVEL_DIRS = ["level1", "level2", "level3"]
+GENERIC_RESULT_PATTERN = "_result.json"
+
+INLINE_SIZE_LIMIT_BYTES = 20 * 1024 * 1024
+
+MODEL_NAME = "gemini-2.5-flash"
+RESULT_SUFFIX = f"_{MODEL_NAME.replace('.', '_')}_result.json"
+
+
+def get_mime_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+
+    # ---- Video ----
+    if ext in [".mp4", ".m4v", ".mov", ".avi", ".mkv", ".webm", ".mpg", ".mpeg", ".wmv", ".3gp", ".3gpp", ".flv"]:
+        return "video/mp4"
+
+    # ---- Audio ----
+    if ext in [".mp3", ".wav", ".aac", ".aiff", ".flac", ".ogg"]:
+        if ext == ".mp3":
+            return "audio/mp3"
+        if ext == ".wav":
+            return "audio/wav"
+        if ext == ".aac":
+            return "audio/aac"
+        if ext == ".aiff":
+            return "audio/aiff"
+        if ext == ".flac":
+            return "audio/flac"
+        if ext == ".ogg":
+            return "audio/ogg"
+
+    # ---- Image ----
+    if ext in [".jpg", ".jpeg"]:
+        return "image/jpeg"
+    if ext == ".png":
+        return "image/png"
+    if ext == ".webp":
+        return "image/webp"
+    if ext == ".gif":
+        return "image/gif"
+
+    return "application/octet-stream"
+
+
+def _poll_file_ready(client: genai.Client, file_obj, sleep_s: float = 2.0, max_wait_s: float = 300.0) -> Optional[object]:
+    start = time.time()
+    name = getattr(file_obj, "name", None)
+    state = getattr(file_obj, "state", None)
+    state_name = getattr(state, "name", None) or str(state)
+
+    while state_name and state_name.upper() in ("PROCESSING", "PENDING"):
+        if time.time() - start > max_wait_s:
+            return None
+        time.sleep(sleep_s)
+        try:
+            file_obj = client.files.get(name=name)
+        except Exception:
+            time.sleep(sleep_s)
+        state = getattr(file_obj, "state", None)
+        state_name = getattr(state, "name", None) or str(state)
+
+    return file_obj
+
+
+def process_single_sample(client: genai.Client, media_full_path: str, prompt_text: str) -> str:
+    clean_prompt = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+    file_size = os.path.getsize(media_full_path)
+    mime_type = get_mime_type(media_full_path)
+
+    try:
+        if file_size < INLINE_SIZE_LIMIT_BYTES:
+            print(f"\n  File size ({file_size / 1024**2:.2f} MB) is under limit. Using inline method.")
+            with open(media_full_path, "rb") as f:
+                file_bytes = f.read()
+
+            media_part = genai.types.Part(
+                inline_data=genai.types.Blob(data=file_bytes, mime_type=mime_type)
+            )
+
+            response = client.models.generate_content(
+                model=MODEL_NAME,
+                contents=[
+                    media_part,
+                    genai.types.Part(text=clean_prompt),
+                ],
+            )
+            return getattr(response, "text", str(response))
+
+        else:
+            print(f"\n   File size ({file_size / 1024**2:.2f} MB) exceeds limit. Using File API.")
+            uploaded_file = None
+            try:
+                print(f"   Uploading: {os.path.basename(media_full_path)} ...")
+                uploaded_file = client.files.upload(file=media_full_path)
+
+                uploaded_file = _poll_file_ready(client, uploaded_file)
+                if uploaded_file is None:
+                    raise RuntimeError("File processing timeout in Files API.")
+
+                print("   File is ready. Generating content ...")
+                response = client.models.generate_content(
+                    model=MODEL_NAME,
+                    contents=[
+                        uploaded_file,                     
+                        genai.types.Part(text=clean_prompt) 
+                    ],
+                )
+                return getattr(response, "text", str(response))
+            finally:
+                try:
+                    if uploaded_file and getattr(uploaded_file, "name", None):
+                        print(f" Deleting uploaded file: {uploaded_file.name}")
+                        client.files.delete(name=uploaded_file.name)
+                except Exception as _e:
+                    print(f" Failed to delete uploaded file: {_e}")
+
+    except Exception as e:
+        return f"ERROR: {str(e)}"
+
+
+def process_task(task_path: str, client: genai.Client):
+
+    source_json_files = [
+        f for f in os.listdir(task_path)
+        if f.endswith(".json") and GENERIC_RESULT_PATTERN not in f
+    ]
+    if not source_json_files:
+        print(f" No source JSON files found in {task_path}.")
+        return
+
+    for json_filename in source_json_files:
+        dataset_json_path = os.path.join(task_path, json_filename)
+        result_json_path = os.path.join(task_path, f"{os.path.splitext(json_filename)[0]}{RESULT_SUFFIX}")
+
+        if os.path.exists(result_json_path):
+            print(f" Result file already exists, skipping: {os.path.basename(result_json_path)}")
+            continue
+
+        try:
+            with open(dataset_json_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError) as e:
+            print(f" Could not read or parse JSON file {dataset_json_path}: {e}")
+            continue
+
+        all_results = []
+        for item in tqdm(data, desc=f"  Processing {json_filename}"):
+            start_time = time.time()
+            model_output = ""
+            prompt = ""
+            ground_truth = ""
+            try:
+                prompt = item["conversations"][0]["value"]
+                ground_truth = item["conversations"][1]["value"]
+                media_path_key = "image" if "image" in item else "video"
+                media_relative_path = item.get(media_path_key)
+                if not media_relative_path:
+                    raise ValueError("Missing 'image' or 'video' key in JSON item.")
+
+                media_full_path = os.path.join(task_path, media_relative_path)
+                if not os.path.exists(media_full_path):
+                    raise FileNotFoundError(f"Media file not found: {media_full_path}")
+
+                model_output = process_single_sample(client, media_full_path, prompt)
+
+            except Exception as e:
+                model_output = f"ERROR: {str(e)}"
+                print(f" Failed to process item {item.get('id', 'N/A')}: {e}")
+
+            end_time = time.time()
+            all_results.append({
+                "id": item.get("id", "N/A"),
+                "prompt": prompt,
+                "model_output": model_output,
+                "ground_truth": ground_truth,
+                "processing_time_seconds": round(end_time - start_time, 2),
+            })
+
+        with open(result_json_path, "w", encoding="utf-8") as f:
+            json.dump(all_results, f, indent=4, ensure_ascii=False)
+        print(f" Task complete. Results saved to: {result_json_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=f"Test emotion.hallucination with {MODEL_NAME}, auto-selecting media strategy (google-genai)."
+    )
+    parser.add_argument(
+        "--api-key",
+        default=os.getenv("GOOGLE_API_KEY", "KEY"),
+        help="Google Gemini API key (or set the GOOGLE_API_KEY environment variable)."
+    )
+    args = parser.parse_args()
+
+    if not args.api_key or args.api_key == "KEY":
+        print("\nPlease provide your Google Gemini API key via the --api-key argument or by setting the GOOGLE_API_KEY environment variable.")
+        return
+
+    try:
+        client = genai.Client(api_key=args.api_key)
+    except Exception as e:
+        print(f"Failed to initialize Gemini client: {e}")
+        return
+
+    dataset_dir = os.getcwd()
+
+    for level_dir in LEVEL_DIRS:
+        level_path = os.path.join(dataset_dir, level_dir)
+        if not os.path.isdir(level_path):
+            continue
+
+        task_dirs = sorted([d.path for d in os.scandir(level_path) if d.is_dir()])
+        for task_path in task_dirs:
+            process_task(task_path, client)
+
+
+if __name__ == "__main__":
+    main()

code/test_code/test_gemini_2.5_pro.py

@@ -0,0 +1,211 @@
+import os
+import json
+import argparse
+import time
+from typing import Optional
+from tqdm import tqdm
+from google import genai
+
+# --- Configuration ---
+LEVEL_DIRS = ["level1", "level2", "level3"]
+GENERIC_RESULT_PATTERN = "_result.json"
+PROMPT_IMAGE_PLACEHOLDER = "<image>"
+PROMPT_VIDEO_PLACEHOLDER = "<video>"
+
+INLINE_SIZE_LIMIT_BYTES = 20 * 1024 * 1024
+
+MODEL_NAME = "gemini-2.5-pro"
+RESULT_SUFFIX = "_gemini_2.5_pro_result.json"
+
+
+def get_mime_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+
+    # --- Video ---
+    if ext in [".mp4", ".m4v", ".mov", ".avi", ".mkv", ".webm", ".mpg", ".mpeg", ".wmv", ".3gp", ".3gpp", ".flv"]:
+        return "video/mp4"
+
+    # --- Audio ---
+    if ext in [".mp3", ".wav", ".aac", ".aiff", ".flac", ".ogg"]:
+        return f"audio/{ext[1:]}"
+
+    # --- Image ---
+    if ext in [".jpg", ".jpeg"]:
+        return "image/jpeg"
+    if ext in [".png", ".webp", ".gif"]:
+        return f"image/{ext[1:]}"
+
+    return "application/octet-stream"
+
+
+def _poll_file_ready(client: genai.Client, file_obj, sleep_s: float = 2.0, max_wait_s: float = 300.0) -> Optional[object]:
+    start_time = time.time()
+    name = getattr(file_obj, "name", None)
+    if not name:
+        return file_obj 
+
+    while time.time() - start_time < max_wait_s:
+        state = getattr(file_obj, "state", None)
+        state_name = getattr(state, "name", None) or str(state)
+
+        if state_name.upper() not in ("PROCESSING", "PENDING"):
+
+            return file_obj
+
+        time.sleep(sleep_s)
+        try:
+            file_obj = client.files.get(name=name)
+        except Exception:
+            
+            time.sleep(sleep_s)
+    
+    return None 
+
+def process_single_sample(client: genai.Client, media_full_path: str, prompt_text: str) -> str:
+
+    clean_prompt = prompt_text.replace(PROMPT_IMAGE_PLACEHOLDER, "").replace(PROMPT_VIDEO_PLACEHOLDER, "").strip()
+    file_size = os.path.getsize(media_full_path)
+    mime_type = get_mime_type(media_full_path)
+
+    try:
+        if file_size < INLINE_SIZE_LIMIT_BYTES:
+            print(f"\n      [INFO] File size ({file_size / 1024**2:.2f} MB) is under limit. Using inline method.")
+            with open(media_full_path, "rb") as f:
+                media_part = genai.types.Part(
+                    inline_data=genai.types.Blob(data=f.read(), mime_type=mime_type)
+                )
+
+            contents = [media_part, genai.types.Part(text=clean_prompt)]
+            response = client.models.generate_content(model=MODEL_NAME, contents=contents)
+            return getattr(response, "text", str(response))
+
+        else:
+            print(f"\n     File size ({file_size / 1024**2:.2f} MB) exceeds limit. Using File API.")
+            uploaded_file = None
+            try:
+                print(f"    Uploading: {os.path.basename(media_full_path)}...")
+                uploaded_file = client.files.upload(file_path=media_full_path)
+
+                uploaded_file = _poll_file_ready(client, uploaded_file)
+                if uploaded_file is None:
+                    raise RuntimeError("File processing timed out in Files API.")
+
+                print("   File is ready. Generating content...")
+                contents = [uploaded_file, genai.types.Part(text=clean_prompt)]
+                response = client.models.generate_content(model=MODEL_NAME, contents=contents)
+                return getattr(response, "text", str(response))
+            finally:
+                if uploaded_file and getattr(uploaded_file, "name", None):
+                    try:
+                        print(f"   Deleting uploaded file: {uploaded_file.name}")
+                        client.files.delete(name=uploaded_file.name)
+                    except Exception as e:
+                        print(f"   Failed to delete uploaded file: {e}")
+
+    except Exception as e:
+        print(f"  An error occurred during Gemini processing: {e}")
+        return f"ERROR: {str(e)}"
+
+
+def process_task(task_path: str, client: genai.Client):
+
+    source_json_files = [
+        f for f in os.listdir(task_path)
+        if f.endswith(".json") and GENERIC_RESULT_PATTERN not in f
+    ]
+    if not source_json_files:
+        print(f" No source JSON files found in {task_path}.")
+        return
+
+    for json_filename in source_json_files:
+        dataset_json_path = os.path.join(task_path, json_filename)
+        result_json_path = os.path.join(task_path, f"{os.path.splitext(json_filename)[0]}{RESULT_SUFFIX}")
+
+        if os.path.exists(result_json_path):
+            print(f"  Result file already exists, skipping: {os.path.basename(result_json_path)}")
+            continue
+
+        print(f" Reading and processing dataset: {json_filename}")
+        try:
+            with open(dataset_json_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError) as e:
+            print(f"Could not read or parse JSON file {dataset_json_path}: {e}")
+            continue
+
+        all_results = []
+        for item in tqdm(data, desc=f"  Processing {json_filename}"):
+            start_time = time.time()
+            model_output = ""
+            prompt = ""
+            ground_truth = ""
+            try:
+                prompt = item["conversations"][0]["value"]
+                ground_truth = item["conversations"][1]["value"]
+
+                media_path_key = "image" if "image" in item else "video"
+                media_relative_path = item.get(media_path_key)
+                if not media_relative_path:
+                    raise ValueError("Missing 'image' or 'video' key in JSON item.")
+
+                media_full_path = os.path.join(task_path, media_relative_path)
+                if not os.path.exists(media_full_path):
+                    raise FileNotFoundError(f"Media file not found: {media_full_path}")
+
+                model_output = process_single_sample(client, media_full_path, prompt)
+
+            except Exception as e:
+                model_output = f"ERROR: {str(e)}"
+                print(f" Failed to process item {item.get('id', 'N/A')}: {e}")
+
+            end_time = time.time()
+            all_results.append({
+                "id": item.get("id", "N/A"),
+                "prompt": prompt,
+                "model_output": model_output,
+                "ground_truth": ground_truth,
+                "processing_time_seconds": round(end_time - start_time, 2),
+            })
+
+        with open(result_json_path, "w", encoding="utf-8") as f:
+            json.dump(all_results, f, indent=4, ensure_ascii=False)
+        print(f" Task complete. Results saved to: {result_json_path}")
+
+
+def main():
+
+    parser = argparse.ArgumentParser(
+        description=f"Run batch inference on datasets using the Google Gemini '{MODEL_NAME}' model."
+    )
+    parser.add_argument(
+        "--api-key",
+        default=os.getenv("GOOGLE_API_KEY", "GEMINI_API_KEY"),
+        help="Google Gemini API key. Can also be set via the GOOGLE_API_KEY environment variable."
+    )
+    args = parser.parse_args()
+
+    if not args.api_key or args.api_key == "GEMINI_API_KEY":
+        return
+
+    try:
+        genai.configure(api_key=args.api_key)
+        client = genai.GenerativeModel(MODEL_NAME)
+    except Exception as e:
+        print(f"Failed to initialize Gemini client: {e}")
+        return
+
+    dataset_dir = os.getcwd()
+    print(f"Running in directory: {dataset_dir}")
+
+    for level_dir in LEVEL_DIRS:
+        level_path = os.path.join(dataset_dir, level_dir)
+        if not os.path.isdir(level_path):
+            continue
+        
+        task_dirs = sorted([d.path for d in os.scandir(level_path) if d.is_dir()])
+        for task_path in task_dirs:
+            process_task(task_path, client)
+
+
+if __name__ == "__main__":
+    main()

code/test_code/test_gpt41.py

@@ -0,0 +1,230 @@
+import os
+import json
+import argparse
+import base64
+import cv2
+import tempfile
+import subprocess
+import shutil
+import io
+import time
+import glob
+from openai import OpenAI
+from tqdm import tqdm
+from PIL import Image
+
+def get_media_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext in ['.mp4', '.avi', '.mov', '.mkv', '.webm']:
+        return 'video'
+    elif ext in ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp']:
+        return 'image'
+    else:
+        raise ValueError(f"Unsupported file format: {ext}")
+
+def encode_media_to_base64(media_path: str) -> str:
+    try:
+        with open(media_path, "rb") as media_file:
+            return base64.b64encode(media_file.read()).decode('utf-8')
+    except Exception as e:
+        raise IOError(f"Could not read or encode file {media_path}: {e}")
+
+def extract_keyframes(video_path: str, max_frames: int = 20) -> list:
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise ValueError(f"Cannot open video file: {video_path}")
+
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    video_fps = cap.get(cv2.CAP_PROP_FPS)
+    duration = total_frames / video_fps if video_fps > 0 else 0
+
+    if duration <= 20:
+        target_frames = min(max_frames, int(duration))
+        frame_interval = max(1, int(video_fps))
+    else:
+        target_frames = max_frames
+        frame_interval = max(1, int(total_frames / max_frames))
+
+    keyframes = []
+    frame_count = 0
+    sampled_count = 0
+    while sampled_count < target_frames:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        
+        if frame_count % frame_interval == 0:
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            pil_image = Image.fromarray(frame_rgb)
+            keyframes.append(pil_image)
+            sampled_count += 1
+        
+        frame_count += 1
+    
+    cap.release()
+    print(f" Extracted {len(keyframes)} keyframes.")
+    return keyframes
+
+def extract_audio_to_text(video_path: str, client: OpenAI) -> str:
+    temp_audio_path = ""
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_audio:
+            temp_audio_path = temp_audio.name
+
+        command = [
+            'ffmpeg', '-i', video_path, '-vn', '-acodec', 'mp3', 
+            '-ar', '16000', '-ac', '1', '-y', temp_audio_path
+        ]
+        
+        result = subprocess.run(command, capture_output=True, text=True, check=False)
+        if result.returncode != 0:
+            print(f"  [WARN] Ffmpeg audio extraction failed: {result.stderr}")
+            return "Audio extraction failed."
+
+        with open(temp_audio_path, 'rb') as audio_file:
+            transcription = client.audio.transcriptions.create(
+                model="whisper-1",
+                file=audio_file,
+                response_format="text"
+            )
+        return transcription
+
+    except Exception as e:
+        print(f" Audio processing failed: {e}")
+        return "Audio processing failed."
+    finally:
+        if temp_audio_path and os.path.exists(temp_audio_path):
+            os.unlink(temp_audio_path)
+
+def process_dataset(dataset_path: str, client: OpenAI, model_name: str, result_suffix: str):
+
+    result_path = f"{os.path.splitext(dataset_path)[0]}{result_suffix}"
+    
+    if os.path.exists(result_path):
+        print(f"Result file '{os.path.basename(result_path)}' already exists. Skipping.")
+        return
+
+    try:
+        with open(dataset_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, FileNotFoundError) as e:
+        print(f" Could not read or parse JSON file {dataset_path}: {e}")
+        return
+
+    all_results = []
+    base_dir = os.path.dirname(dataset_path)
+
+    for item in tqdm(data, desc=f"Processing items from {os.path.basename(dataset_path)}"):
+        start_time = time.time()
+        model_output = ""
+        try:
+            prompt = item['conversations'][0]['value']
+            ground_truth = item['conversations'][1]['value']
+            media_key = 'image' if 'image' in item else 'video'
+            media_relative_path = item.get(media_key)
+
+            if not media_relative_path:
+                raise ValueError("JSON item is missing 'image' or 'video' key.")
+            
+            media_full_path = os.path.join(base_dir, media_relative_path)
+            if not os.path.exists(media_full_path):
+                raise FileNotFoundError(f"Media file not found: {media_full_path}")
+
+            media_type = get_media_type(media_full_path)
+            clean_prompt = prompt.replace("<image>", "").replace("<video>", "").strip()
+            
+            messages = []
+            if media_type == 'image':
+                base64_media = encode_media_to_base64(media_full_path)
+                messages = [{
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": clean_prompt},
+                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_media}"}}
+                    ]
+                }]
+            else: 
+                print(f"\n      [INFO] Processing video: {os.path.basename(media_full_path)}")
+                keyframes = extract_keyframes(media_full_path)
+                audio_text = extract_audio_to_text(media_full_path, client)
+                
+                enhanced_prompt = f"""Please analyze the following video content:
+
+Original question: {clean_prompt}
+
+Transcribed audio from the video:
+"{audio_text}"
+
+Analyze the keyframes and the audio transcription to provide a comprehensive answer."""
+
+                content = [{"type": "text", "text": enhanced_prompt}]
+                for frame in keyframes:
+                    buffer = io.BytesIO()
+                    frame.save(buffer, format='JPEG', quality=85)
+                    frame_base64 = base64.b64encode(buffer.getvalue()).decode('utf-8')
+                    content.append({
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/jpeg;base64,{frame_base64}"}
+                    })
+                
+                messages = [{"role": "user", "content": content}]
+
+            response = client.chat.completions.create(
+                model=model_name,
+                messages=messages,
+                max_tokens=1024,
+                temperature=0.0
+            )
+            model_output = response.choices[0].message.content
+
+        except Exception as e:
+            model_output = f"ERROR: {str(e)}"
+        
+        end_time = time.time()
+        all_results.append({
+            "id": item.get('id', 'N/A'),
+            "prompt": prompt,
+            "model_output": model_output,
+            "ground_truth": ground_truth,
+            "processing_time_seconds": round(end_time - start_time, 2)
+        })
+
+    # Save results
+    with open(result_path, 'w', encoding='utf-8') as f:
+        json.dump(all_results, f, indent=4, ensure_ascii=False)
+    print(f" Processing complete. Results saved to: {result_path}")
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Run inference on a dataset using a specified GPT model."
+    )
+    parser.add_argument("--api-key", required=True, help="OpenAI API key.")
+    parser.add_argument("--model-name", default="gpt-4o", help="The model name to use (e.g., 'gpt-4o').")
+    parser.add_argument("--result-suffix", default="_result.json", help="Suffix for generated result files.")
+    
+    args = parser.parse_args()
+
+    try:
+        client = OpenAI(api_key=args.api_key)
+    except Exception as e:
+        print(f"Failed to initialize OpenAI client: {e}")
+        return
+
+    if shutil.which('ffmpeg') is None:
+        print("[ffmpeg not found. Video audio extraction will be unavailable.")
+    source_files = [
+        f for f in glob.glob('*.json') 
+        if not f.endswith(args.result_suffix)
+    ]
+
+    if not source_files:
+        print("\n No source JSON files.")
+    else:
+        print(f"\nFound {len(source_files)} dataset to process.")
+
+    for dataset_file in sorted(source_files):
+        process_dataset(dataset_file, client, args.model_name, args.result_suffix)
+
+
+if __name__ == "__main__":
+    main()

code/test_code/test_gpt4o.py

@@ -0,0 +1,246 @@
+import os
+import json
+import argparse
+import base64
+import cv2
+import tempfile
+import subprocess
+import shutil
+import io
+import time
+import glob
+from openai import OpenAI
+from tqdm import tqdm
+from PIL import Image
+
+GENERIC_RESULT_PATTERN = "_result.json"
+
+def get_media_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext in ['.mp4', '.avi', '.mov', '.mkv', '.webm']:
+        return 'video'
+    elif ext in ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp']:
+        return 'image'
+    else:
+        raise ValueError(f"Unsupported file format: {ext}")
+
+def encode_media_to_base64(media_path: str) -> str:
+    try:
+        with open(media_path, "rb") as media_file:
+            return base64.b64encode(media_file.read()).decode('utf-8')
+    except FileNotFoundError:
+        raise
+    except Exception as e:
+        raise IOError(f"Could not read or encode file {media_path}: {e}")
+
+def extract_keyframes(video_path: str, max_frames: int = 20) -> list:
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise ValueError(f"Cannot open video file: {video_path}")
+
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    video_fps = cap.get(cv2.CAP_PROP_FPS)
+    duration = total_frames / video_fps if video_fps > 0 else 0
+
+    if duration <= 20:
+        target_frames = min(max_frames, int(duration))
+        frame_interval = max(1, int(video_fps))  # 1 frame per second
+    else:
+        target_frames = max_frames
+        frame_interval = max(1, int(total_frames / max_frames))
+
+
+    keyframes = []
+    frame_count = 0
+    sampled_count = 0
+
+    while cap.isOpened() and sampled_count < target_frames:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        if frame_count % frame_interval == 0:
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            pil_image = Image.fromarray(frame_rgb)
+            keyframes.append(pil_image)
+            sampled_count += 1
+
+        frame_count += 1
+
+    cap.release()
+    return keyframes
+
+def extract_audio_to_text(video_path: str, client: OpenAI) -> str:
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_audio:
+            temp_audio_path = temp_audio.name
+        command = [
+            'ffmpeg', '-i', video_path, '-vn', '-acodec', 'mp3',
+            '-ar', '16000', '-ac', '1', '-y', temp_audio_path
+        ]
+        result = subprocess.run(command, capture_output=True, text=True)
+
+        if result.returncode != 0:
+            print(f"FFmpeg audio extraction failed: {result.stderr}")
+            os.unlink(temp_audio_path)
+            return "Audio extraction failed."
+        with open(temp_audio_path, 'rb') as audio_file:
+
+            transcription = client.audio.transcriptions.create(
+                model="whisper-1",
+                file=(os.path.basename(temp_audio_path), audio_file.read()),
+                response_format="text"
+            )
+        
+        os.unlink(temp_audio_path)
+        return transcription
+
+    except Exception as e:
+        print(f"Audio processing failed: {e}")
+ 
+        if 'temp_audio_path' in locals() and os.path.exists(temp_audio_path):
+            os.unlink(temp_audio_path)
+        return "Audio processing failed."
+
+def process_single_sample(client: OpenAI, media_full_path: str, prompt_text: str) -> str:
+
+    clean_prompt = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+    media_type = get_media_type(media_full_path)
+
+    try:
+        content = [{"type": "text", "text": clean_prompt}]
+
+        if media_type == 'image':
+            base64_media = encode_media_to_base64(media_full_path)
+            content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_media}"}})
+        
+        elif media_type == 'video':
+            key_frames = extract_keyframes(media_full_path)
+            audio_text = ""
+            if shutil.which('ffmpeg'):
+                try:
+                    audio_text = extract_audio_to_text(media_full_path, client)
+                except Exception as audio_e:
+                    print(f" Could not extract audio from video: {audio_e}")
+            else:
+                print(" ffmpeg not found, skipping audio extraction.")
+
+            for frame in key_frames:
+                with io.BytesIO() as buffer:
+                    frame.save(buffer, format='JPEG', quality=85)
+                    frame_base64 = base64.b64encode(buffer.getvalue()).decode('utf-8')
+                    content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{frame_base64}"}})
+            
+            if audio_text:
+                full_prompt_with_audio = f"{clean_prompt}\n\n--- Video Audio Transcription ---\n{audio_text}"
+                content[0] = {"type": "text", "text": full_prompt_with_audio}
+
+        messages = [{"role": "user", "content": content}]
+        response = client.chat.completions.create(
+            model="gpt-4o",
+            messages=messages,
+            max_tokens=1024,
+            temperature=0,
+            timeout=120.0
+        )
+        return response.choices[0].message.content
+
+    except Exception as e:
+        try:
+            messages = [{"role": "user", "content": clean_prompt}]
+            response = client.chat.completions.create(
+                model="gpt-4o",
+                messages=messages,
+                max_tokens=1024,
+                temperature=0,
+                timeout=60.0
+            )
+            return response.choices[0].message.content
+        except Exception as fallback_e:
+            print(f"  Text-only fallback also failed: {fallback_e}")
+            return f"ERROR: Fallback failed. Details: {fallback_e}"
+
+def process_dataset_file(dataset_path: str, client: OpenAI, result_suffix: str):
+
+    result_path = f"{os.path.splitext(dataset_path)[0]}{result_suffix}"
+    if os.path.exists(result_path):
+        print(f"Result file '{os.path.basename(result_path)}' already exists, skipping.")
+        return
+
+    try:
+        with open(dataset_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, FileNotFoundError) as e:
+        print(f" Could not read or parse JSON file {dataset_path}: {e}")
+        return
+
+    all_results = []
+    base_dir = os.path.dirname(dataset_path)
+
+    for item in tqdm(data, desc=f"  Processing {os.path.basename(dataset_path)}"):
+        start_time = time.time()
+        model_output = ""
+        try:
+            prompt = item['conversations'][0]['value']
+            ground_truth = item['conversations'][1]['value']
+            media_path_key = 'image' if 'image' in item else 'video'
+            media_relative_path = item.get(media_path_key)
+
+            if not media_relative_path:
+                raise ValueError("JSON item is missing 'image' or 'video' key.")
+            
+            media_full_path = os.path.join(base_dir, media_relative_path)
+            if not os.path.exists(media_full_path):
+                raise FileNotFoundError(f"Media file not found: {media_full_path}")
+            
+            model_output = process_single_sample(client, media_full_path, prompt)
+            
+        except Exception as e:
+            model_output = f"ERROR: {str(e)}"
+            print(f" Failed to process item {item.get('id', 'N/A')}: {e}")
+        
+        end_time = time.time()
+        all_results.append({
+            "id": item.get('id', 'N/A'), 
+            "prompt": prompt, 
+            "model_output": model_output, 
+            "ground_truth": ground_truth, 
+            "processing_time_seconds": round(end_time - start_time, 2)
+        })
+
+    with open(result_path, 'w', encoding='utf-8') as f:
+        json.dump(all_results, f, indent=4, ensure_ascii=False)
+    print(f" Processing complete. Results saved to: {result_path}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Run inference on a dataset using GPT-4o with multimodal capabilities.")
+    parser.add_argument("--api-key", required=True, help="OpenAI API key.")
+    parser.add_argument("--model-name", default="gpt-4o", help="The model to use (default: gpt-4o).")
+    parser.add_argument("--result-suffix", default="_gpt4o_result.json", help="Suffix for the output result files.")
+    
+    args = parser.parse_args()
+
+    try:
+        client = OpenAI(api_key=args.api_key)
+    except Exception as e:
+        print(f"[Could not initialize OpenAI client: {e}")
+        return
+
+    if not shutil.which('ffmpeg'):
+        print("ffmpeg not found. Video audio extraction will be disabled.")
+
+    source_json_files = [
+        f for f in glob.glob('*.json') 
+        if not f.endswith(args.result_suffix) and GENERIC_RESULT_PATTERN not in f
+    ]
+
+    if not source_json_files:
+        print("\n No source JSON files.")
+    else:
+        print(f"\nFound {len(source_json_files)} dataset(s) to process.")
+
+    for json_file in sorted(source_json_files):
+        process_dataset_file(json_file, client, args.result_suffix)
+            
+if __name__ == "__main__":
+    main()

code/test_code/test_humanomni.py

@@ -0,0 +1,241 @@
+import os
+import json
+import sys
+import time
+import traceback
+from typing import Dict, Any
+
+from tqdm import tqdm
+import torch
+import torch.multiprocessing as mp
+from transformers import BertTokenizer
+
+worker_model_objects: Dict[str, Any] = {}
+
+def init_worker(model_path: str, bert_path: str, humanomni_project_path: str, device: str):
+    global worker_model_objects
+    
+    if humanomni_project_path and humanomni_project_path not in sys.path:
+        sys.path.append(humanomni_project_path)
+
+    try:
+        from humanomni import model_init, mm_infer
+        from humanomni.utils import disable_torch_init
+    except ImportError:
+        print(f"[Worker PID: {os.getpid()}] ERROR: Failed to import HumanOmni. Ensure the humanomni_path is set correctly.", file=sys.stderr)
+        return
+
+    disable_torch_init()
+    
+    model, processor, tokenizer = model_init(model_path, device=device)
+    bert_tokenizer = BertTokenizer.from_pretrained(bert_path)
+    
+    worker_model_objects = {
+        "model": model,
+        "processor": processor,
+        "tokenizer": tokenizer,
+        "bert_tokenizer": bert_tokenizer,
+        "mm_infer": mm_infer,
+    }
+
+def get_media_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext in ['.mp4', '.avi', '.mov', '.mkv', '.webm']:
+        return 'video'
+    elif ext in ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp']:
+        return 'image'
+    else:
+        return 'unknown'
+
+def process_single_sample(media_full_path: str, prompt_text: str) -> str:
+    global worker_model_objects
+    try:
+        model = worker_model_objects['model']
+        processor = worker_model_objects['processor']
+        tokenizer = worker_model_objects['tokenizer']
+        bert_tokenizer = worker_model_objects['bert_tokenizer']
+        mm_infer = worker_model_objects['mm_infer']
+        
+        media_type = get_media_type(media_full_path)
+        if media_type == 'unknown':
+            raise ValueError(f"Unsupported media type for file: {media_full_path}")
+        
+        clean_prompt = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+
+        media_tensor, audio_tensor, modal_str = None, None, ""
+
+        if media_type == 'video':
+            media_tensor = processor['video'](media_full_path)
+            audio_tensor = processor['audio'](media_full_path)[0]
+            modal_str = 'video_audio'
+        elif media_type == 'image':
+            media_tensor = processor['image'](media_full_path)
+            if media_tensor.ndim == 3:
+                media_tensor = media_tensor.unsqueeze(0)
+            audio_tensor = None
+            modal_str = 'image'
+
+        output = mm_infer(
+            media_tensor,
+            instruct=clean_prompt,
+            model=model,
+            tokenizer=tokenizer,
+            modal=modal_str,
+            question=clean_prompt,
+            bert_tokeni=bert_tokenizer,
+            do_sample=False,
+            audio=audio_tensor
+        )
+        return output
+    except Exception as e:
+        return f"ERROR: {e}\n{traceback.format_exc()}"
+
+def text_only_fallback(prompt_text: str) -> str:
+    global worker_model_objects
+    try:
+        model = worker_model_objects['model']
+        tokenizer = worker_model_objects['tokenizer']
+        
+        clean_prompt = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+        inputs = tokenizer(clean_prompt, return_tensors="pt").to(model.device)
+        
+        output_ids = model.generate(
+            input_ids=inputs.input_ids,
+            attention_mask=inputs.attention_mask,
+            max_new_tokens=512,
+            do_sample=False
+        )
+        
+        response = tokenizer.decode(output_ids[0], skip_special_tokens=True)
+        
+        if response.startswith(clean_prompt):
+             return response[len(clean_prompt):].strip()
+        else:
+             return response
+
+    except Exception as e:
+        return f"ERROR in text-only fallback: {str(e)}"
+
+def run_inference_task(media_full_path, prompt_text):
+    if not worker_model_objects: return "ERROR: Worker model not initialized."
+    return process_single_sample(media_full_path, prompt_text)
+
+def run_fallback_task(prompt_text):
+    if not worker_model_objects: return "ERROR: Worker model not initialized."
+    return text_only_fallback(prompt_text)
+
+def main():
+    class Config:
+        model_path = "example/model/HumanOmni_7B"
+        
+        bert_model_path = "example/model/bert-base-uncased"
+        
+        humanomni_path = "example/moodel"
+        
+        input_dir = "example"
+
+        device = "cuda:7"
+        
+        result_suffix = "_humanomni_result.json"
+        
+        timeout = 60
+    
+    config = Config()
+    
+    os.environ['TRANSFORMERS_OFFLINE'] = '1'
+    
+    worker_device = config.device
+    if "cuda" in config.device:
+        gpu_id = config.device.split(':')[-1]
+        os.environ['CUDA_VISIBLE_DEVICES'] = gpu_id
+        worker_device = "cuda:0"
+
+    init_args = (config.model_path, config.bert_model_path, config.humanomni_path, worker_device)
+    pool_ref = [mp.Pool(processes=1, initializer=init_worker, initargs=init_args)]
+
+    try:
+        source_json_files = [
+            f for f in os.listdir(config.input_dir) 
+            if f.endswith(".json") and not f.endswith(config.result_suffix)
+        ]
+
+        if not source_json_files:
+            print("No source JSON files.")
+            return
+
+        for json_filename in source_json_files:
+            dataset_json_path = os.path.join(config.input_dir, json_filename)
+            result_json_path = os.path.join(config.input_dir, f"{os.path.splitext(json_filename)[0]}{config.result_suffix}")
+            
+            if os.path.exists(result_json_path):
+                continue
+
+            try:
+                with open(dataset_json_path, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+            except (json.JSONDecodeError, FileNotFoundError) as e:
+                continue
+
+            all_results = []
+            for item in tqdm(data, desc=f"  Inferring on {json_filename}", unit="item"):
+                start_time = time.time()
+                model_output, prompt, ground_truth = "", "", ""
+                
+                try:
+                    prompt = item["conversations"][0]["value"]
+                    ground_truth = item["conversations"][1]["value"]
+                    media_relative_path = item.get('image') or item.get('video')
+
+                    if not media_relative_path:
+                        model_output = pool_ref[0].apply(run_fallback_task, args=(prompt,))
+                    else:
+                        media_full_path = os.path.join(config.input_dir, media_relative_path)
+                        if not os.path.exists(media_full_path):
+                            model_output = pool_ref[0].apply(run_fallback_task, args=(prompt,))
+                        else:
+                            media_type = get_media_type(media_full_path)
+                            
+                            if media_type == 'image':
+                                model_output = pool_ref[0].apply(run_fallback_task, args=(prompt,))
+                            elif media_type == 'video':
+                                async_result = pool_ref[0].apply_async(run_inference_task, args=(media_full_path, prompt))
+                                try:
+                                    model_output = async_result.get(timeout=config.timeout)
+                                except (mp.TimeoutError, Exception) as e:
+                                    print(f"\n Worker task failed for item {item.get('id', 'N/A')}. Reason: {type(e).__name__}. Restarting and falling back.", file=sys.stderr)
+                                    pool_ref[0].terminate()
+                                    pool_ref[0].join()
+                                    pool_ref[0] = mp.Pool(processes=1, initializer=init_worker, initargs=init_args)
+                                    model_output = pool_ref[0].apply(run_fallback_task, args=(prompt,))
+                            else: # Unknown media type
+                                model_output = pool_ref[0].apply(run_fallback_task, args=(prompt,))
+
+                except Exception as e:
+                    model_output = f"ERROR: An unexpected error occurred in the main loop: {e}"
+
+                all_results.append({
+                    "id": item.get("id", "N/A"),
+                    "prompt": prompt,
+                    "model_output": model_output,
+                    "ground_truth": ground_truth,
+                    "processing_time_seconds": round(time.time() - start_time, 2),
+                })
+
+            with open(result_json_path, "w", encoding="utf-8") as f:
+                json.dump(all_results, f, indent=4, ensure_ascii=False)
+            print(f"Results saved to: {result_json_path}")
+
+    finally:
+        if pool_ref and pool_ref[0]:
+            pool_ref[0].close()
+            pool_ref[0].join()
+
+if __name__ == "__main__":
+    if torch.cuda.is_available():
+        try:
+            mp.set_start_method('spawn', force=True)
+            print("Multiprocessing start method set to 'spawn'.")
+        except RuntimeError:
+            pass
+        
+    main()

code/test_code/test_internvl.py

@@ -0,0 +1,253 @@
+import os
+import json
+import argparse
+from tqdm import tqdm
+import time
+from PIL import Image
+import numpy as np
+import torch
+import torchvision.transforms as T
+from decord import VideoReader, cpu
+from torchvision.transforms.functional import InterpolationMode
+from transformers import AutoModel, AutoTokenizer
+
+
+IMAGENET_MEAN = (0.485, 0.456, 0.406)
+IMAGENET_STD = (0.229, 0.224, 0.225)
+
+DEFAULT_IMAGE_SIZE = 448
+DEFAULT_VIDEO_SEGMENTS = 8
+DEFAULT_MAX_PATCHES_PER_FRAME = 1  
+DEFAULT_MAX_PATCHES_PER_IMAGE = 6  
+
+def build_transform(input_size):
+    return T.Compose([
+        T.Lambda(lambda img: img.convert('RGB') if img.mode != 'RGB' else img),
+        T.Resize((input_size, input_size), interpolation=InterpolationMode.BICUBIC),
+        T.ToTensor(),
+        T.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD)
+    ])
+
+def find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size):
+    best_ratio_diff = float('inf')
+    best_ratio = (1, 1)
+    area = width * height
+    for ratio in target_ratios:
+        target_aspect_ratio = ratio[0] / ratio[1]
+        ratio_diff = abs(aspect_ratio - target_aspect_ratio)
+        if ratio_diff < best_ratio_diff:
+            best_ratio_diff = ratio_diff
+            best_ratio = ratio
+        elif ratio_diff == best_ratio_diff:
+            if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]:
+                best_ratio = ratio
+    return best_ratio
+
+def dynamic_preprocess(image, min_num=1, max_num=12, image_size=448, use_thumbnail=False):
+    orig_width, orig_height = image.size
+    aspect_ratio = orig_width / orig_height
+
+    target_ratios = set(
+        (i, j)
+        for n in range(min_num, max_num + 1)
+        for i in range(1, n + 1)
+        for j in range(1, n + 1)
+        if i * j <= max_num and i * j >= min_num
+    )
+    target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])
+    target_aspect_ratio = find_closest_aspect_ratio(
+        aspect_ratio, target_ratios, orig_width, orig_height, image_size
+    )
+
+    target_width = image_size * target_aspect_ratio[0]
+    target_height = image_size * target_aspect_ratio[1]
+    blocks = target_aspect_ratio[0] * target_aspect_ratio[1]
+
+    resized_img = image.resize((target_width, target_height))
+    processed_images = []
+    for i in range(blocks):
+        box = (
+            (i % (target_width // image_size)) * image_size,
+            (i // (target_width // image_size)) * image_size,
+            ((i % (target_width // image_size)) + 1) * image_size,
+            ((i // (target_width // image_size)) + 1) * image_size
+        )
+        processed_images.append(resized_img.crop(box))
+    assert len(processed_images) == blocks
+    if use_thumbnail and len(processed_images) != 1:
+        processed_images.append(image.resize((image_size, image_size)))
+    return processed_images
+
+def get_frame_indices(bound, fps, max_frame, first_idx=0, num_segments=32):
+    if bound:
+        start, end = bound[0], bound[1]
+    else:
+        start, end = -100000, 100000
+    start_idx = max(first_idx, round(start * fps))
+    end_idx = min(round(end * fps), max_frame)
+    seg_size = float(end_idx - start_idx) / num_segments
+    frame_indices = np.array([
+        int(start_idx + (seg_size / 2) + np.round(seg_size * idx))
+        for idx in range(num_segments)
+    ])
+    return frame_indices
+
+def load_video(video_path, bound=None, input_size=448, max_num=1, num_segments=32):
+    vr = VideoReader(video_path, ctx=cpu(0), num_threads=1)
+    max_frame = len(vr) - 1
+    fps = float(vr.get_avg_fps())
+
+    pixel_values_list, num_patches_list = [], []
+    transform = build_transform(input_size=input_size)
+    frame_indices = get_frame_indices(bound, fps, max_frame, first_idx=0, num_segments=num_segments)
+    
+    valid_indices = [i for i in frame_indices if i < len(vr)]
+    if not valid_indices:
+        raise ValueError(f"No valid frames could be sampled from video {video_path}.")
+
+    frames = vr.get_batch(valid_indices).asnumpy()
+
+    for frame_np in frames:
+        img = Image.fromarray(frame_np).convert('RGB')
+        tiles = dynamic_preprocess(img, image_size=input_size, use_thumbnail=True, max_num=max_num)
+        pixel_values = torch.stack([transform(tile) for tile in tiles])
+        num_patches_list.append(pixel_values.shape[0])
+        pixel_values_list.append(pixel_values)
+        
+    pixel_values = torch.cat(pixel_values_list)
+    return pixel_values, num_patches_list
+
+def get_media_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext in ['.mp4', '.avi', '.mov', '.mkv', '.webm']:
+        return 'video'
+    elif ext in ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp']:
+        return 'image'
+    else:
+        raise ValueError(f"Unsupported file format: {ext} in file {file_path}")
+
+def process_file(dataset_json_path: str, model, tokenizer, result_suffix: str):
+    json_filename = os.path.basename(dataset_json_path)
+    result_json_path = os.path.join(
+        os.path.dirname(dataset_json_path),
+        f"{os.path.splitext(json_filename)[0]}{result_suffix}"
+    )
+
+    if os.path.exists(result_json_path):
+        print(f"Result file '{os.path.basename(result_json_path)}' already exists. Skipping.")
+        return
+
+    try:
+        with open(dataset_json_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, FileNotFoundError) as e:
+        print(f"Failed to read or parse JSON file {dataset_json_path}: {e}")
+        return
+
+    generation_config = dict(num_beams=1, max_new_tokens=2048, do_sample=False)
+    device = next(model.parameters()).device
+    all_results = []
+    
+    base_path = os.path.dirname(dataset_json_path)
+
+    for item in tqdm(data, desc=f"  Inferring on {json_filename}"):
+        start_time = time.time()
+        model_output = "N/A"
+        
+        try:
+            prompt_text = item['conversations'][0]['value']
+            ground_truth = item['conversations'][1]['value']
+            media_path_key = 'image' if 'image' in item else 'video'
+            media_relative_path = item.get(media_path_key)
+            if not media_relative_path:
+                raise ValueError("JSON item is missing 'image' or 'video' key.")
+            
+            media_full_path = os.path.join(base_path, media_relative_path)
+            if not os.path.exists(media_full_path):
+                raise FileNotFoundError(f"Media file not found: {media_full_path}")
+            
+            media_type = get_media_type(media_full_path)
+            clean_prompt = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+
+            pixel_values, num_patches_list, question = None, None, None
+
+            if media_type == 'image':
+                image = Image.open(media_full_path).convert('RGB')
+                transform = build_transform(input_size=DEFAULT_IMAGE_SIZE)
+                patches = dynamic_preprocess(image, image_size=DEFAULT_IMAGE_SIZE, use_thumbnail=True, max_num=DEFAULT_MAX_PATCHES_PER_IMAGE)
+                pixel_values = torch.stack([transform(p) for p in patches])
+                num_patches_list = [len(patches)]
+                question = f"<image>\n{clean_prompt}"
+            
+            elif media_type == 'video':
+                pixel_values, num_patches_list = load_video(
+                    media_full_path,
+                    num_segments=DEFAULT_VIDEO_SEGMENTS,
+                    max_num=DEFAULT_MAX_PATCHES_PER_FRAME,
+                    input_size=DEFAULT_IMAGE_SIZE
+                )
+                video_prefix = ''.join([f'Frame{i+1}: <image>\n' for i in range(len(num_patches_list))])
+                question = f"{video_prefix}{clean_prompt}"
+
+            pixel_values = pixel_values.to(torch.bfloat16).to(device)
+
+            response = model.chat(
+                tokenizer=tokenizer,
+                pixel_values=pixel_values,
+                question=question,
+                generation_config=generation_config,
+                num_patches_list=num_patches_list,
+                history=None
+            )
+            model_output = response.strip()
+
+        except Exception as e:
+            model_output = f"ERROR: {str(e)}"
+        
+        end_time = time.time()
+        all_results.append({
+            "id": item.get('id', 'N/A'),
+            "prompt": prompt_text,
+            "model_output": model_output,
+            "ground_truth": ground_truth,
+            "processing_time_seconds": round(end_time - start_time, 2)
+        })
+
+    with open(result_json_path, 'w', encoding='utf-8') as f:
+        json.dump(all_results, f, indent=4, ensure_ascii=False)
+
+def main():
+    parser = argparse.ArgumentParser(description="Batch inference with InternVL model on local JSON datasets.")
+    parser.add_argument("--model-path", required=True, help="Full path to the local model directory.")
+    parser.add_argument("--result-suffix", default="_result.json", help="Suffix for the generated result files.")
+    args = parser.parse_args()
+
+    try:
+        torch.backends.cuda.matmul.allow_tf32 = True
+        model = AutoModel.from_pretrained(
+            args.model_path,
+            torch_dtype=torch.bfloat16,
+            low_cpu_mem_usage=True,
+            trust_remote_code=True,
+            device_map="auto"
+        ).eval()
+        tokenizer = AutoTokenizer.from_pretrained(args.model_path, trust_remote_code=True, use_fast=False)
+    except Exception as e:
+        print(f"Failed to load the model from {args.model_path}. Error: {e}")
+        return
+    
+    current_dir = os.getcwd()
+    source_json_files = [
+        f for f in os.listdir(current_dir)
+        if f.endswith('.json') and not f.endswith(args.result_suffix)
+    ]
+
+    if not source_json_files:
+        print(f"\nNo source JSON files: {current_dir}")
+    else:
+        for json_filename in sorted(source_json_files):
+            process_file(os.path.join(current_dir, json_filename), model, tokenizer, args.result_suffix)
+
+
+if __name__ == "__main__":
+    main()

code/test_code/test_llavanext.py

@@ -0,0 +1,158 @@
+import os
+import json
+import argparse
+from tqdm import tqdm
+import time
+from PIL import Image
+import numpy as np
+import av
+import torch
+from transformers import LlavaNextVideoProcessor, LlavaNextVideoForConditionalGeneration
+
+def get_media_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext in ['.mp4', '.avi', '.mov', '.mkv', '.webm']:
+        return 'video'
+    elif ext in ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp']:
+        return 'image'
+    else:
+        raise ValueError(f"Unsupported file format: {ext} in file {file_path}")
+
+def read_video_pyav(container, indices):
+    frames = []
+    container.seek(0)
+    start_index = indices[0]
+    end_index = indices[-1]
+    for i, frame in enumerate(container.decode(video=0)):
+        if i > end_index:
+            break
+        if i >= start_index and i in indices:
+            frames.append(frame)
+    if not frames:
+        raise ValueError("Could not decode specified frames from the video.")
+    return np.stack([x.to_ndarray(format="rgb24") for x in frames])
+
+def process_file(dataset_json_path: str, model, processor, result_suffix: str, device: str):
+    json_filename = os.path.basename(dataset_json_path)
+    result_json_path = os.path.join(
+        os.path.dirname(dataset_json_path),
+        f"{os.path.splitext(json_filename)[0]}{result_suffix}"
+    )
+
+    if os.path.exists(result_json_path):
+        print(f"[INFO] Result file '{os.path.basename(result_json_path)}' already exists. Skipping.")
+        return
+
+    try:
+        with open(dataset_json_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, FileNotFoundError) as e:
+        print(f"Failed to read or parse JSON file {dataset_json_path}: {e}")
+        return
+
+    all_results = []
+    base_path = os.path.dirname(dataset_json_path)
+
+    for item in tqdm(data, desc=f"  Inferring on {json_filename}"):
+        start_time = time.time()
+        model_output = "N/A"
+        
+        try:
+            prompt_text = item['conversations'][0]['value']
+            ground_truth = item['conversations'][1]['value']
+            media_path_key = 'image' if 'image' in item else 'video'
+            media_relative_path = item.get(media_path_key)
+            if not media_relative_path:
+                raise ValueError("JSON item is missing 'image' or 'video' key.")
+            
+            media_full_path = os.path.join(base_path, media_relative_path)
+            if not os.path.exists(media_full_path):
+                raise FileNotFoundError(f"Media file not found: {media_full_path}")
+            
+            media_type = get_media_type(media_full_path)
+            clean_prompt = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+
+            conversation = [
+                {"role": "user", "content": [
+                    {"type": "text", "text": clean_prompt},
+                    {"type": media_type},
+                ]},
+            ]
+            prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)
+
+            if media_type == 'image':
+                raw_image = Image.open(media_full_path)
+                inputs = processor(text=prompt, images=raw_image, return_tensors='pt').to(device, torch.float16)
+            
+            elif media_type == 'video':
+                container = av.open(media_full_path)
+                total_frames = container.streams.video[0].frames
+                indices = np.arange(0, total_frames, total_frames / 8).astype(int)
+                clip = read_video_pyav(container, indices)
+                inputs = processor(text=prompt, videos=clip, return_tensors="pt").to(device, torch.float16)
+
+            output = model.generate(**inputs, max_new_tokens=1024, do_sample=False)
+            decoded_output = processor.batch_decode(output, skip_special_tokens=True)[0].strip()
+            
+            assistant_marker = "ASSISTANT:"
+            if assistant_marker in decoded_output:
+                model_output = decoded_output.split(assistant_marker)[-1].strip()
+            else:
+                model_output = decoded_output
+
+        except Exception as e:
+            model_output = f"ERROR: {str(e)}"
+        
+        end_time = time.time()
+        all_results.append({
+            "id": item.get('id', 'N/A'), 
+            "prompt": prompt_text, 
+            "model_output": model_output, 
+            "ground_truth": ground_truth, 
+            "processing_time_seconds": round(end_time - start_time, 2)
+        })
+
+    with open(result_json_path, 'w', encoding='utf-8') as f:
+        json.dump(all_results, f, indent=4, ensure_ascii=False)
+    print(f" Processing complete. Results saved to: {result_json_path}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Batch inference with a local LLaVA-NeXT-Video model.")
+    parser.add_argument("--model-path", required=True, help="Full path to the local model directory.")
+    parser.add_argument("--result-suffix", required=True, help="Suffix for the generated result files (e.g., '_result.json').")
+    parser.add_argument("--device", default="cuda:0", help="Device to run the model on (e.g., 'cuda:0' or 'cpu').")
+    args = parser.parse_args()
+
+    try:
+        model = LlavaNextVideoForConditionalGeneration.from_pretrained(
+            args.model_path, 
+            torch_dtype=torch.float16, 
+            low_cpu_mem_usage=True,
+        ).to(args.device)
+        processor = LlavaNextVideoProcessor.from_pretrained(args.model_path)
+        print(" Model and processor loaded successfully.")
+    except Exception as e:
+        print(f"Failed to load model from '{args.model_path}'. Error: {e}")
+        return
+
+    current_dir = os.getcwd()
+    source_json_files = [
+        f for f in os.listdir(current_dir) 
+        if f.endswith('.json') and not f.endswith(args.result_suffix)
+    ]
+
+    if not source_json_files:
+        print(f"\n[INFO] No source JSON files: {current_dir}")
+    else:
+        for json_filename in sorted(source_json_files):
+            process_file(
+                dataset_json_path=os.path.join(current_dir, json_filename),
+                model=model,
+                processor=processor,
+                result_suffix=args.result_suffix,
+                device=args.device
+            )
+            
+
+if __name__ == "__main__":
+    main()

code/test_code/test_llavaonevison.py

@@ -0,0 +1,126 @@
+import os
+import json
+import argparse
+import base64
+from openai import OpenAI
+from tqdm import tqdm
+import time
+
+
+GENERIC_RESULT_PATTERN = "_result.json"
+
+def get_media_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext in ['.mp4', '.avi', '.mov', '.mkv', '.webm']:
+        return 'video'
+    elif ext in ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp']:
+        return 'image'
+    else:
+        raise ValueError(f"Unsupported file format: {ext}")
+
+def encode_media_to_base64(media_path: str) -> str:
+    try:
+        with open(media_path, "rb") as media_file:
+            return base64.b64encode(media_file.read()).decode('utf-8')
+    except FileNotFoundError:
+        raise
+    except Exception as e:
+        raise IOError(f"Failed to read or encode file {media_path}: {e}")
+
+def process_file(dataset_json_path: str, client: OpenAI, model_name: str, result_suffix: str):
+    json_filename = os.path.basename(dataset_json_path)
+    result_json_path = os.path.join(
+        os.path.dirname(dataset_json_path),
+        f"{os.path.splitext(json_filename)[0]}{result_suffix}"
+    )
+
+    if os.path.exists(result_json_path):
+        print(f"Result file '{os.path.basename(result_json_path)}' already exists. Skipping.")
+        return
+
+    try:
+        with open(dataset_json_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, FileNotFoundError) as e:
+        print(f"Failed to read or parse JSON file {dataset_json_path}: {e}")
+        return
+
+    all_results = []
+    base_path = os.path.dirname(dataset_json_path)
+
+    for item in tqdm(data, desc=f"  Querying API for {json_filename}"):
+        start_time = time.time()
+        model_output = "N/A"
+        try:
+            prompt = item['conversations'][0]['value']
+            ground_truth = item['conversations'][1]['value']
+            media_path_key = 'image' if 'image' in item else 'video'
+            media_relative_path = item.get(media_path_key)
+            if not media_relative_path:
+                raise ValueError("JSON item is missing 'image' or 'video' key.")
+            
+            media_full_path = os.path.join(base_path, media_relative_path)
+            if not os.path.exists(media_full_path):
+                raise FileNotFoundError(f"Media file not found: {media_full_path}")
+            
+            media_type = get_media_type(media_full_path)
+            media_base64 = encode_media_to_base64(media_full_path)
+            clean_prompt = prompt.replace("<image>", "").replace("<video>", "").strip()
+            
+            if media_type == 'image':
+                messages = [{"role": "user", "content": [{"type": "text", "text": clean_prompt}, {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{media_base64}"}}]}]
+            else: 
+                messages = [{"role": "user", "content": [{"type": "text", "text": clean_prompt}, {"type": "video_url", "video_url": {"url": f"data:video/mp4;base64,{media_base64}"}}]}]
+
+            response = client.chat.completions.create(model=model_name, messages=messages, max_tokens=1024, temperature=0.0)
+            model_output = response.choices[0].message.content
+
+        except Exception as e:
+            model_output = f"ERROR: {str(e)}"
+        
+        end_time = time.time()
+        all_results.append({
+            "id": item.get('id', 'N/A'),
+            "prompt": prompt,
+            "model_output": model_output,
+            "ground_truth": ground_truth,
+            "processing_time_seconds": round(end_time - start_time, 2)
+        })
+
+    with open(result_json_path, 'w', encoding='utf-8') as f:
+        json.dump(all_results, f, indent=4, ensure_ascii=False)
+    print(f"  [SUCCESS] Processing complete. Results saved to: {result_json_path}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Batch inference for multimodal models using an OpenAI-compatible API.")
+    parser.add_argument("--model-endpoint", default="http://localhost:8004/v1", help="The API endpoint of the model server.")
+    parser.add_argument("--model-name", default="llavaonevision7b", help="The name of the model to use.")
+    parser.add_argument("--result-suffix", default="_result.json", help="Suffix for the generated result files.")
+    args = parser.parse_args()
+
+    try:
+        client = OpenAI(base_url=args.model_endpoint, api_key="EMPTY")
+    except Exception as e:
+        print(f"Could not initialize OpenAI client: {e}")
+        return
+
+    current_dir = os.getcwd()
+    source_json_files = [
+        f for f in os.listdir(current_dir) 
+        if f.endswith('.json') and not f.endswith(GENERIC_RESULT_PATTERN)
+    ]
+
+    if not source_json_files:
+        print(f"\nNo source JSON files: {current_dir}")
+    else:
+        for json_filename in sorted(source_json_files):
+            process_file(
+                dataset_json_path=os.path.join(current_dir, json_filename),
+                client=client,
+                model_name=args.model_name,
+                result_suffix=args.result_suffix
+            )
+            
+
+if __name__ == "__main__":
+    main()

code/test_code/test_minicpm.py

@@ -0,0 +1,123 @@
+import os
+import json
+import base64
+from openai import OpenAI
+from tqdm import tqdm
+import time
+import sys
+
+# --- Configuration ---
+MODEL_ENDPOINT = "http://localhost:8000/v1"
+MODEL_NAME = "minicpm" 
+RESULT_SUFFIX = "_minicpm_result.json"   
+
+GENERIC_RESULT_PATTERN = "_result.json"
+
+def get_media_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext in ['.mp4', '.avi', '.mov', '.mkv', '.webm']:
+        return 'video'
+    elif ext in ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp']:
+        return 'image'
+    else:
+        raise ValueError(f"Unsupported file format: {ext}")
+
+def encode_media_to_base64(media_path: str) -> str:
+    try:
+        with open(media_path, "rb") as media_file:
+            return base64.b64encode(media_file.read()).decode('utf-8')
+    except FileNotFoundError:
+        print(f"Media file not found at: {media_path}")
+        raise
+    except Exception as e:
+        raise IOError(f"Could not read or encode file {media_path}: {e}")
+
+def process_directory(client: OpenAI, model_name: str, result_suffix: str):
+    current_dir = os.getcwd()
+    source_json_files = [
+        f for f in os.listdir(current_dir)
+        if f.endswith('.json') and GENERIC_RESULT_PATTERN not in f
+    ]
+
+    if not source_json_files:
+        print(f"[Info] No source JSON files to process in {current_dir}.")
+        return
+
+    for json_filename in source_json_files:
+        process_single_json(current_dir, json_filename, client, model_name, result_suffix)
+
+def process_single_json(directory: str, json_filename: str, client: OpenAI, model_name: str, result_suffix: str):
+    dataset_json_path = os.path.join(directory, json_filename)
+    result_json_path = os.path.join(directory, f"{os.path.splitext(json_filename)[0]}{result_suffix}")
+
+    if os.path.exists(result_json_path):
+        print(f"Result file '{os.path.basename(result_json_path)}' already exists, skipping.")
+        return
+
+    print(f"Reading and processing dataset: {json_filename}")
+    try:
+        with open(dataset_json_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, FileNotFoundError) as e:
+        return
+
+    all_results = []
+    for item in tqdm(data, desc=f"  Processing {json_filename}", unit="item"):
+        start_time = time.time()
+        model_output = ""
+        try:
+            prompt = item['conversations'][0]['value']
+            ground_truth = item['conversations'][1]['value']
+            media_path_key = 'image' if 'image' in item else 'video'
+            media_relative_path = item.get(media_path_key)
+            if not media_relative_path:
+                raise ValueError("JSON item is missing 'image' or 'video' key.")
+
+            media_full_path = os.path.join(directory, media_relative_path)
+        
+            media_type = get_media_type(media_full_path)
+            media_base64 = encode_media_to_base64(media_full_path)
+            clean_prompt = prompt.replace("<image>", "").replace("<video>", "").strip()
+            
+            content = [{"type": "text", "text": clean_prompt}]
+            if media_type == 'image':
+                content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{media_base64}"}})
+            else: # video
+                content.append({"type": "video_url", "video_url": {"url": f"data:video/mp4;base64,{media_base64}"}})
+            
+            messages = [{"role": "user", "content": content}]
+
+            response = client.chat.completions.create(model=model_name, messages=messages, max_tokens=1024, temperature=0.0)
+            model_output = response.choices[0].message.content
+
+        except Exception as e:
+            model_output = f"ERROR: {str(e)}"
+        
+        end_time = time.time()
+      
+        all_results.append({
+            "id": item.get('id', 'N/A'),
+            "prompt": prompt,
+            "model_output": model_output,
+            "ground_truth": ground_truth,
+            "processing_time_seconds": round(end_time - start_time, 2)
+        })
+
+    with open(result_json_path, 'w', encoding='utf-8') as f:
+        json.dump(all_results, f, indent=4, ensure_ascii=False)
+    print(f"Task complete. Results saved to: {result_json_path}")
+
+
+def main():
+    try:
+        client = OpenAI(base_url=MODEL_ENDPOINT, api_key="EMPTY")
+    except Exception as e:
+        print(f"[Fatal] Could not initialize OpenAI client: {e}")
+        sys.exit(1) 
+
+    process_directory(client, MODEL_NAME, RESULT_SUFFIX)
+
+
+
+if __name__ == "__main__":
+    main()

code/test_code/test_qwen25_omni.py

@@ -0,0 +1,177 @@
+import os
+import json
+import argparse
+import time
+import sys
+import base64
+import signal
+import contextlib
+from typing import Dict, Any, List
+from tqdm import tqdm
+from openai import OpenAI
+
+
+class TimeoutError(Exception):
+    pass
+
+@contextlib.contextmanager
+def timeout(seconds: int, error_message: str = 'Function call timed out'):
+    def _handle_timeout(signum, frame):
+        raise TimeoutError(error_message)
+    
+    signal.signal(signal.SIGALRM, _handle_timeout)
+    signal.alarm(seconds)
+    
+    try:
+        yield
+    finally:
+        signal.alarm(0)
+
+def get_media_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext in ['.mp4', '.avi', '.mov', '.mkv', '.webm']:
+        return 'video'
+    elif ext in ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp']:
+        return 'image'
+    else:
+        raise ValueError(f"Unsupported file format: {ext}")
+
+def create_text_message(prompt: str) -> List[Dict[str, Any]]:
+    return [{"role": "user", "content": [{"type": "text", "text": prompt}]}]
+
+def create_multimodal_message(prompt: str, media_path: str) -> List[Dict[str, Any]]:
+    media_type = get_media_type(media_path)
+    
+    try:
+        with open(media_path, "rb") as media_file:
+            media_base64 = base64.b64encode(media_file.read()).decode('utf-8')
+    except IOError as e:
+        raise IOError(f"Could not read or encode file {media_path}: {e}")
+
+    content = [{"type": "text", "text": prompt}]
+    if media_type == 'image':
+        content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{media_base64}"}})
+    elif media_type == 'video':
+        content.append({"type": "video_url", "video_url": {"url": f"data:video/mp4;base64,{media_base64}"}})
+    
+    return [{"role": "user", "content": content}]
+
+def get_model_response(client: OpenAI, model_name: str, messages: List[Dict[str, Any]]) -> str:
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=messages,
+        max_tokens=1024,
+        temperature=0.0
+    )
+    return response.choices[0].message.content
+
+def text_only_fallback(client: OpenAI, model_name: str, prompt_text: str) -> str:
+    print("  [INFO] Executing text-only fallback...", file=sys.stderr)
+    try:
+        clean_prompt = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+        messages = create_text_message(clean_prompt)
+        return get_model_response(client, model_name, messages)
+    except Exception as e:
+        return f"ERROR in text-only fallback: {str(e)}"
+
+def process_file(client: OpenAI, model_name: str, result_suffix: str, json_filename: str):
+    result_json_path = f"{os.path.splitext(json_filename)[0]}{result_suffix}"
+    if os.path.exists(result_json_path):
+        print(f"[INFO] Skipping already processed file: {json_filename}")
+        return
+    with open(json_filename, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+
+    all_results = []
+    for item in tqdm(data, desc=f"  Processing {json_filename}", file=sys.stdout):
+        start_time = time.time()
+        model_output = ""
+        prompt_text = ""
+        ground_truth = ""
+
+        try:
+            prompt_text = item['conversations'][0]['value']
+            ground_truth = item['conversations'][1]['value']
+            clean_prompt = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+
+            media_relative_path = item.get('image') or item.get('video')
+
+            if not media_relative_path:
+                print(f"\n No media key found for item {item.get('id', 'N/A')}. Falling back to text-only.", file=sys.stderr)
+                model_output = text_only_fallback(client, model_name, prompt_text)
+            else:
+                media_full_path = os.path.abspath(media_relative_path)
+                if not os.path.exists(media_full_path):
+                    raise FileNotFoundError(f"Media file not found: {media_full_path}")
+                
+                try:
+                    with timeout(seconds=300):
+                        messages = create_multimodal_message(clean_prompt, media_full_path)
+                        model_output = get_model_response(client, model_name, messages)
+                except TimeoutError:
+                    print(f"\n Processing timed out for item {item.get('id', 'N/A')}. Falling back to text-only.", file=sys.stderr)
+                    model_output = text_only_fallback(client, model_name, prompt_text)
+
+        except Exception as e:
+            error_message = f"ERROR: {str(e)}"
+            model_output = error_message
+            print(f"\n Failed to process item {item.get('id', 'N/A')}: {e}", file=sys.stderr)
+        
+        end_time = time.time()
+        all_results.append({
+            "id": item.get('id', 'N/A'),
+            "prompt": prompt_text,
+            "model_output": model_output,
+            "ground_truth": ground_truth,
+            "processing_time_seconds": round(end_time - start_time, 2)
+        })
+
+    with open(result_json_path, 'w', encoding='utf-8') as f:
+        json.dump(all_results, f, indent=4, ensure_ascii=False)
+    print(f" File processing complete. Results saved to: {result_json_path}")
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Run inference on JSON files in the current directory using a specified model.",
+        formatter_class=argparse.RawTextHelpFormatter
+    )
+    parser.add_argument(
+        "--model-endpoint",
+        default="http://127.0.0.1:8000/v1",
+        help="The API endpoint for the model (e.g., 'http://127.0.0.1:8000/v1')."
+    )
+    parser.add_argument(
+        "--model-name",
+        default="qwen2.5-omni-7b",
+        help="The name of the model to use for inference."
+    )
+    parser.add_argument(
+        "--result-suffix",
+        default="_result.json",
+        help="The suffix to append to result filenames."
+    )
+    args = parser.parse_args()
+
+    try:
+        client = OpenAI(base_url=args.model_endpoint, api_key="EMPTY")
+    except Exception as e:
+        print(f"Could not create OpenAI client. Please check the endpoint: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    current_dir = os.getcwd()
+    source_files = sorted([
+        f for f in os.listdir(current_dir)
+        if f.endswith('.json') and not f.endswith(args.result_suffix)
+    ])
+
+    if not source_files:
+        print("No source JSON files.", file=sys.stderr)
+        return
+
+    for json_filename in source_files:
+        process_file(client, args.model_name, args.result_suffix, json_filename)
+            
+
+
+if __name__ == "__main__":
+    main()

code/test_code/test_qwenvl.py

@@ -0,0 +1,183 @@
+import os
+import json
+import argparse
+import time
+import traceback
+from typing import Any, Dict, List, Optional, Tuple
+from tqdm import tqdm
+
+try:
+    import torch
+    from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
+    import av
+except ImportError as e:
+    print(f"Original error: {e}")
+    exit(1)
+
+# --- Configuration ---
+DEFAULT_MODEL_PATH = "example/model/Qwen2.5-VL-model"
+
+def get_media_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext in ['.mp4', '.avi', '.mov', '.mkv', '.webm']:
+        return 'video'
+    elif ext in ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp']:
+        return 'image'
+    else:
+        raise ValueError(f"Unsupported file format: {ext} in file {file_path}")
+
+def run_inference_on_file(
+    json_path: str,
+    model: Qwen2_5_VLForConditionalGeneration,
+    processor: AutoProcessor,
+    result_suffix: str,
+    fps: float,
+    max_pixels: int,
+    total_pixels: Optional[int],
+    gen_tokens: int
+):
+
+
+    result_json_path = f"{os.path.splitext(json_path)[0]}{result_suffix}"
+
+    if os.path.exists(result_json_path):
+        print(f"  [INFO] Result file '{os.path.basename(result_json_path)}' already exists. Skipping.")
+        return
+
+    try:
+        with open(json_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, FileNotFoundError) as e:
+        print(f"Could not read or parse JSON file {json_path}: {e}")
+        return
+    from qwen_vl_utils import process_vision_info
+
+    all_results = []
+    for item in tqdm(data, desc=f"  Inferring on {os.path.basename(json_path)}"):
+        start_time = time.time()
+        model_output = "N/A"
+        
+        try:
+            prompt_text = item['conversations'][0]['value']
+            ground_truth = item['conversations'][1]['value']
+            media_path_key = 'image' if 'image' in item else 'video'
+            media_relative_path = item.get(media_path_key)
+
+            if not media_relative_path:
+                raise ValueError("JSON entry is missing 'image' or 'video' key.")
+
+            base_dir = os.path.dirname(json_path)
+            media_full_path = os.path.join(base_dir, media_relative_path)
+            
+            if not os.path.exists(media_full_path):
+                raise FileNotFoundError(f"Media file not found: {media_full_path}")
+            
+            media_type = get_media_type(media_full_path)
+            clean_prompt = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+
+            content: List[Dict[str, Any]] = []
+            media_abs_path = os.path.abspath(media_full_path)
+            
+            if media_type == 'image':
+                content.append({"type": "image", "image": media_abs_path})
+            else:  # video
+                video_item = {
+                    "type": "video",
+                    "video": media_abs_path,
+                    "fps": float(fps),
+                    "max_pixels": int(max_pixels),
+                }
+                if total_pixels is not None and total_pixels > 0:
+                    video_item["total_pixels"] = int(total_pixels)
+                content.append(video_item)
+
+            content.append({"type": "text", "text": clean_prompt})
+            messages = [{"role": "user", "content": content}]
+
+            text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+            
+            image_inputs, video_inputs, video_kwargs = process_vision_info(messages, return_video_kwargs=True)
+            
+            inputs = processor(
+                text=[text], images=image_inputs, videos=video_inputs,
+                padding=True, return_tensors="pt", **video_kwargs,
+            )
+            inputs = inputs.to(model.device)
+
+            generated_ids = model.generate(**inputs, max_new_tokens=gen_tokens, do_sample=False)
+            generated_ids_trimmed = [out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+            output_text = processor.batch_decode(generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False)
+            model_output = (output_text[0] if output_text else "").strip()
+
+        except Exception as e:
+            model_output = f"ERROR: {str(e)}\n{traceback.format_exc()}"
+        
+        end_time = time.time()
+        all_results.append({
+            "id": item.get('id', 'N/A'),
+            "prompt": prompt_text,
+            "model_output": model_output,
+            "ground_truth": ground_truth,
+            "processing_time_seconds": round(end_time - start_time, 2)
+        })
+
+    with open(result_json_path, 'w', encoding='utf-8') as f:
+        json.dump(all_results, f, indent=4, ensure_ascii=False)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Qwen2.5-VL Batch Inference (High-Performance Mode)")
+    parser.add_argument("--model-path", default=DEFAULT_MODEL_PATH, help="Path to the local model directory.")
+    parser.add_argument("--result-suffix", default="_result.json", help="Suffix for result files.")
+    parser.add_argument("--fps", type=float, default=1.0, help="Frame rate for video sampling.")
+    parser.add_argument("--max-pixels", type=int, default=360*420, help="Maximum pixels per frame.")
+    parser.add_argument("--total-pixels", type=int, default=0, help="Total pixel limit for a video (0 for unlimited).")
+    parser.add_argument("--max-new-tokens", type=int, default=1024, help="Maximum number of new tokens to generate.")
+    args = parser.parse_args()
+
+    if not args.model_path or args.model_path == "path/to/your/Qwen2.5-VL-model":
+        exit(1)
+
+    print(f"Model Path: {args.model_path}")
+
+    try:
+        import flash_attn
+        attn_implementation = "flash_attention_2"
+        print("Flash Attention 2 detected. Using for better performance.")
+    except ImportError:
+        attn_implementation = "eager"
+        print("Flash Attention 2 not found. ")
+
+    print(f"Loading model with bfloat16 + {attn_implementation}...")
+    
+    model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+        args.model_path,
+        torch_dtype=torch.bfloat16,
+        attn_implementation=attn_implementation,
+        device_map="auto",
+    )
+    
+    processor = AutoProcessor.from_pretrained(args.model_path)
+    current_dir = os.getcwd()
+    source_files = [
+        f for f in os.listdir(current_dir)
+        if f.endswith('.json') and not f.endswith(args.result_suffix)
+    ]
+
+    if not source_files:
+        print(f"\nNo source JSON files.")
+    else:
+        print(f"\nFound {len(source_files)} JSON file(s) to process.")
+        
+        for json_filename in sorted(source_files):
+            json_full_path = os.path.join(current_dir, json_filename)
+            run_inference_on_file(
+                json_full_path, model, processor, args.result_suffix,
+                fps=args.fps, max_pixels=args.max_pixels,
+                total_pixels=(args.total_pixels if args.total_pixels > 0 else None),
+                gen_tokens=args.max_new_tokens
+            )
+            
+
+if __name__ == "__main__":
+    main()

code/test_code/test_r1omni.py

@@ -0,0 +1,232 @@
+
+import os
+import json
+import argparse
+import time
+import sys
+import glob
+from typing import Dict, Any, List
+from tqdm import tqdm
+import torch
+import torch.multiprocessing as mp
+from transformers import BertTokenizer
+
+from humanomni import model_init, mm_infer
+from humanomni.utils import disable_torch_init
+
+worker_model_objects: Dict[str, Any] = {}
+
+def init_worker(model_path: str, bert_path: str, device: str):
+    global worker_model_objects
+    try:
+        disable_torch_init()
+        model, processor, tokenizer = model_init(model_path, device=device)
+        bert_tokenizer = BertTokenizer.from_pretrained(bert_path)
+        worker_model_objects = {
+            "model": model,
+            "processor": processor,
+            "tokenizer": tokenizer,
+            "bert_tokenizer": bert_tokenizer,
+        }
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        raise e
+
+def get_media_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext in ['.mp4', '.avi', '.mov', '.mkv', '.webm']:
+        return 'video'
+    elif ext in ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp']:
+        return 'image'
+    else:
+        return 'unknown'
+
+def process_single_sample(media_full_path: str, prompt_text: str) -> str:
+    global worker_model_objects
+    try:
+        model = worker_model_objects['model']
+        processor = worker_model_objects['processor']
+        tokenizer = worker_model_objects['tokenizer']
+        bert_tokenizer = worker_model_objects['bert_tokenizer']
+
+        media_type = get_media_type(media_full_path)
+        if media_type == 'unknown':
+            raise ValueError(f"Unsupported media type for file: {media_full_path}")
+
+        clean_prompt = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+        media_tensor, audio_tensor, modal_str = None, None, ""
+
+        if media_type == 'video':
+            media_tensor = processor['video'](media_full_path)
+            audio_tensor = processor['audio'](media_full_path)[0]
+            modal_str = 'video_audio'
+        elif media_type == 'image':
+            media_tensor = processor['image'](media_full_path)
+            modal_str = 'image'
+
+        output = mm_infer(
+            media=media_tensor,
+            instruct=clean_prompt,
+            model=model,
+            tokenizer=tokenizer,
+            modal=modal_str,
+            question=clean_prompt,
+            bert_tokeni=bert_tokenizer,
+            do_sample=False,
+            audio=audio_tensor
+        )
+        return output
+    except Exception as e:
+        import traceback
+        return f"ERROR: {e}\n{traceback.format_exc()}"
+
+def text_only_fallback(prompt_text: str) -> str:
+
+    global worker_model_objects
+    try:
+        model = worker_model_objects['model']
+        tokenizer = worker_model_objects['tokenizer']
+        
+        clean_prompt = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+        inputs = tokenizer(clean_prompt, return_tensors="pt").to(model.device)
+        
+        output_ids = model.generate(
+            input_ids=inputs.input_ids,
+            attention_mask=inputs.attention_mask,
+            max_new_tokens=512,
+            do_sample=False
+        )
+        
+        response = tokenizer.decode(output_ids[0], skip_special_tokens=True)
+        
+        if response.startswith(clean_prompt):
+             return response[len(clean_prompt):].strip()
+        return response
+    except Exception as e:
+        return f"ERROR in text-only fallback: {str(e)}"
+
+def run_inference_task(media_full_path: str, prompt_text: str) -> str:
+    if not worker_model_objects: return "ERROR: Worker model not initialized."
+    return process_single_sample(media_full_path, prompt_text)
+
+def run_fallback_task(prompt_text: str) -> str:
+    if not worker_model_objects: return "ERROR: Worker model not initialized."
+    return text_only_fallback(prompt_text)
+
+def process_json_file(
+    dataset_json_path: str,
+    result_suffix: str,
+    pool_ref: List[mp.Pool],
+    model_path: str,
+    bert_path: str,
+    device: str
+):
+
+    base_dir = os.path.dirname(dataset_json_path)
+    json_filename = os.path.basename(dataset_json_path)
+    result_json_path = os.path.join(base_dir, f"{os.path.splitext(json_filename)[0]}{result_suffix}")
+
+    if os.path.exists(result_json_path):
+        return
+
+    try:
+        with open(dataset_json_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, FileNotFoundError) as e:
+        return
+
+    all_results = []
+    for item in tqdm(data, desc=f"  Inferring on {json_filename}", unit="item"):
+        start_time = time.time()
+        model_output, prompt, ground_truth = "", "", ""
+        pool = pool_ref[0]
+
+        try:
+            prompt = item["conversations"][0]["value"]
+            ground_truth = item["conversations"][1]["value"]
+            media_relative_path = item.get('image') or item.get('video')
+
+            if not media_relative_path:
+                model_output = pool.apply(run_fallback_task, args=(prompt,))
+            else:
+                media_full_path = os.path.join(base_dir, media_relative_path)
+                if not os.path.exists(media_full_path):
+                    model_output = pool.apply(run_fallback_task, args=(prompt,))
+                else:
+                    async_result = pool.apply_async(run_inference_task, args=(media_full_path, prompt))
+                    try:
+                        model_output = async_result.get(timeout=60)
+                    except (mp.TimeoutError, Exception) as e:
+                        pool.terminate()
+                        pool.join()
+                        pool_ref[0] = mp.Pool(processes=1, initializer=init_worker, initargs=(model_path, bert_path, device))
+                        model_output = pool_ref[0].apply(run_fallback_task, args=(prompt,))
+
+        except Exception as e:
+            model_output = f"ERROR: Main loop error: {e}"
+            print(f"\n {model_output}")
+
+        end_time = time.time()
+        all_results.append({
+            "id": item.get("id", "N/A"),
+            "prompt": prompt,
+            "model_output": model_output,
+            "ground_truth": ground_truth,
+            "processing_time_seconds": round(end_time - start_time, 2),
+        })
+
+    with open(result_json_path, "w", encoding="utf-8") as f:
+        json.dump(all_results, f, indent=4, ensure_ascii=False)
+
+def main():
+    parser = argparse.ArgumentParser(description="Batch inference with R1-Omni model on local JSON datasets.")
+    parser.add_argument("--model-path", required=True, help="Path to the R1-Omni model directory.")
+    parser.add_argument("--bert-path", required=True, help="Path to the bert-base-uncased tokenizer directory.")
+    parser.add_argument("--input-dir", default=".", help="Directory containing JSON datasets and media files.")
+    parser.add_argument("--device", default="cuda:0", help="Device to run the model on (e.g., 'cuda:0', 'cpu').")
+    parser.add_argument("--result-suffix", default="_r1omni_result.json", help="Suffix for result JSON files.")
+    args = parser.parse_args()
+    
+    os.environ['TRANSFORMERS_OFFLINE'] = '1'
+    
+    worker_device = args.device
+    if "cuda" in args.device:
+        gpu_id = args.device.split(':')[-1]
+        os.environ['CUDA_VISIBLE_DEVICES'] = gpu_id
+        worker_device = "cuda:0"
+
+    pool_ref = [mp.Pool(
+        processes=1,
+        initializer=init_worker,
+        initargs=(args.model_path, args.bert_path, worker_device)
+    )]
+
+    try:
+        source_json_files = glob.glob(os.path.join(args.input_dir, "*.json"))
+        source_json_files = [f for f in source_json_files if not f.endswith(args.result_suffix)]
+
+        if not source_json_files:
+            return
+
+        for json_path in sorted(source_json_files):
+            process_json_file(
+                json_path,
+                args.result_suffix,
+                pool_ref,
+                args.model_path,
+                args.bert_path,
+                worker_device
+            )
+    finally:
+        pool_ref[0].close()
+        pool_ref[0].join()
+
+
+if __name__ == "__main__":
+    if torch.cuda.is_available():
+        try:
+            mp.set_start_method('spawn', force=True)
+        except RuntimeError:
+            pass
+    main()

code/test_code/test_videollama3.py

@@ -0,0 +1,144 @@
+import os
+import json
+import argparse
+from tqdm import tqdm
+import time
+import torch
+from transformers import AutoModelForCausalLM, AutoProcessor
+
+LEVEL_DIRS = ["level1", "level2", "level3"]
+GENERIC_RESULT_PATTERN = "_result.json"
+
+def get_media_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext in ['.mp4', '.avi', '.mov', '.mkv', '.webm']:
+        return 'video'
+    elif ext in ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp']:
+        return 'image'
+    else:
+        raise ValueError(f"Unsupported file extension: {ext} in file {file_path}")
+
+def process_task(task_path: str, model, processor, result_suffix: str, device: str):
+
+
+    source_json_files = [
+        f for f in os.listdir(task_path)
+        if f.endswith('.json') and GENERIC_RESULT_PATTERN not in f
+    ]
+
+    if not source_json_files:
+        return
+
+    for json_filename in source_json_files:
+        dataset_json_path = os.path.join(task_path, json_filename)
+        result_json_path = os.path.join(task_path, f"{os.path.splitext(json_filename)[0]}{result_suffix}")
+
+        if os.path.exists(result_json_path):
+            continue
+
+        try:
+            with open(dataset_json_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError) as e:
+            continue
+
+        all_results = []
+        for item in tqdm(data, desc=f"  Processing {json_filename}"):
+            start_time = time.time()
+            model_output = "N/A"
+
+            try:
+                prompt_text = item['conversations'][0]['value']
+                ground_truth = item['conversations'][1]['value']
+                media_path_key = 'image' if 'image' in item else 'video'
+                media_relative_path = item.get(media_path_key)
+
+                if not media_relative_path:
+                    raise ValueError("Missing 'image' or 'video' key in JSON entry.")
+
+                media_full_path = os.path.join(task_path, media_relative_path)
+                if not os.path.exists(media_full_path):
+                    raise FileNotFoundError(f"Media file not found: {media_full_path}")
+
+                media_type = get_media_type(media_full_path)
+                clean_prompt = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+
+                if media_type == 'image':
+                    media_content = {"type": "image", "image": {"image_path": media_full_path}}
+                else:
+                    media_content = {"type": "video", "video": {"video_path": media_full_path, "fps": 1, "max_frames": 128}}
+                
+                conversation = [
+                    {"role": "system", "content": "You are a helpful assistant."},
+                    {
+                        "role": "user",
+                        "content": [
+                            media_content,
+                            {"type": "text", "text": clean_prompt},
+                        ]
+                    },
+                ]
+
+                inputs = processor(conversation=conversation, return_tensors="pt")
+                inputs = {k: v.to(device) if isinstance(v, torch.Tensor) else v for k, v in inputs.items()}
+                if "pixel_values" in inputs:
+                    inputs["pixel_values"] = inputs["pixel_values"].to(torch.bfloat16)
+
+                output = model.generate(**inputs, max_new_tokens=1024, do_sample=False)
+                response = processor.batch_decode(output, skip_special_tokens=True)[0].strip()
+
+                last_turn_markers = ['assistant\n', 'assistant:']
+                for marker in last_turn_markers:
+                    if marker in response.lower():
+                        response = response.split(marker, 1)[-1].strip()
+                        break
+                model_output = response
+
+            except Exception as e:
+                model_output = f"ERROR: {str(e)}"
+
+            end_time = time.time()
+            all_results.append({
+                "id": item.get('id', 'N/A'),
+                "prompt": prompt_text,
+                "model_output": model_output,
+                "ground_truth": ground_truth,
+                "processing_time_seconds": round(end_time - start_time, 2)
+            })
+
+        with open(result_json_path, 'w', encoding='utf-8') as f:
+            json.dump(all_results, f, indent=4, ensure_ascii=False)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Batch processing script for a local multimodal model using the Transformers library.")
+
+    parser.add_argument("--model-path", required=True, help="Full path to the local model directory")
+    parser.add_argument("--result-suffix", required=True, help="Suffix for the generated result files")
+    parser.add_argument("--device", default="cuda:0", help="Device to run the model")
+
+    args = parser.parse_args()
+    try:
+        model = AutoModelForCausalLM.from_pretrained(
+            args.model_path,
+            trust_remote_code=True,
+            torch_dtype=torch.bfloat16,
+            attn_implementation="flash_attention_2",
+            device_map=args.device
+        )
+        processor = AutoProcessor.from_pretrained(args.model_path, trust_remote_code=True)
+    except Exception as e:
+        return
+
+    for level_dir in LEVEL_DIRS:
+        level_path = os.path.join(os.getcwd(), level_dir)
+        if not os.path.isdir(level_path):
+            continue
+
+        task_dirs = sorted([d.path for d in os.scandir(level_path) if d.is_dir()])
+        for task_path in task_dirs:
+            process_task(task_path, model, processor, args.result_suffix, args.device)
+
+
+if __name__ == "__main__":
+    main()

code/train_code/train_gemini.py

@@ -0,0 +1,412 @@
+import os
+import json
+import argparse
+import time
+from typing import Optional
+from tqdm import tqdm
+from google import genai
+import random
+from collections import deque
+#config
+GENERIC_RESULT_PATTERN = "_result.json"
+
+INLINE_SIZE_LIMIT_BYTES = 20 * 1024 * 1024
+
+MODEL_NAME = "gemini-2.5-pro"
+RESULT_SUFFIX = "_gemini_2.5_pro_result.json"
+
+REQUESTS_PER_MINUTE = 30  
+MIN_REQUEST_INTERVAL = 60.0 / REQUESTS_PER_MINUTE
+
+MAX_RETRIES = 5
+INITIAL_RETRY_DELAY = 5
+MAX_RETRY_DELAY = 120
+
+
+class RateLimiter:
+    
+    def __init__(self, requests_per_minute):
+        self.requests_per_minute = requests_per_minute
+        self.min_interval = 60.0 / requests_per_minute
+        self.last_request_time = 0
+        self.request_times = deque(maxlen=requests_per_minute)
+    
+    def wait_if_needed(self):
+        current_time = time.time()
+        
+        time_since_last = current_time - self.last_request_time
+        if time_since_last < self.min_interval:
+            sleep_time = self.min_interval - time_since_last
+            time.sleep(sleep_time)
+            current_time = time.time()
+        
+        minute_ago = current_time - 60
+        while self.request_times and self.request_times[0] < minute_ago:
+            self.request_times.popleft()
+        
+        if len(self.request_times) >= self.requests_per_minute:
+            sleep_time = 60 - (current_time - self.request_times[0]) + 0.1
+            if sleep_time > 0:
+                print(f"      [RATE LIMIT] Waiting {sleep_time:.1f}s to respect rate limits...")
+                time.sleep(sleep_time)
+                current_time = time.time()
+        
+        self.last_request_time = current_time
+        self.request_times.append(current_time)
+
+
+def get_mime_type(file_path: str) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+
+    if ext in [".mp4", ".m4v", ".mov", ".avi", ".mkv", ".webm", ".mpg", ".mpeg", ".wmv", ".3gp", ".3gpp", ".flv"]:
+        return "video/mp4"
+
+    audio_types = {
+        ".mp3": "audio/mp3",
+        ".wav": "audio/wav",
+        ".aac": "audio/aac",
+        ".aiff": "audio/aiff",
+        ".flac": "audio/flac",
+        ".ogg": "audio/ogg"
+    }
+    if ext in audio_types:
+        return audio_types[ext]
+
+    image_types = {
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".png": "image/png",
+        ".webp": "image/webp",
+        ".gif": "image/gif"
+    }
+    if ext in image_types:
+        return image_types[ext]
+
+    return "application/octet-stream"
+
+
+def _poll_file_ready(client: genai.Client, file_obj, sleep_s: float = 2.0, max_wait_s: float = 300.0) -> Optional[object]:
+    """Poll file processing status."""
+    start = time.time()
+    name = getattr(file_obj, "name", None)
+    state = getattr(file_obj, "state", None)
+    state_name = getattr(state, "name", None) or str(state)
+
+    while state_name and state_name.upper() in ("PROCESSING", "PENDING"):
+        if time.time() - start > max_wait_s:
+            return None
+        time.sleep(sleep_s)
+        try:
+            file_obj = client.files.get(name=name)
+        except Exception:
+            time.sleep(sleep_s)
+        state = getattr(file_obj, "state", None)
+        state_name = getattr(state, "name", None) or str(state)
+
+    return file_obj
+
+
+def process_single_sample_with_retry(
+    client: genai.Client, 
+    media_full_path: str, 
+    prompt_text: str,
+    rate_limiter: RateLimiter,
+    item_id: str = "N/A"
+) -> str:
+    """Process a single sample with retry logic and rate limiting."""
+    retry_delay = INITIAL_RETRY_DELAY
+    last_error = None
+    
+    for attempt in range(MAX_RETRIES):
+        try:
+            rate_limiter.wait_if_needed()
+            
+            return process_single_sample(client, media_full_path, prompt_text)
+            
+        except Exception as e:
+            last_error = e
+            error_str = str(e)
+            
+            if any(x in error_str.lower() for x in ["503", "overloaded", "rate", "quota", "429"]):
+                if attempt < MAX_RETRIES - 1:
+                    jitter = random.uniform(0, retry_delay * 0.3)
+                    sleep_time = retry_delay + jitter
+                    
+                    print(f"\n      [RETRY] Item {item_id}: API overloaded/rate limited. "
+                          f"Waiting {sleep_time:.1f}s... (Attempt {attempt + 1}/{MAX_RETRIES})")
+                    time.sleep(sleep_time)
+                    
+                    retry_delay = min(retry_delay * 2, MAX_RETRY_DELAY)
+                    
+                    if "503" in error_str:
+                        rate_limiter.min_interval *= 1.2 
+                        print(f"      [THROTTLE] Slowing down to {60/rate_limiter.min_interval:.1f} RPM")
+                    continue
+            
+            print(f"\n Item {item_id}: {error_str}")
+            return f"ERROR: {error_str}"
+    
+    print(f"\n    Item {item_id}: Max retries exceeded")
+    return f"ERROR: Max retries exceeded - {last_error}"
+
+
+def process_single_sample(client: genai.Client, media_full_path: str, prompt_text: str) -> str:
+    clean_prompt = prompt_text.replace("<image>", "").replace("<video>", "").strip()
+    file_size = os.path.getsize(media_full_path)
+    mime_type = get_mime_type(media_full_path)
+
+    if file_size < INLINE_SIZE_LIMIT_BYTES:
+        with open(media_full_path, "rb") as f:
+            file_bytes = f.read()
+
+        media_part = genai.types.Part(
+            inline_data=genai.types.Blob(data=file_bytes, mime_type=mime_type)
+        )
+
+        response = client.models.generate_content(
+            model=MODEL_NAME,
+            contents=[
+                media_part,
+                genai.types.Part(text=clean_prompt),
+            ],
+        )
+        text_response = getattr(response, "text", None)
+        if text_response is None:
+            return "ERROR: Empty response from model"
+        return text_response
+
+    else:
+        uploaded_file = None
+        try:
+            print(f"\n      [UPLOAD] Uploading: {os.path.basename(media_full_path)} ({file_size/1024**2:.1f} MB)...")
+            uploaded_file = client.files.upload(file=media_full_path)
+
+            uploaded_file = _poll_file_ready(client, uploaded_file)
+            if uploaded_file is None:
+                raise RuntimeError("File processing timeout in Files API.")
+
+            response = client.models.generate_content(
+                model=MODEL_NAME,
+                contents=[
+                    uploaded_file,
+                    genai.types.Part(text=clean_prompt)
+                ],
+            )
+            text_response = getattr(response, "text", None)
+            if text_response is None:
+                return "ERROR: Empty response from model"
+            return text_response
+        finally:
+            try:
+                if uploaded_file and getattr(uploaded_file, "name", None):
+                    client.files.delete(name=uploaded_file.name)
+            except Exception:
+                pass
+
+
+def save_result_immediately(result_json_path: str, all_results: list):
+    os.makedirs(os.path.dirname(result_json_path) or ".", exist_ok=True)
+    
+    temp_path = result_json_path + f".tmp_{os.getpid()}"
+    try:
+        with open(temp_path, "w", encoding="utf-8") as f:
+            json.dump(all_results, f, indent=4, ensure_ascii=False)
+        
+        os.replace(temp_path, result_json_path)
+        
+        os.sync() if hasattr(os, 'sync') else None
+        
+    except Exception as e:
+        print(f"\n  Failed to save results: {e}")
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+        raise
+
+
+def load_existing_results(result_json_path: str) -> tuple[list, set]:
+    if os.path.exists(result_json_path):
+        try:
+            with open(result_json_path, "r", encoding="utf-8") as f:
+                existing_results = json.load(f)
+            processed_ids = {item.get("id") for item in existing_results if item.get("id")}
+            return existing_results, processed_ids
+        except Exception as e:
+            print(f"Could not load existing results: {e}")
+    return [], set()
+
+
+def process_json_file(
+    json_path: str, 
+    client: genai.Client, 
+    resume: bool = True,
+    requests_per_minute: int = REQUESTS_PER_MINUTE
+):
+    json_filename = os.path.basename(json_path)
+    working_dir = os.path.dirname(json_path) or "."
+    result_json_path = os.path.join(
+        working_dir, 
+        f"{os.path.splitext(json_filename)[0]}{RESULT_SUFFIX}"
+    )
+
+    rate_limiter = RateLimiter(requests_per_minute)
+
+    all_results = []
+    processed_ids = set()
+    if resume:
+        all_results, processed_ids = load_existing_results(result_json_path)
+        if processed_ids:
+            print(f"Found {len(processed_ids)} already processed items")
+
+    try:
+        with open(json_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        print(f"Loaded {len(data)} total items from source file")
+    except (json.JSONDecodeError, FileNotFoundError) as e:
+        print(f" Could not read JSON file {json_path}: {e}")
+        return
+
+    items_to_process = []
+    for i, item in enumerate(data):
+        item_id = item.get("id", f"item_{i}")
+        if "id" not in item:
+            item["id"] = item_id
+        if resume and item_id in processed_ids:
+            continue
+        items_to_process.append(item)
+    
+    if not items_to_process:
+        print(f"All items already processed!")
+        return
+
+    if not os.path.exists(result_json_path):
+        save_result_immediately(result_json_path, all_results)
+        print(f" Result file: {result_json_path}\n")
+    
+    with tqdm(items_to_process, desc="Progress", ncols=100) as pbar:
+        for idx, item in enumerate(pbar):
+            start_time = time.time()
+            item_id = item.get("id", f"item_{idx}")
+            
+            pbar.set_description(f"Processing {item_id}")
+            
+            try:
+                prompt = item["conversations"][0]["value"]
+                ground_truth = item["conversations"][1]["value"]
+
+                media_path_key = "image" if "image" in item else "video"
+                media_relative_path = item.get(media_path_key)
+                if not media_relative_path:
+                    raise ValueError("Missing 'image' or 'video' key")
+
+                media_full_path = os.path.join(working_dir, media_relative_path)
+                if not os.path.exists(media_full_path):
+                    raise FileNotFoundError(f"Media file not found: {media_full_path}")
+
+                model_output = process_single_sample_with_retry(
+                    client, media_full_path, prompt, rate_limiter, item_id
+                )
+
+            except Exception as e:
+                model_output = f"ERROR: {str(e)}"
+                print(f"\n[ERROR] Failed item {item_id}: {e}")
+                prompt = item.get("conversations", [{}])[0].get("value", "")
+                ground_truth = item.get("conversations", [{}, {}])[1].get("value", "")
+
+            end_time = time.time()
+            processing_time = round(end_time - start_time, 2)
+            
+            if model_output is None:
+                model_output = "ERROR: Null response from model"
+            
+            result_item = {
+                "id": item_id,
+                "prompt": prompt,
+                "model_output": model_output,
+                "ground_truth": ground_truth,
+                "processing_time_seconds": processing_time,
+            }
+            
+            all_results.append(result_item)
+            
+            save_result_immediately(result_json_path, all_results)
+            
+            current_rpm = 60 / rate_limiter.min_interval
+
+            success_count = sum(1 for r in all_results 
+                              if r.get("model_output") and not str(r["model_output"]).startswith("ERROR"))
+            error_count = len(all_results) - success_count
+            
+            pbar.set_postfix({
+                "Saved": len(all_results),
+                "OK": success_count,
+                "Err": error_count,
+                "RPM": f"{current_rpm:.1f}",
+                "Time": f"{processing_time:.1f}s"
+            })
+    
+    success_count = sum(1 for r in all_results 
+                        if r.get("model_output") and not str(r["model_output"]).startswith("ERROR"))
+    error_count = len(all_results) - success_count
+    
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=f"Process task with {MODEL_NAME} - saves after each item."
+    )
+    parser.add_argument(
+        "--api-key",
+        default=os.getenv("GOOGLE_API_KEY", "API_KEY"),
+        help="Google Gemini API key (or set env GOOGLE_API_KEY)."
+    )
+    parser.add_argument(
+        "--json-file",
+        type=str,
+        help="Specific JSON file to process."
+    )
+    parser.add_argument(
+        "--no-resume",
+        action="store_true",
+        help="Start from scratch (ignore existing results)."
+    )
+    parser.add_argument(
+        "--rpm",
+        type=int,
+        default=REQUESTS_PER_MINUTE,
+        help=f"Requests per minute limit (default: {REQUESTS_PER_MINUTE})."
+    )
+    args = parser.parse_args()
+
+    if not args.api_key:
+        print("\nPlease provide your Google Gemini API key.")
+        return
+
+    try:
+        client = genai.Client(api_key=args.api_key)
+    except Exception as e:
+        print(f"\n Failed to initialize Gemini client: {e}")
+        return
+
+    if args.json_file:
+        if not os.path.exists(args.json_file):
+            print(f"\n JSON file not found: {args.json_file}")
+            return
+        process_json_file(args.json_file, client, not args.no_resume, args.rpm)
+    else:
+        current_dir = os.getcwd()
+        json_files = [
+            f for f in os.listdir(current_dir)
+            if f.endswith(".json") and GENERIC_RESULT_PATTERN not in f
+        ]
+        
+        if not json_files:
+            print(f"\nNo source JSON files found in current directory.")
+            return
+        for f in json_files:
+            print(f"  - {f}")
+        
+        for json_file in json_files:
+            json_path = os.path.join(current_dir, json_file)
+            process_json_file(json_path, client, not args.no_resume, args.rpm)
+
+if __name__ == "__main__":
+    main()

code/train_code/train_gpt4o.py

@@ -0,0 +1,108 @@
+import json
+import os
+import time
+from openai import OpenAI
+
+
+API_KEY = os.environ.get("OPENAI_API_KEY", "api-key")
+client = OpenAI(api_key=API_KEY)
+MODEL_NAME = "gpt-4o"                          
+
+INPUT_FILE = "example.json"                      
+OUTPUT_FILE = "gpt4o_results.json"             
+
+TEST_MODE = True                             
+TEST_ITEMS = 5                                 
+
+MAX_RETRY = 3                                  
+SLEEP_BETWEEN_RETRY = 3                   
+REASONING_EFFORT = "high"                      
+
+def call_gpt4o_with_retry(prompt, attempt_num=1):
+    for retry in range(MAX_RETRY):
+        try:
+
+            response = client.responses.create(
+                model=MODEL_NAME,
+                reasoning={"effort": REASONING_EFFORT},
+                input=[{
+                    "role": "user",
+                    "content": [{"type": "input_text", "text": prompt}]
+                }]
+            )
+
+            return response.output_text
+
+        except Exception as e:
+            print(f" Error on attempt {retry + 1}: {str(e)}")
+            if retry < MAX_RETRY - 1:
+                print(f" Retrying in {SLEEP_BETWEEN_RETRY} seconds...")
+                time.sleep(SLEEP_BETWEEN_RETRY)
+            else:
+                print(f"Failed after {MAX_RETRY} attempts")
+                return None
+    return None
+
+
+def extract_prompt_and_truth(conversations):
+    prompt = None
+    ground_truth = None
+
+    if conversations and len(conversations) > 0 and conversations[0]["from"] == "human":
+        prompt = conversations[0]["value"].strip()
+
+    if len(conversations) >= 2 and conversations[1]["from"] == "gpt":
+        ground_truth = conversations[1]["value"]
+
+    return prompt, ground_truth
+
+
+def main():
+    if not os.path.exists(INPUT_FILE):
+        print(f"Error: Input file '{INPUT_FILE}' not found")
+        return
+
+    with open(INPUT_FILE, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+
+    print(f"Loaded {len(data)} items from {INPUT_FILE}")
+
+    items_to_process = data[:TEST_ITEMS] if TEST_MODE else data
+    results = []
+
+    for idx, item in enumerate(items_to_process, 1):
+        item_id = item.get("id")
+        conversations = item.get("conversations", [])
+
+        print(f"\n[{idx}/{len(items_to_process)}] Processing ID: {item_id}")
+
+        if not conversations:
+            print(f"Skipping: missing conversations")
+            continue
+
+        prompt, ground_truth = extract_prompt_and_truth(conversations)
+
+        if not prompt:
+            print(f"Skipping: no prompt found")
+            continue
+
+        print(f"  Ground Truth: {ground_truth}")
+
+        response1 = call_gpt4o_with_retry(prompt, attempt_num=1)
+
+        response2 = call_gpt4o_with_retry(prompt, attempt_num=2)
+
+        result = {
+            "id": item_id,
+            "response_1": response1,
+            "response_2": response2,
+            "ground_truth": ground_truth
+        }
+        results.append(result)
+
+    with open(OUTPUT_FILE, 'w', encoding='utf-8') as f:
+        json.dump(results, f, ensure_ascii=False, indent=2)
+
+
+if __name__ == "__main__":
+    main()

code/train_code/train_gpt5.py

@@ -0,0 +1,196 @@
+import json
+import cv2
+import base64
+import os
+import time
+from openai import OpenAI
+from pathlib import Path
+
+API_KEY = os.environ.get("OPENAI_API_KEY", "api-key")
+client = OpenAI(api_key=API_KEY)
+MODEL_NAME = "gpt-5"                          
+
+INPUT_FILE = "example.json"                     
+OUTPUT_FILE = "gpt5_results.json"             
+
+TEST_MODE = True                             
+TEST_ITEMS = 5                             
+VIDEO_SAMPLE_INTERVAL = 25                    
+
+MAX_RETRY = 3                                 
+SLEEP_BETWEEN_RETRY = 3                        
+REASONING_EFFORT = "high"                      
+
+VIDEO_EXTENSIONS = ['.mp4', '.avi', '.mov', '.mkv', '.wmv', '.flv']
+IMAGE_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp']
+
+def encode_image_to_base64(image_path):
+    try:
+        with open(image_path, "rb") as image_file:
+            return base64.b64encode(image_file.read()).decode('utf-8')
+    except Exception as e:
+        print(f"Error encoding image {image_path}: {str(e)}")
+        return None
+
+def process_video(video_path, sample_interval=VIDEO_SAMPLE_INTERVAL):
+    try:
+        video = cv2.VideoCapture(video_path)
+        base64_frames = []
+        frame_count = 0
+        
+        while video.isOpened():
+            success, frame = video.read()
+            if not success:
+                break
+            frame_count += 1
+
+            if (frame_count - 1) % sample_interval == 0:
+                _, buffer = cv2.imencode(".jpg", frame)
+                base64_frames.append(base64.b64encode(buffer).decode("utf-8"))
+        
+        video.release()
+        print(f"Processed video: {frame_count} total frames, sampled {len(base64_frames)} frames")
+        return base64_frames
+    
+    except Exception as e:
+        print(f"Error processing video {video_path}: {str(e)}")
+        return None
+
+def determine_media_type(file_path):
+    ext = Path(file_path).suffix.lower()
+    
+    if ext in VIDEO_EXTENSIONS:
+        return 'video'
+    elif ext in IMAGE_EXTENSIONS:
+        return 'image'
+    else:
+        print(f" Unknown extension {ext}, treating as video")
+        return 'video'
+
+def call_gpt5_with_retry(prompt, media_path, attempt_num=1):
+    media_type = determine_media_type(media_path)
+    
+    if not os.path.exists(media_path):
+        print(f" Warning: File {media_path} not found")
+        return None
+    
+    for retry in range(MAX_RETRY):
+        try:
+            print(f"  Attempt {attempt_num}.{retry + 1}: Processing {media_type}...")
+            
+            if media_type == 'video':
+                frames = process_video(media_path)
+                if not frames:
+                    print(f"   No frames extracted from {media_path}")
+                    return None
+                
+                content = [
+                    {"type": "input_text", "text": prompt},
+                    *[
+                        {
+                            "type": "input_image",
+                            "image_url": f"data:image/jpeg;base64,{frame}"
+                        }
+                        for frame in frames
+                    ]
+                ]
+            else:
+                base64_image = encode_image_to_base64(media_path)
+                if not base64_image:
+                    return None
+                    
+                content = [
+                    {"type": "input_text", "text": prompt},
+                    {
+                        "type": "input_image",
+                        "image_url": f"data:image/jpeg;base64,{base64_image}"
+                    }
+                ]
+            
+            response = client.responses.create(
+                model=MODEL_NAME,
+                reasoning={"effort": REASONING_EFFORT},
+                input=[{
+                    "role": "user",
+                    "content": content
+                }]
+            )
+            
+            return response.output_text
+        
+        except Exception as e:
+            print(f" Error on attempt {retry + 1}: {str(e)}")
+            if retry < MAX_RETRY - 1:
+                print(f" Retrying in {SLEEP_BETWEEN_RETRY} seconds...")
+                time.sleep(SLEEP_BETWEEN_RETRY)
+            else:
+                print(f" Failed after {MAX_RETRY} attempts")
+                return None
+    
+    return None
+
+def extract_prompt_and_truth(conversations):
+    prompt = None
+    ground_truth = None
+    
+    if conversations and len(conversations) > 0 and conversations[0]["from"] == "human":
+        full_value = conversations[0]["value"]
+        prompt = full_value.replace("<video>", "").replace("<image>", "").strip()
+    
+    if len(conversations) >= 2 and conversations[1]["from"] == "gpt":
+        ground_truth = conversations[1]["value"]
+    
+    return prompt, ground_truth
+
+def main():
+
+    if not os.path.exists(INPUT_FILE):
+        print(f"Error: Input file '{INPUT_FILE}' not found")
+        return
+    
+    with open(INPUT_FILE, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    print(f"Loaded {len(data)} items from {INPUT_FILE}")
+    
+    items_to_process = data[:TEST_ITEMS] if TEST_MODE else data
+    results = []
+    
+    
+    for idx, item in enumerate(items_to_process, 1):
+        item_id = item.get("id")
+        media_path = item.get("video") or item.get("image")
+        conversations = item.get("conversations", [])
+        
+        print(f"\n[{idx}/{len(items_to_process)}] Processing ID: {item_id}")
+        print(f"  Media: {media_path}")
+        
+        if not media_path or not conversations:
+            print(f"Skipping: missing media path or conversations")
+            continue
+
+        prompt, ground_truth = extract_prompt_and_truth(conversations)
+        
+        if not prompt:
+            print(f"Skipping: no prompt found")
+            continue
+
+        response1 = call_gpt5_with_retry(prompt, media_path, attempt_num=1)
+
+        response2 = call_gpt5_with_retry(prompt, media_path, attempt_num=2)
+
+        result = {
+            "id": item_id,
+            "media_path": media_path,
+            "response_1": response1,
+            "response_2": response2,
+            "ground_truth": ground_truth
+        }
+        results.append(result)
+
+    with open(OUTPUT_FILE, 'w', encoding='utf-8') as f:
+        json.dump(results, f, ensure_ascii=False, indent=2)
+
+
+if __name__ == "__main__":
+    main()