Upgrade evaluation script.

evaluation.py

@@ -1,157 +1,206 @@
-import os, llava, argparse
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+import logging
+import os
+
 import numpy as np
 from mmengine import load, dump
 from tqdm import tqdm
 from collections import defaultdict
 
 
-PROMPT_TEMPLATES = {
-    "instruction": "Evaluate if this video follows the instruction: '{instruction}'. Use the following scoring criteria:\n\n- 0: The video does not follow the instruction at all.\n- 1: The video includes the correct object but performs the wrong action, or vice versa.\n- 2: The video follows the instruction and shows a tendency toward the intended action but does not fully achieve the goal.\n- 3: The video follows the instruction precisely and successfully achieves the intended goal.\n\nLet's analyze step-by-step and conclude with 'Score: [score]'.",
-    "physical_laws": 'Watch the video and determine if it shows any \'{physical_laws}\' Let\'s think step-by-step and conclude with "Yes" or "No".',
-    "common_sense": 'Does the video exhibit \'{common_sense}\'? Let\'s think step-by-step and conclude with "Yes" or "No".',
-}
-
-QUESTION_POOL = {
-    "instruction": None,
-    "physical_laws": [
-        "Violation of Newton's Law: Objects move without any external force.",
-        "Violation of the Law of Conservation of Mass or Solid Constitutive Law: Objects deform or distort irregularly.",
-        "Violation of Fluid Constitutive Law: Liquids flow in an unnatural or irregular manner.",
-        "Violation of Non-physical Penetration: Objects unnaturally pass through each other.",
-        "Violation of Gravity: Objects behave inconsistently with gravity, such as floating in the air.",
-    ],
-    "common_sense": [
-        "Poor Aesthetics: Visually unappealing or low-quality content.",
-        "Temporal Inconsistency: Noticeable flickering, choppy motion, or abrupt appearance/disappearance of irrelevant objects.",
-    ],
-}
+class EvaluationType(Enum):
+    INSTRUCTION = "instruction"
+    PHYSICAL_LAWS = "physical_laws"
+    COMMON_SENSE = "common_sense"
 
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Script for evaluating the WorldModelBenchmark."
-    )
-    parser.add_argument(
-        "--judge",
-        type=str,
-        help="Path to judge model checkpoint.",
-    )
-    parser.add_argument(
-        "--video_dir",
-        type=str,
-        help="Path to the generated video directory.",
-    )
-    parser.add_argument(
-        "--save_name",
-        type=str,
-        help="Path to save evaluation results.",
-    )
-    parser.add_argument(
-        "--cot", action="store_true", help="Enable or disable Chain-of-Thought output."
-    )
+
+@dataclass
+class EvaluationConfig:
+    """Configuration for evaluation prompts and scoring criteria."""
+    
+    PROMPT_TEMPLATES: Dict[str, str] = {
+        EvaluationType.INSTRUCTION.value: """
+            Evaluate if this video follows the instruction: '{instruction}'.
+            Use the following scoring criteria:
+            
+            - 0: The video does not follow the instruction at all.
+            - 1: The video includes the correct object but performs the wrong action, or vice versa.
+            - 2: The video follows the instruction and shows a tendency toward the intended goal.
+            - 3: The video follows the instruction precisely and successfully achieves the goal.
+            
+            Let's analyze step-by-step and conclude with 'Score: [score]'.
+        """.strip(),
+        
+        EvaluationType.PHYSICAL_LAWS.value: """
+            Watch the video and determine if it shows any '{physical_laws}'
+            Let's think step-by-step and conclude with "Yes" or "No".
+        """.strip(),
+        
+        EvaluationType.COMMON_SENSE.value: """
+            Does the video exhibit '{common_sense}'?
+            Let's think step-by-step and conclude with "Yes" or "No".
+        """.strip(),
+    }
+
+    QUESTION_POOL: Dict[str, Optional[List[str]]] = {
+        EvaluationType.INSTRUCTION.value: None,
+        EvaluationType.PHYSICAL_LAWS.value: [
+            "Violation of Newton's Law: Objects move without any external force.",
+            "Violation of the Law of Conservation of Mass or Solid Constitutive Law: Objects deform irregularly.",
+            "Violation of Fluid Constitutive Law: Liquids flow in an unnatural manner.",
+            "Violation of Non-physical Penetration: Objects unnaturally pass through each other.",
+            "Violation of Gravity: Objects behave inconsistently with gravity.",
+        ],
+        EvaluationType.COMMON_SENSE.value: [
+            "Poor Aesthetics: Visually unappealing or low-quality content.",
+            "Temporal Inconsistency: Noticeable flickering or abrupt changes.",
+        ],
+    }
+
+
+class WorldModelEvaluator:
+    """Evaluates world model benchmark videos using LLaVA model."""
+    
+    def __init__(self, judge_path: str, video_dir: str, config: EvaluationConfig):
+        self.judge = self._load_judge(judge_path)
+        self.video_dir = Path(video_dir)
+        self.config = config
+        self.logger = logging.getLogger(__name__)
+
+    @staticmethod
+    def _load_judge(judge_path: str):
+        """Load the LLaVA judge model."""
+        import llava
+        return llava.load(judge_path)
+
+    def _load_video(self, video_name: str) -> Optional['llava.Video']:
+        """Load a video file for evaluation."""
+        video_path = self.video_dir / f"{video_name}.mp4"
+        if not video_path.exists():
+            self.logger.warning(f"Video not found: {video_path}")
+            return None
+        import llava
+        return llava.Video(str(video_path))
+
+    def evaluate_video(self, video: 'llava.Video', prompt: str, cot: bool = True) -> str:
+        """Generate evaluation content for a video."""
+        if not cot:
+            prompt = prompt.replace(
+                "Let's think step-by-step and conclude with", "Answer with"
+            ).replace(
+                "Let's analyze step-by-step and conclude with", "Answer with"
+            )
+        return self.judge.generate_content([video, prompt])
+
+    def process_results(self, preds: Dict, accs: defaultdict) -> float:
+        """Process and print evaluation results."""
+        num_insts = len(preds)
+        total_score = 0
+        
+        category_mapping = {
+            2: [("framewise", "temporal")],
+            5: [("newton", "mass", "fluid", "penetration", "gravity")],
+        }
+
+        for category, scores in accs.items():
+            print(f"\n{category} details:")
+            num_sub = len(scores) // num_insts
+            
+            if num_sub == 1:
+                mean_score = np.mean(scores)
+                print(f"-- overall score: {mean_score:.2f}")
+                total_score += mean_score
+            elif num_sub in category_mapping:
+                sub_scores = []
+                for i, sub in enumerate(category_mapping[num_sub][0]):
+                    sub_mean = np.mean(scores[i::num_sub])
+                    print(f"-- {sub} score: {sub_mean:.2f}")
+                    sub_scores.append(sub_mean)
+                overall_mean = np.mean(sub_scores)
+                print(f"-- overall score: {overall_mean:.2f}")
+                total_score += overall_mean
+            else:
+                raise ValueError(f"Unexpected number of subcategories: {num_sub}")
+
+        return total_score
+
+def main():
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Evaluate World Model Benchmark")
+    parser.add_argument("--judge", type=str, required=True, help="Path to judge model checkpoint")
+    parser.add_argument("--video_dir", type=str, required=True, help="Path to generated video directory")
+    parser.add_argument("--save_name", type=str, required=True, help="Path to save evaluation results")
+    parser.add_argument("--cot", action="store_true", help="Enable Chain-of-Thought output")
+    
     args = parser.parse_args()
