script/wit_filter.py

import torch
import math
import os
import argparse
import logging

from datasets import load_dataset, Features, Sequence, Value, Image
from huggingface_hub import hf_hub_download
from ultralytics import YOLO, YOLOWorld

def parse_args() -> argparse.Namespace:
    """
    Parse command-line arguments for the WIT Data Filtering System.

    Returns:
        argparse.Namespace: Parsed arguments.
    """
    parser = argparse.ArgumentParser(description="WIT Data Filtering System")
    parser.add_argument('--device', type=str, default="cuda:0", help='Device to use for inference')
    parser.add_argument('--batch_size', type=int, default=32, help='Batch size for processing')
    parser.add_argument('--output_filtered_data_file_path', type=str, default="filtered_data_file.parquet", help='Path to save filtered data file')
    parser.add_argument('--eval_mode', action='store_true', help='Enable evaluation mode')
    parser.add_argument('--filtered_image_dir', type=str, default="image_filter_result_dir", help='Directory to save filtered images')
    return parser.parse_args()

# Evaluation data index in original wit dataset.
eval_data_no_face = [1496, 1750, 1818, 1952, 2303, 3088, 3365, 3878, 3923]
eval_data_have_face_no_glasses = [541, 960, 1096, 1763, 2518, 2687, 3200, 5393, 5702]
eval_data_have_face_with_eyeglasses = [990, 2246, 3298, 4596, 5401, 5578, 5754, 7397, 8879]
eval_data_have_face_with_sunglasses = [1116, 3239, 6754]
eval_data_idx = eval_data_no_face + eval_data_have_face_no_glasses + eval_data_have_face_with_eyeglasses + eval_data_have_face_with_sunglasses

# YOLOv8-face-detection Model: detect face
def load_yolo_face_model(device: str) -> YOLO:
    """
    Load the YOLOv8 face detection model.

    Args:
        device (str): Device to load the model on (e.g., 'cuda:0' or 'cpu').

    Returns:
        YOLO: Loaded YOLO face detection model.
    """
    yolo_face_model_path = hf_hub_download(repo_id="arnabdhar/YOLOv8-Face-Detection", filename="model.pt")
    return YOLO(yolo_face_model_path).to(device)

# YOLO-World Model: detect eyeglasses, sunglasses
def load_yolo_world_model(device: str) -> YOLOWorld:
    """
    Load the YOLO-World model for eyeglasses and sunglasses detection.

    Args:
        device (str): Device to load the model on (e.g., 'cuda:0' or 'cpu').

    Returns:
        YOLOWorld: Loaded YOLO-World model.
    """
    yolo_world_model = YOLOWorld("yolov8s-world.pt").to(device)
    yolo_world_model.set_classes(["eyeglasses", "sunglasses"])
    return yolo_world_model


