Upload create_metadata_360_icl_v3.py with huggingface_hub

create_metadata_360_icl_v3.py

@@ -0,0 +1,530 @@
+import os
+import re
+import glob
+import json
+import random
+import argparse
+from tqdm import tqdm
+from pathlib import Path
+from collections import defaultdict
+
+def parse_ground_truth(name):
+    """Extract ground truth rotation axis and angle from filename or folder name"""
+    # Remove file extension if present
+    basename = name.split(".")[0] if "." in name else name
+    
+    parts = basename.split("_")
+    if len(parts) >= 4:  # figXXXX_XXX_axis_angle
+        rotation_axis = parts[-2]  # Second to last element is axis
+        rotation_angle = int(parts[-1])  # Last element is angle
+        
+        # Convert negative angles to 0-360 range
+        if rotation_angle < 0:
+            rotation_angle += 360
+            
+        return rotation_axis, rotation_angle
+    
+    print(f"Warning: Could not parse name: {basename}")
+    return None, None
+
+def load_examples(example_dir, generation_mode):
+    """Load example images from the example directory"""
+    if generation_mode == "combined":
+        # Load all single PNG files from the example directory
+        files = glob.glob(os.path.join(example_dir, "*.png"))
+        print(f"Found {len(files)} combined example images in {example_dir}")
+        return files
+    else:  # separate mode
+        # Find all folders in the example directory
+        folders = [f for f in glob.glob(os.path.join(example_dir, "*")) if os.path.isdir(f)]
+        # Filter folders that contain both _ini.png and _rot.png files
+        valid_folders = []
+        for folder in folders:
+            folder_name = os.path.basename(folder)
+            ini_file = os.path.join(folder, f"{folder_name}_ini.png")
+            rot_file = os.path.join(folder, f"{folder_name}_rot.png")
+            if os.path.exists(ini_file) and os.path.exists(rot_file):
+                valid_folders.append(folder)
+        
+        print(f"Found {len(valid_folders)} example folder pairs in {example_dir}")
+        return valid_folders
+
+def organize_examples(examples, generation_mode):
+    """Organize examples by rotation axis and angle"""
+    organized = defaultdict(list)
+    for example in examples:
+        basename = os.path.basename(example)
+        if generation_mode == "combined":
+            basename = basename.split(".")[0]
+            
+        axis, angle = parse_ground_truth(basename)
+        if axis is None or angle is None:
+            continue
+            
+        key = (axis, angle)
+        organized[key].append(example)
+    
+    # Print statistics
+    print("\nDistribution of examples by axis-angle:")
+    for key, examples_list in organized.items():
+        print(f"  {key[0]}-axis, {key[1]} degrees: {len(examples_list)} examples")
+    
+    return dict(organized)
+
+def select_examples(organized_examples, test_axis, possible_angles, max_examples=1):
+    """Select a single random example for the test case"""
+    # Collect all examples for this axis regardless of angle
+    all_examples_for_axis = []
+    for (axis, angle), example_list in organized_examples.items():
+        if axis == test_axis:
+            for example in example_list:
+                all_examples_for_axis.append((example, angle))
+    
+    # If we have any examples for this axis, select one randomly
+    examples = []
+    if all_examples_for_axis:
+        selected_example = random.choice(all_examples_for_axis)
+        examples.append(selected_example)
+    else:
+        print(f"Warning: No examples found for rotation around {test_axis}-axis")
+            
+    return examples
+
+def construct_icl_prompt(axis, possible_angles, icl_examples, difficulty="easy", generation_mode="combined"):
+    """Create prompt with in-context learning examples for the VLM"""
+    # Generate list of all possible rotation angles based on angle increment
+    '''possible_angles = []
+    current_angle = 0 + angle_increment
+    while current_angle < 360:
+        possible_angles.append(current_angle)
+        current_angle += angle_increment'''
+    
+    # Common instructions for both modes
+    coordinate_system = (
+        f"The 3D Cartesian coordinate system is defined as follows: "
+        f"\n- x-axis: points horizontally from left to right (positive direction is right)"
+        f"\n- y-axis: points vertically from bottom to top (positive direction is up)"
+        f"\n- z-axis: points from inside the image toward the viewer (positive direction is out of the screen)"
+        f"\n- The origin (0,0,0) is located at the geometric center of the 3D object mesh"
+        f"\n\nWhen discussing rotations around an axis, imagine looking along the positive direction of that axis (as if looking from the origin toward the positive end)."
+    )
+    
+    angle_constraints = (
+        f"The rotation angle is one of these specific values: {possible_angles} degrees. "
+        f"A positive angle means rotation in the CLOCKWISE direction when looking along the positive direction of the axis. "
+    )
+    
+    # Create example section of the prompt (singular!)
+    examples_text = "\n### EXAMPLE OF ROTATION ###\n"
+    for idx, (_, angle) in enumerate(icl_examples):
+        if generation_mode == "combined":
+            img_num = idx + 1
+            examples_text += f"\nExample: Image {img_num} shows a 3D object with its left half showing the initial view and right half showing a {angle} degree rotation around the {axis}-axis.\n"
+        else:  # separate mode
+            img_num_start = idx * 2 + 1
+            img_num_end = idx * 2 + 2
+            examples_text += f"\nExample: Image {img_num_start} shows the initial view and Image {img_num_end} shows the object after a {angle} degree rotation around the {axis}-axis.\n"
+    
+    # Different instructions based on difficulty
+    if difficulty == "easy":
+        # For easy mode - axis is provided
+        thinking_instructions = (
+            f"IMPORTANT: Please follow this systematic approach to determine the rotation angle:"
+            f"\n\n1. First, analyze the object's features in both views to understand its structure."
+            f"\n\n2. For the {axis}-axis rotation, you must evaluate ONLY these possible rotation angles: {possible_angles}"
+            f"\n   - For each angle in the list, describe what the object would look like after rotating around the {axis}-axis by that amount"
+            f"\n   - Compare these descriptions with the actual second view"
+            f"\n   - DO NOT make a decision until you have evaluated all possible angles in the list"
+            f"\n\n3. After evaluating all angles, choose the one that best matches the observed changes"
+            f"\n\n4. Verify your answer by mentally applying the rotation to confirm it matches the second view"
+        )
+        
+        response_format = (
+            f"Place your detailed reasoning process in <think></think> tags. Your reasoning should include:"
+            f"\n- Systematic evaluation of possible rotation angles from the provided list"
+            f"\n- Specific visual features you used to determine your answer"
+            f"\n\nThen provide your final answer in <rotation_angle></rotation_angle> tags (use only a number from the list for angle)."
+            f"\ni.e., <think> your reasoning process here </think><rotation_angle> your predicted degrees here </rotation_angle>"
+        )
+        
+        task_description = (
+            f"Your task is to determine the angle of rotation around the {axis}-axis in degrees."
+        )
+        
+    else:  # hard mode - axis is not provided
+        thinking_instructions = (
+            f"IMPORTANT: Please follow this systematic approach to determine the rotation:"
+            f"\n\n1. First, analyze the object's features in both views to understand its structure."
+            f"\n\n2. Consider what would happen if rotation occurred around each of the three axes (x, y, and z):"
+            f"\n   - For x-axis rotation: What specific features would change and how?"
+            f"\n   - For y-axis rotation: What specific features would change and how?"
+            f"\n   - For z-axis rotation: What specific features would change and how?"
+            f"\n   - Based on the observed changes, explain which axis makes the most sense and why."
+            f"\n\n3. Once you've determined the most likely axis, evaluate ALL of these possible rotation angles: {possible_angles}"
+            f"\n   - For each angle in the list, describe what the object would look like after rotating around your chosen axis by that amount"
+            f"\n   - Compare these descriptions with the actual second view"
+            f"\n   - DO NOT make a decision until you have evaluated all angles in the list"
+            f"\n\n4. After evaluating all angles, choose the one that best matches the observed changes"
+        )
+        
+        response_format = (
+            f"Place your detailed reasoning process in <think></think> tags. Your reasoning should include:"
+            f"\n- Analysis of how rotation around each axis would affect the object"
+            f"\n- Systematic evaluation of possible rotation angles from the provided list"
+            f"\n- Specific visual features you used to determine your answer"
+            f"\n\nThen provide your final answer in <rotation_axis></rotation_axis> and <rotation_angle></rotation_angle> tags respectively (use only x, y, or z for axis and only a number from the list for angle)."
+            f"\ni.e., <think> your reasoning process here </think><rotation_axis> your predicted axis here </rotation_axis><rotation_angle> your predicted degrees here </rotation_angle>"
+        )
+        
+        task_description = (
+            f"Your task is to determine which axis the object was rotated around and by what angle."
+        )
+    
+    # Generate the prompt based on generation mode
+    if generation_mode == "combined":
+        test_img_num = len(icl_examples) + 1
+        prompt = (
+            f"IMPORTANT: I'm showing you multiple images of 3D objects. "
+            f"The test case (final image) contains TWO separate 3D renderings side-by-side. "
+            f"\n\nThe LEFT HALF shows a 3D object in its initial orientation. "
+            f"The RIGHT HALF shows the SAME 3D object after being rotated. "
+            f"\n\nYour task is to determine the angle of rotation around the {axis}-axis in degrees."            
+            f"\n\n{coordinate_system}"
+            f"\n\n{angle_constraints}"            
+            f"\n\n{examples_text}"            
+            f"\n\n### YOUR TASK ###"
+            f"\nNow, for Image {test_img_num}, determine the angle of rotation around the {axis}-axis."
+            f"\nBased on the examples provided, analyze Image {test_img_num} carefully."            
+            f"\n\n{thinking_instructions}"            
+            f"\n\n{response_format}"
+        )
+    else:  # separate mode
+        test_img_start = len(icl_examples) * 2 + 1
+        test_img_end = len(icl_examples) * 2 + 2
+        prompt = (
+            f"I'm showing you multiple images of 3D objects. "
+            f"For each example or test case, two images represent the same object before and after rotation."
+            f"\n\nYour task is to determine the angle of rotation around the {axis}-axis in degrees."            
+            f"\n\n{coordinate_system}"
+            f"\n\n{angle_constraints}"           
+            f"\n\n{examples_text}"            
+            f"\n\n### YOUR TASK ###"
+            f"\nNow, determine the angle of rotation around the {axis}-axis from Image {test_img_start} to Image {test_img_end}."
+            f"\nBased on the examples provided, analyze the rotation carefully."            
+            f"\n\n{thinking_instructions}"            
+            f"\n\n{response_format}"
+        )
+            
+    return prompt
+
+def create_metadata_jsonl_combined_icl(input_dir, example_dir, output_file, possible_angles=[45, 315], difficulty="easy", max_examples=3):
+    """Create metadata JSONL file for all images in input_dir with in-context learning examples (combined mode)"""
+    # Get all PNG files in the input directory
+    png_files = glob.glob(os.path.join(input_dir, "*.png"))
+    
+    # Sort files to ensure consistent order
+    png_files = sorted(png_files)
+    
+    if not png_files:
+        print(f"No PNG files found in {input_dir}")
+        return
+    
+    print(f"Found {len(png_files)} PNG files in {input_dir}")
+    
+    # Load example images
+    examples = load_examples(example_dir, "combined")
+    
+    # Organize examples by axis and angle
+    organized_examples = organize_examples(examples, "combined")
+    
+    # Create output directory if it doesn't exist
+    output_dir = os.path.dirname(output_file)
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Get the last folder name from the input directory
+    last_folder = os.path.basename(os.path.normpath(input_dir))
+    
+    # Define the target base directory
+    target_base_dir = f"/lustre/fsw/portfolios/av/users/shiyil/yunfei/MM-EUREKA/data/{last_folder}"
+    
+    # Example directory - assume it's the "examples" subdirectory of input_dir
+    target_example_dir = f"{target_base_dir}/examples"
+    
+    # Generate list of all possible rotation angles
+    '''possible_angles = []
+    current_angle = 0 + angle_increment
+    while current_angle < 360:
+        possible_angles.append(current_angle)
+        current_angle += angle_increment'''
+    
+    # Process each file and create metadata entries
+    entries = []
+    
+    for png_file in tqdm(png_files, desc="Creating metadata for combined mode with ICL"):
+        # Parse ground truth from filename
+        axis, angle = parse_ground_truth(os.path.basename(png_file))
+        
+        if axis is None or angle is None:
+            print(f"Skipping {png_file} - could not parse ground truth")
+            continue
+        
+        # Get the basename
+        basename = os.path.basename(png_file)
+        
+        # Create the new image path for the target system
+        target_image_path = f"{target_base_dir}/{basename}"
+        
+        # Select in-context examples for this test case
+        icl_examples = select_examples(organized_examples, axis, possible_angles, max_examples)
+        
+        # Skip if no examples found
+        if not icl_examples:
+            print(f"Skipping {png_file} - no suitable examples found")
+            continue
+            
+        # Construct prompt with in-context examples
+        prompt = construct_icl_prompt(axis, possible_angles, icl_examples, difficulty, generation_mode="combined")
+        
+        # Create answer format based on difficulty WITH image path
+        if difficulty == "easy":
+            # For easy mode, only include angle in the answer (axis is provided in the prompt)
+            answer = f"<angle>{angle}</angle><image_path>{target_image_path}</image_path>"
+        else:
+            # For hard mode, include both axis and angle
+            answer = f"<axis>{axis}</axis><angle>{angle}</angle><image_path>{target_image_path}</image_path>"
+        
+        # Create content array with example images and test image
+        content = []
+        
+        # Add example images
+        for example_path, _ in icl_examples:
+            example_basename = os.path.basename(example_path)
+            target_example_path = f"{target_example_dir}/{example_basename}"
+            content.append({"type": "image", "image": target_example_path})
+        
+        # Add test image
+        content.append({"type": "image", "image": target_image_path})
+        
+        # Add prompt text
+        content.append({"type": "text", "text": prompt})
+        
+        # Create entry with the content array
+        entry = {
+            "message": json.dumps([{
+                "role": "user",
+                "content": content
+            }]),
+            "answer": answer
+        }
+        
+        entries.append(entry)
+    
+    # Write entries to JSONL file
+    with open(output_file, 'w') as f:
+        for entry in entries:
+            f.write(json.dumps(entry) + '\n')
+    
+    print(f"\nSummary for combined mode with ICL:")
+    print(f"  Found {len(png_files)} PNG files")
+    print(f"  Created metadata for {len(entries)} entries")
+    print(f"  Output file: {output_file}")
+    print(f"  Image paths are set to: {target_base_dir}/[filename].png")
+    print(f"  Example paths are set to: {target_example_dir}/[filename].png")
+
+def create_metadata_jsonl_separate_icl(input_dir, example_dir, output_file, possible_angles=[45, 315], difficulty="easy", max_examples=3):
+    """Create metadata JSONL file for folders in input_dir with in-context learning examples (separate mode)"""
+    # Get all directories in the input directory (excluding the examples directory)
+    folders = [f for f in glob.glob(os.path.join(input_dir, "*")) 
+              if os.path.isdir(f) and os.path.basename(f) != "examples"]
+    
+    # Sort folders to ensure consistent order
+    folders = sorted(folders)
+    
+    if not folders:
+        print(f"No folders found in {input_dir}")
+        return
+    
+    print(f"Found {len(folders)} folders in {input_dir}")
+    
+    # Load example folders
+    examples = load_examples(example_dir, "separate")
+    
+    # Organize examples by axis and angle
+    organized_examples = organize_examples(examples, "separate")
+    
+    # Create output directory if it doesn't exist
+    output_dir = os.path.dirname(output_file)
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Get the last folder name from the input directory
+    last_folder = os.path.basename(os.path.normpath(input_dir))
+    
+    # Define the target base directory
+    target_base_dir = f"/lustre/fsw/portfolios/av/users/shiyil/yunfei/MM-EUREKA/data/{last_folder}"
+    
+    # Example directory is always a subdirectory called 'examples'
+    target_example_dir = f"{target_base_dir}/examples"
+    
+    # Generate list of all possible rotation angles
+    '''possible_angles = []
+    current_angle = 0 + angle_increment
+    while current_angle < 360:
+        possible_angles.append(current_angle)
+        current_angle += angle_increment'''
+    
+    # Process each folder and create metadata entries
+    entries = []
+    valid_folders = 0
+    
+    for folder in tqdm(folders, desc="Creating metadata for separate mode with ICL"):
+        folder_name = os.path.basename(folder)
+        
+        # Parse ground truth from folder name
+        axis, angle = parse_ground_truth(folder_name)
+        
+        if axis is None or angle is None:
+            print(f"Skipping {folder} - could not parse ground truth")
+            continue
+        
+        # Check for the two required images in the folder
+        ini_path = os.path.join(folder, f"{folder_name}_ini.png")
+        rot_path = os.path.join(folder, f"{folder_name}_rot.png")
+        
+        if not os.path.exists(ini_path):
+            print(f"Skipping {folder} - missing initial view image")
+            continue
+            
+        if not os.path.exists(rot_path):
+            print(f"Skipping {folder} - missing rotated view image")
+            continue
+        
+        # Create target paths for remote system
+        target_folder_path = f"{target_base_dir}/{folder_name}"
+        target_ini_path = f"{target_folder_path}/{folder_name}_ini.png"
+        target_rot_path = f"{target_folder_path}/{folder_name}_rot.png"
+        
+        # Select in-context examples for this test case
+        icl_examples = select_examples(organized_examples, axis, possible_angles, max_examples)
+        
+        # Skip if no examples found
+        if not icl_examples:
+            print(f"Skipping {folder} - no suitable examples found")
+            continue
+            
+        # Construct prompt with in-context examples
+        prompt = construct_icl_prompt(axis, possible_angles, icl_examples, difficulty, generation_mode="separate")
+        
+        # Create answer format based on difficulty WITH folder path
+        if difficulty == "easy":
+            # For easy mode, only include angle in the answer (axis is provided in the prompt)
+            answer = f"<angle>{angle}</angle><image_path>{target_folder_path}</image_path>"
+        else:
+            # For hard mode, include both axis and angle
+            answer = f"<axis>{axis}</axis><angle>{angle}</angle><image_path>{target_folder_path}</image_path>"
+        
+        # Create content array with example images and test images
+        content = []
+        
+        # Add example image pairs
+        for example_folder, _ in icl_examples:
+            example_name = os.path.basename(example_folder)
+            target_example_ini = f"{target_example_dir}/{example_name}/{example_name}_ini.png"
+            target_example_rot = f"{target_example_dir}/{example_name}/{example_name}_rot.png"
+            
+            content.append({"type": "image", "image": target_example_ini})
+            content.append({"type": "image", "image": target_example_rot})
+        
+        # Add test image pair
+        content.append({"type": "image", "image": target_ini_path})
+        content.append({"type": "image", "image": target_rot_path})
+        
+        # Add prompt text
+        content.append({"type": "text", "text": prompt})
+        
+        # Create entry with both image paths
+        entry = {
+            "message": json.dumps([{
+                "role": "user",
+                "content": content
+            }]),
+            "answer": answer
+        }
+        
+        entries.append(entry)
+        valid_folders += 1
+    
+    # Write entries to JSONL file
+    with open(output_file, 'w') as f:
+        for entry in entries:
+            f.write(json.dumps(entry) + '\n')
+    
+    print(f"\nSummary for separate mode with ICL:")
+    print(f"  Found {len(folders)} folders")
+    print(f"  Created metadata for {valid_folders} valid folders")
+    print(f"  Output file: {output_file}")
+    print(f"  Image paths format: {target_base_dir}/[folder_name]/[folder_name]_[ini/rot].png")
+    print(f"  Example paths format: {target_example_dir}/[folder_name]/[folder_name]_[ini/rot].png")
+
+def main():
+    parser = argparse.ArgumentParser(description="Create metadata JSONL for rotation dataset with in-context learning")
+    parser.add_argument('--input-dir', type=str, required=True,
+                      help="Directory containing rotation dataset images or folders")
+    parser.add_argument('--example-dir', type=str, required=True,
+                      help="Directory containing example images or folders for in-context learning")
+    parser.add_argument('--output-file', type=str, default="rotation_metadata_icl.jsonl",
+                      help="Output JSONL file path")
+    parser.add_argument('--possible-angles', type=int, nargs='+', default=[45, 315],
+                      help="List of possible rotation angles in degrees (e.g., 45 315)")
+    parser.add_argument('--difficulty', type=str, choices=["easy", "hard"], default="easy",
+                      help="Difficulty mode: easy (axis provided) or hard (axis not provided)")
+    parser.add_argument('--generation-mode', type=str, choices=["combined", "separate"], default="combined",
+                      help="Mode for dataset generation (combined = one image with both views, separate = folder with two images)")
+    parser.add_argument('--max-examples', type=int, default=1,
+                      help="Maximum number of examples to include for each test case (default: 1)")
+    parser.add_argument('--random-seed', type=int, default=None,
+                      help="Random seed for example selection (None for true randomness)")
+    
+    args = parser.parse_args()
+    
+    # Set random seed for reproducibility (or use None for true randomness)
+    random.seed(args.random_seed)
+    
+    print(f"Creating metadata JSONL for rotation dataset with in-context learning:")
+    print(f"Input directory: {args.input_dir}")
+    print(f"Example directory: {args.example_dir}")
+    print(f"Output file: {args.output_file}")
+    print(f"Possible angles: {args.possible_angles}")
+    print(f"Difficulty mode: {args.difficulty}")
+    print(f"Generation mode: {args.generation_mode}")
+    print(f"Max examples per test case: {args.max_examples}")
+    
+    if args.random_seed is not None:
+        print(f"Using fixed random seed: {args.random_seed}")
+    else:
+        print("Using true randomness (different examples selection each run)")
+
+    # Fix the indentation error here:
+    if args.example_dir is None and os.path.exists(os.path.join(args.input_dir, "examples")):
+        args.example_dir = os.path.join(args.input_dir, "examples")
+        print(f"Using examples directory: {args.example_dir}")
+    
+    if args.generation_mode == "combined":
+        create_metadata_jsonl_combined_icl(
+            input_dir=args.input_dir,
+            example_dir=args.example_dir,
+            output_file=args.output_file,
+            possible_angles=args.possible_angles,  # Updated from angle_increment
+            difficulty=args.difficulty,
+            max_examples=args.max_examples
+        )
+    else:  # separate mode
+        create_metadata_jsonl_separate_icl(
+            input_dir=args.input_dir,
+            example_dir=args.example_dir,
+            output_file=args.output_file,
+            possible_angles=args.possible_angles,  # Updated from angle_increment
+            difficulty=args.difficulty,
+            max_examples=args.max_examples
+        )
+if __name__ == "__main__":
+    main()