+    
+    # Setup logging
+    logging.basicConfig(level=logging.INFO)
+    logger = logging.getLogger(__name__)
 
+    # Initialize evaluator
+    config = EvaluationConfig()
+    evaluator = WorldModelEvaluator(args.judge, args.video_dir, config)
+    
+    # Load validation set
     validation_set = load("./worldmodelbench.json")
-    if args.cot:
-        args.save_name += "_cot"
-    results = None
-    if os.path.exists(args.save_name):
-        results = load(args.save_name)
+    
+    # Check for existing results
+    save_path = f"{args.save_name}_cot" if args.cot else args.save_name
+    if os.path.exists(save_path):
+        results = load(save_path)
         try:
-            preds = results["preds"]
-            accs = results["accs"]
-        except:
-            raise "Expected keys are not found in the results."
+            preds, accs = results["preds"], results["accs"]
+        except KeyError:
+            raise KeyError("Expected keys not found in results file")
     else:
-        model = llava.load(args.judge)
-
-        preds = dict()
+        preds = {}
         accs = defaultdict(list)
+        
         for vid, v_i in tqdm(enumerate(validation_set), total=len(validation_set)):
-            ## Load video
-            video_name = v_i["first_frame"].split("/")[-1].split(".")[0]
-            video = os.path.join(args.video_dir, video_name + ".mp4")
-            if not os.path.exists(video):
+            video_name = Path(v_i["first_frame"]).stem
+            video = evaluator._load_video(video_name)
+            if not video:
                 continue