def main() -> None:
    """
    Main function to run the WIT Data Filtering System. Handles argument parsing, model loading,
    dataset loading, detection, filtering, and saving results.
    """
    args = parse_args()
    device = args.device
    batch_size = args.batch_size
    output_filtered_data_file_path = os.path.abspath(os.path.expanduser(args.output_filtered_data_file_path))
    eval_mode = args.eval_mode
    filtered_image_dir = os.path.abspath(os.path.expanduser(args.filtered_image_dir))

    # Path for saving the filtered images in evaluation.
    img_dir_no_face = os.path.join(filtered_image_dir, "no_face")
    img_dir_valid_face_no_glasses = os.path.join(filtered_image_dir, "valid_face_no_glasses")
    img_dir_valid_face_with_eyeglasses = os.path.join(filtered_image_dir, "valid_face_with_eyeglasses")
    img_dir_valid_face_with_sunglasses = os.path.join(filtered_image_dir, "valid_face_with_sunglasses")

    save_filtered_image = eval_mode
    # If the dataset is big, force the save_filtered_image to be `False` (will be set after loading dataset).

    if save_filtered_image:
        os.makedirs(img_dir_no_face, exist_ok=True)
        os.makedirs(img_dir_valid_face_no_glasses, exist_ok=True)
        os.makedirs(img_dir_valid_face_with_eyeglasses, exist_ok=True)
        os.makedirs(img_dir_valid_face_with_sunglasses, exist_ok=True)

    # Load models
    yolo_face_model = load_yolo_face_model(device)
    yolo_world_model = load_yolo_world_model(device)
    face_yolo_threshold = 0.7
    eyeglasses_yolo_threshold = 0.25
    cls_idx_map = {"eyeglasses": 0, "sunglasses": 1}

    def detect_face_and_eyeglasses(examples, idx):
        """
        Detect faces, eyeglasses, and sunglasses in a batch of images.

        Args:
            examples (Dict[str, Any]): Batch of examples from the dataset, containing images.
            idx (List[int]): Indices of the images in the dataset.

        Returns:
            Dict[str, Any]: Detection results including image, glasses_score, glasses_box, face_score, face_box.
        """
        images = []
        for i, image in zip(idx, examples["image"]):
            try:
                image = image.convert("RGB")
                images.append(image)
            except Exception as e:
                logging.warning(f"Failed to load image at index {i}: {e}")
                images.append(None)
                continue
        # Detect faces for the image batch
        try:
            results_face = yolo_face_model.predict(images, conf=face_yolo_threshold, device=device, verbose=False)
        except Exception as e:
            logging.error(f"Face model inference failed for batch: {e}")
            # Return None for all images in this batch
            return {
                "image": images,
                "glasses_score": [None]*len(images),
                "glasses_box": [None]*len(images),
                "face_score": [None]*len(images),
                "face_box": [None]*len(images),
            }

        glasses_scores = []
        glasses_boxes = []
        face_scores = []
        face_boxes = []
        for i, image, result_face in zip(idx, images, results_face):
            # Iterate across the face detection result for each image.
            if image is None:
                logging.warning(f"Skip unvalid image at index {i}")
                glasses_scores.append(None)
                glasses_boxes.append(None)
                face_scores.append(None)
                face_boxes.append(None)
                continue

            # 1. No face detected.
            if len(result_face.boxes.cls) == 0:
                glasses_scores.append(None)
                glasses_boxes.append(None)
                face_scores.append(None)
                face_boxes.append(None)
                if save_filtered_image:
                    image.save(f"{img_dir_no_face}/{i}.jpg")
                continue

            # 2. Face detected.
            face_score = []
            face_box = []
            has_valid_face = False
            # Filter the face detection results based on the bbox size.
            for j in range(len(result_face.boxes.conf)):
                # Iterate across the detected face bboxes in current image.
                w, h = math.ceil(result_face.boxes.xywh[j, 2]), math.ceil(result_face.boxes.xywh[j, 3])
                if w >= 100 and h >= 100:
                    has_valid_face = True

                    score = result_face.boxes.conf[j]
                    box_xyxy = [int(x) for x in result_face.boxes.xyxy[j].tolist()]  # [x0, y0, x1, y1]
                    face_score.append(score)
                    face_box.append(box_xyxy)
                else:
                    continue

            # 3. Detected faces are all smaller than 100-px.
            if not has_valid_face:
                glasses_scores.append(None)
                glasses_boxes.append(None)
                face_scores.append(None)
                face_boxes.append(None)
                continue
            else:
                face_scores.append(torch.tensor(face_score))
                face_boxes.append(torch.tensor(face_box))

            # 4. Have at least one valid face.
            # Detect eyeglasses and sunglasses for the single image with valid face.
            try:
                result_eyeglasses = yolo_world_model.predict(image, conf=eyeglasses_yolo_threshold, device=device, verbose=False)[0]
            except Exception as e:
                logging.error(f"Eyeglasses model inference failed at index {i}: {e}")
                glasses_scores.append(None)
                glasses_boxes.append(None)
                continue
            # 5. No eyeglasses detected.
            if len(result_eyeglasses.boxes.cls) == 0:
                glasses_scores.append(None)
                glasses_boxes.append(None)
                if save_filtered_image:
                    image.save(f"{img_dir_valid_face_no_glasses}/{i}.jpg")
                continue

            glasses_score = []
            glasses_box = []
            is_eyeglasses = True
            for j in range(len(result_eyeglasses.boxes.conf)):
                # Iterate across the detected glasses bboxes in current image.
                category = result_eyeglasses.boxes.cls[j]
                if category == cls_idx_map["eyeglasses"]:
                    score = result_eyeglasses.boxes.conf[j]
                    box_xyxy = [int(x) for x in result_eyeglasses.boxes.xyxy[j].tolist()]  # [x0, y0, x1, y1]
                    glasses_score.append(score)
                    glasses_box.append(box_xyxy)
                elif category == cls_idx_map["sunglasses"]:
                    is_eyeglasses = False
                    break

            if not is_eyeglasses:
                # 6. Sunglasses detected, drop the eyeglasses bbox.
                glasses_scores.append(None)
                glasses_boxes.append(None)
                if save_filtered_image:
                    image.save(f"{img_dir_valid_face_with_sunglasses}/{i}.jpg")
            else:
                # 7. Sunglasses not detected, keep the eyeglasses bbox.
                glasses_scores.append(torch.tensor(glasses_score))  # [n]
                glasses_boxes.append(torch.tensor(glasses_box))  # [n, 4]
                if save_filtered_image:
                    image.save(f"{img_dir_valid_face_with_eyeglasses}/{i}.jpg")

        # No valid face: All of the four features are None.
        # Valid face without eyeglasses: "face_score" and "face_box" has value. "glasses_score" and "glasses_box" are None.
        # Valid face with eyeglasses: All of the four features are not None.
        return {
            "image": images,
            "glasses_score": glasses_scores,
            "glasses_box": glasses_boxes,
            "face_score": face_scores,
            "face_box": face_boxes,
        }

    # Load the first two shards of the wit-base dataset.
    base_url = "https://huggingface.co/datasets/wikimedia/wit_base/resolve/main/data/"
    data_files = {"train": [base_url + "train-00000-of-00330.parquet", base_url + "train-00001-of-00330.parquet"]}
    wit = load_dataset("parquet", data_files=data_files, split="train", trust_remote_code=True).cast_column('image', Image())

    # Select the curated subset for evaluation.
    if eval_mode:
        wit = wit.select(eval_data_idx)
        save_filtered_image = True

    # If the dataset is big, force the save_filtered_image to be `False`.
    if len(wit) > 1000:
        save_filtered_image = False

    # Define new columns to store detection results.
    features = {
        "image": Image(),
        "glasses_score": Sequence(feature=Value(dtype='float16', id=None), length=-1, id=None),
        "glasses_box": Sequence(feature=Sequence(feature=Value(dtype='int16', id=None), length=-1, id=None), length=-1, id=None),
        "face_score": Sequence(feature=Value(dtype='float16', id=None), length=-1, id=None),
        "face_box": Sequence(feature=Sequence(feature=Value(dtype='int16', id=None), length=-1, id=None), length=-1, id=None)
    }
    # Delete unrelated columns.
    remove_columns = wit.column_names
    remove_columns.remove("image")
    # Run the detection.
    wit = wit.map(
        detect_face_and_eyeglasses,
        with_indices=True,
        batched=True,
        batch_size=batch_size,
        features=Features(features),
        remove_columns=remove_columns
    )

    # Filter the dataset based on detection result.
    wit_filter = wit.filter(lambda example: example["glasses_score"])

    # Save the filtered dataset as parquet file.
    wit_filter.to_parquet(output_filtered_data_file_path)

if __name__ == "__main__":
    main()