Upload 33 files

script/README.md

@@ -0,0 +1,58 @@
+## **Installation**
+
+- Install PyTorch
+- Install required Python packages:
+
+```bash
+pip install datasets
+pip install huggingface_hub
+pip install ultralytics
+```
+
+## Basic usage: Run the Filtering on WIT-base
+
+Run the Filtering with Command-Line Arguments
+
+
+```bash
+python wit_filter.py --device cuda:0 --batch_size 32 --output_filtered_data_file_path /path/to/filtered_data_file.parquet
+```
+
+- `--device`: Set to "cpu" if GPU is unavailable (default: cuda:0)
+- `--batch_size`: Adjust based on your available memory (default: 32)
+- `--output_filtered_data_file_path`: Path to save the filtered results (default: filtered_data_file.parquet)
+
+The filtered dataset will be saved at the path specified by `--output_filtered_data_file_path`.
+
+## Evaluation Mode Usage: Evaluate Detection Performance on WIT-base Subset
+
+A curated evaluation subset of 30 WIT-base images is included to evaluate the detection model performance.
+
+
+To enable evaluation mode and save filtered images into category-specific folders, use the `--eval_mode` flag and specify the image directory:
+
+```bash
+python wit_filter.py --device cuda:0 --batch_size 32 --output_filtered_data_file_path /path/to/filtered_data_file.parquet --eval_mode --filtered_image_dir path/to/image_filter_result_dir
+```
+
+- `--eval_mode`: Enable evaluation mode to save filtered images into category-specific folders
+- `--filtered_image_dir`: Directory where the filtered images will be saved (default: image_filter_result_dir)
+
+Filtered images will be organized into subfolders under `filtered_image_dir`:
+
+- `no_face/`: No valid face detected
+- `valid_face_no_glasses/`: Valid face detected, no glasses
+- `valid_face_with_eyeglasses/`: Valid face with eyeglasses
+- `valid_face_with_sunglasses/`: Valid face with sunglasses
+
+### Information about the Evaluation Data
+
+📎 `wit_eval_30.csv`: Metadata for the evaluation set.
+
+| Column | Description |
+| --- | --- |
+| `idx` | Index in the original WIT-base dataset |
+| `has_face` | 0 = No face or too small, 1 = Valid face |
+| `glasses_type` | 0 = No glasses, 1 = Eyeglasses, 2 = Sunglasses |
+
+📎 `data/`: Directory containing all 30 images in the evaluation subset.

script/wit_eval_30.csv

@@ -0,0 +1,31 @@
+idx, has_face, glasses_type
+1496,0,0
+1750,0,0
+1818,0,0
+1952,0,0
+2303,0,0
+3088,0,0
+3365,0,0
+3878,0,0
+3923,0,0
+541,1,0
+960,1,0
+1096,1,0
+1763,1,0
+2518,1,0
+2687,1,0
+3200,1,0
+5393,1,0
+5702,1,0
+990,1,1
+2246,1,1
+3298,1,1
+4596,1,1
+5401,1,1
+5578,1,1
+5754,1,1
+7397,1,1
+8879,1,1
+1116,1,2
+3239,1,2
+6754,1,2

script/wit_filter.py

@@ -0,0 +1,282 @@
+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()