Formatted.

evaluation.py

@@ -20,7 +20,7 @@ class EvaluationType(Enum):
 @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}'.
@@ -33,12 +33,10 @@ class EvaluationConfig:
             
             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".
@@ -63,7 +61,7 @@ class EvaluationConfig:
 
 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)
@@ -74,32 +72,34 @@ class WorldModelEvaluator:
     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']:
+    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:
+    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"
-            )
+            ).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")],
@@ -108,7 +108,7 @@ class WorldModelEvaluator:
         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}")
@@ -127,17 +127,26 @@ class WorldModelEvaluator:
 
         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")
-    
+    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__)
@@ -145,10 +154,10 @@ def main():
     # Initialize evaluator
     config = EvaluationConfig()
     evaluator = WorldModelEvaluator(args.judge, args.video_dir, config)
-    
+
     # Load validation set
     validation_set = load("./worldmodelbench.json")
-    
+
     # Check for existing results
     save_path = f"{args.save_name}_cot" if args.cot else args.save_name
     if os.path.exists(save_path):
@@ -160,24 +169,22 @@ def main():
     else:
         preds = {}
         accs = defaultdict(list)
-        
+
         for vid, v_i in tqdm(enumerate(validation_set), total=len(validation_set)):
             video_name = Path(v_i["first_frame"]).stem
             video = evaluator._load_video(video_name)
             if not video:
                 continue
-                
+
             for eval_type in EvaluationType:
                 preds_i = []
                 prompt_template = config.PROMPT_TEMPLATES[eval_type.value]
                 questions = config.QUESTION_POOL[eval_type.value]
-                
+
                 if questions:
                     accs_i = []
                     for question in questions:
-                        format_kwargs = {
-                            f"{eval_type.value}": question.lower()
-                        }
+                        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)
@@ -193,7 +200,7 @@ def main():
                         logger.warning(f"Could not parse score from prediction: {pred}")
                         score = 0
                     accs[eval_type.value].append(score)
-                
+
                 if video_name not in preds:
                     preds[video_name] = {}
                 preds[video_name][eval_type.value] = preds_i
@@ -202,5 +209,6 @@ def main():
     total_score = evaluator.process_results(preds, accs)
     print(f"\nTotal score: {total_score:.2f}")
 
+
 if __name__ == "__main__":
     main()