Upload eval.py

eval.py

@@ -0,0 +1,174 @@
+import json
+import os
+from datetime import datetime
+
+import torch
+from transformers import AutoProcessor, Qwen2_5_VLForConditionalGeneration
+
+from qwen_vl_utils import process_vision_info
+
+MODEL_PATH = os.environ.get("QWEN_VL_MODEL_PATH", "./qwen2_5_vl_model")
+DEFAULT_INPUT_JSON = os.environ.get("EVAL_INPUT_JSON", "test.json")
+DEFAULT_OUTPUT_JSON = os.environ.get("EVAL_OUTPUT_JSON", "results/qwen_sft_eval_results.json")
+
+model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+    MODEL_PATH, torch_dtype="auto", device_map="auto"
+)
+processor = AutoProcessor.from_pretrained(MODEL_PATH)
+
+
+def build_prompt(action):
+    return (
+        "Given a video and an action description, reply with one of the following options ONLY:\n"
+        "- 'yes' if the action is completed,\n"
+        "- 'no' if the action is not completed,\n"
+        "- 'Not exists' if the action in the video does not match the given action.\n\n"
+        f"Action: {action}"
+    )
+
+
+def call_qwen_vl_with_video(prompt, video_path, max_pixels=151200, fps=0.5):
+    if not os.path.exists(video_path):
+        print(f"[error] Video not found: {video_path}")
+        return "Error: Video not found"
+    try:
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "video",
+                        "video": f"file://{video_path}",
+                        "max_pixels": max_pixels,
+                        "fps": fps,
+                    },
+                    {"type": "text", "text": prompt},
+                ],
+            }
+        ]
+        text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+        image_inputs, video_inputs = process_vision_info(messages)
+        inputs = processor(
+            text=[text],
+            images=image_inputs,
+            videos=video_inputs,
+            fps=fps,
+            padding=True,
+            return_tensors="pt",
+        ).to(model.device)
+        generated_ids = model.generate(**inputs, max_new_tokens=20)
+        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
+        )
+        return output_text[0].strip().lower()
+    except Exception as exc:
+        print(f"[error] Failed to process {video_path}: {exc}")
+        return "Error: Video processing failed"
+
+
+def get_processed_videos(output_json_path):
+    if not os.path.exists(output_json_path):
+        return set()
+    try:
+        with open(output_json_path, "r", encoding="utf-8") as file:
+            data = json.load(file)
+        return {item["video"] for item in data}
+    except (json.JSONDecodeError, FileNotFoundError):
+        return set()
+
+
+def save_result_json_list(output_path, result_entry):
+    result_entry["timestamp"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    if os.path.exists(output_path):
+        try:
+            with open(output_path, "r", encoding="utf-8") as file:
+                data = json.load(file)
+        except json.JSONDecodeError:
+            data = []
+    else:
+        data = []
+    data.append(result_entry)
+    with open(output_path, "w", encoding="utf-8") as file:
+        json.dump(data, file, indent=2, ensure_ascii=False)
+
+
+def evaluate(json_path, output_json_path):
+    processed_videos = get_processed_videos(output_json_path)
+    print(f"[info] Previously processed videos: {len(processed_videos)}")
+    with open(json_path, "r", encoding="utf-8") as file:
+        data = json.load(file)
+    total = 0
+    correct = 0
+    skipped = 0
+    for idx, item in enumerate(data):
+        video_path = item["video"]
+        action = item["action"]
+        ground_truth = item["if_finish"].strip().lower()
+        if video_path in processed_videos:
+            print(
+                f"[{idx + 1}/{len(data)}] Skip {os.path.basename(video_path)} (already processed)"
+            )
+            skipped += 1
+            continue
+        print(f"[{idx + 1}/{len(data)}] Process {os.path.basename(video_path)}")
+        if not os.path.exists(video_path):
+            print(f"[warning] Missing file: {video_path}")
+            continue
+        prompt = build_prompt(action)
+        prediction = call_qwen_vl_with_video(prompt, video_path)
+        if prediction.startswith("Error:"):
+            print(f"[warning] Skipping {video_path}: {prediction}")
+            continue
+        if "not exists" in prediction:
+            predicted_label = "Not exists"
+        elif "yes" in prediction:
+            predicted_label = "yes"
+        elif "no" in prediction:
+            predicted_label = "no"
+        else:
+            print(f"[warning] Unrecognized output: {prediction}")
+            predicted_label = "Unknown"
+        is_correct = predicted_label.lower() == ground_truth.lower()
+        result_entry = {
+            "video": video_path,
+            "action": action,
+            "ground_truth": ground_truth,
+            "prediction": predicted_label,
+            "raw_output": prediction,
+            "correct": is_correct,
+        }
+        save_result_json_list(output_json_path, result_entry)
+        total += 1
+        if is_correct:
+            correct += 1
+    if total > 0:
+        current_accuracy = correct / total
+        print(f"[session] Accuracy: {current_accuracy * 100:.2f}% ({correct}/{total})")
+    else:
+        print("[session] No new videos processed.")
+    processed_entries = get_processed_videos(output_json_path)
+    all_total = len(processed_entries)
+    if all_total > 0:
+        with open(output_json_path, "r", encoding="utf-8") as file:
+            results_data = json.load(file)
+        all_correct = sum(1 for item in results_data if item.get("correct", False))
+        overall_accuracy = all_correct / all_total
+        print(f"[overall] Accuracy: {overall_accuracy * 100:.2f}% ({all_correct}/{all_total})")
+        print(f"[overall] Skipped videos: {skipped}")
+
+
+def main():
+    json_path = DEFAULT_INPUT_JSON
+    output_json_path = DEFAULT_OUTPUT_JSON
+    output_dir = os.path.dirname(output_json_path)
+    if output_dir:
+        os.makedirs(output_dir, exist_ok=True)
+    print("Starting Qwen2.5-VL evaluation...")
+    evaluate(json_path, output_json_path)
+
+
+if __name__ == "__main__":
+    main()