-            video = llava.Video(video)
-            ## Traverse criterions
-            for k in ["instruction", "physical_laws", "common_sense"]:
+                
+            for eval_type in EvaluationType:
                 preds_i = []
-                prompt_template = PROMPT_TEMPLATES[k]
-                qs = QUESTION_POOL[k]
-                if qs is not None:
+                prompt_template = config.PROMPT_TEMPLATES[eval_type.value]
+                questions = config.QUESTION_POOL[eval_type.value]
+                
+                if questions:
                     accs_i = []
-                    for q in qs:
-                        if k == "physical_laws":
-                            text_prompt = prompt_template.format(
-                                physical_laws=q.lower()
-                            )
-                        else:
-                            text_prompt = prompt_template.format(common_sense=q.lower())
-                        if not args.cot:
-                            text_prompt = text_prompt.replace(
-                                "Let's think step-by-step and conclude with",
-                                "Answer with",
-                            ).replace(
-                                "Let's analyze step-by-step and conclude with",
-                                "Answer with",
-                            )
-                        pred = model.generate_content([video, text_prompt])
+                    for question in questions:
+                        format_kwargs = {
+                            f"{eval_type.value}": question.lower()
+                        }
+                        prompt = prompt_template.format(**format_kwargs)
+                        pred = evaluator.evaluate_video(video, prompt, args.cot)
                         preds_i.append(pred)
-                        ## Always ask for violations, so a "No" is preferred!
                         accs_i.append("no" in pred.lower())
-                    accs[k].extend(accs_i)
+                    accs[eval_type.value].extend(accs_i)
                 else:
-                    text_prompt = prompt_template.format(
-                        instruction=v_i["text_instruction"]
-                    )
-                    if not args.cot:
-                        text_prompt = text_prompt.replace(
-                            "Let's think step-by-step and conclude with", "Answer with"
-                        ).replace(
-                            "Let's analyze step-by-step and conclude with",
-                            "Answer with",
-                        )
-                    pred = model.generate_content([video, text_prompt])
+                    prompt = prompt_template.format(instruction=v_i["text_instruction"])
+                    pred = evaluator.evaluate_video(video, prompt, args.cot)
                     preds_i.append(pred)
                     try:
                         score = float(pred.split(":")[-1].strip(" ."))
-                    except:
+                    except ValueError:
+                        logger.warning(f"Could not parse score from prediction: {pred}")
                         score = 0
-                    accs[k].append(score)
+                    accs[eval_type.value].append(score)
+                
                 if video_name not in preds:
-                    preds[video_name] = dict()
-                preds[video_name][k] = preds_i
-    ## Save results
-    # if results is None:
-    #     results = {"preds": preds, "accs": accs}
-    #     dump(results, f"./{args.save_name}.json", indent=4)
-    ## Print results
-    num_insts = len(preds)
-    total_score = 0
-    for k, v in accs.items():
-        print(k + " details:")
-        num_sub = len(v) // num_insts
-        if num_sub == 1:
-            print(f"-- overall score: {np.mean(v):.2f}.")
-            total_score += np.mean(v)
-        elif num_sub == 2:
-            sub_scores = []
-            for i, sub in enumerate(["framewise", "temporal"]):
-                print(f"-- {sub} score: {np.mean(v):.2f}.")
-                sub_scores.append(np.mean(v))
-            print(f"-- overall score: {np.mean(sub_scores):.2f}.")
-            total_score += np.mean(sub_scores)
-        elif num_sub == 5:
-            sub_scores = []
-            for i, sub in enumerate(
-                ["newton", "mass", "fluid", "penetration", "gravity"]
-            ):
-                print(f"-- {sub} score: {np.mean(v):.2f}.")
-                sub_scores.append(np.mean(v))
-            print(f"-- overall score: {np.mean(sub_scores):.2f}.")
-            total_score += np.mean(sub_scores)
-        else:
-            raise ValueError("Unexpected number of subcategories!")
-
-    print(f"\ntotal score: {total_score:.2f}.")
+                    preds[video_name] = {}
+                preds[video_name][eval_type.value] = preds_i
 
+    # Process and display results
+    total_score = evaluator.process_results(preds, accs)
+    print(f"\nTotal score: {total_score:.2f}")
+
+if __name__ == "__main__":
+    main()