Added Pixel

Individual-Contest/Pixel/Pixel.ipynb

@@ -0,0 +1,643 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "362e9f36-2300-4851-8f49-b952e62a2c78",
+   "metadata": {},
+   "source": [
+    "<img src=\"./figs/IOAI-Logo.png\" alt=\"IOAI Logo\" width=\"200\" height=\"auto\">\n",
+    "\n",
+    "[IOAI 2025 (Beijing, China), Individual Contest](https://ioai-official.org/china-2025)\n",
+    "\n",
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/IOAI-official/IOAI-2025/blob/main/Individual-Contest/Pixel/Pixel.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4509a190",
+   "metadata": {},
+   "source": [
+    "# Pixel Efficiency\n",
+    "\n",
+    "## 1. Problem Description\n",
+    "\n",
+    "You are a student in wildlife biology, working on a groundbreaking research project at the Starr Park Research Center. Your team has deployed thousands of camera traps across remote wilderness areas to monitor endangered species populations. However, the satellite internet connections in these remote locations have extremely limited bandwidth. Your job is to write code that identifies the most critical pixels in each wildlife photograph so that only the essential visual information needs to be transmitted back to headquarters.\n",
+    "\n",
+    "<img src=\"./figs/Pixel Fig 1.png\" width=\"400\">\n",
+    "\n",
+    "## 2. Dataset\n",
+    "\n",
+    "The dataset consists of a training set and a test set. Datasets are loaded using `load_from_disk`, and are in the format of `datasets`. Test set is not visible to the contestants.\n",
+    "\n",
+    "In the dataset there are the following fields:\n",
+    "\n",
+    "- `image`: the image are RGB full color images in PIL format, the size of each image is (224, 224)\n",
+    "- `name`: the animal species label\n",
+    "- `idx`: unique identifiers used to track the records.\n",
+    "\n",
+    "1. **Training Set (`train_dataset` folder)**:\n",
+    "    - The training set is used for training your models/ doing experimentations on and can be accessed and downloaded directly during the competition.\n",
+    "    - There are 700 images in the training set.\n",
+    "\n",
+    "2. **Test Set (`test_dataset` folder)**: \n",
+    "    - These follow the same format as the training set but do not contain the `name` field.\n",
+    "    - There are 698 images in test set, which had been separated into 2 testing sets within the ratio of 3:7, i.e. 30% of the data would be used to calculate the Leaderboard A score, another 70% data would be used to calculate the Leaderboard B score.\n",
+    "    - The testing set is used to calculate the Leaderboard A score and the Leaderboard B score and is not directly accessible during the competition. Contestants can access the result on Leaderboard A , but cannot access the result on Leaderboard B. The final score would be counted using Leaderboard B only. The subsets for Leaderboard A and Leaderboard B are completely distinct.\n",
+    "    \n",
+    "\n",
+    "## 3. Task\n",
+    "You are given a dataset of animal photographs and a CLIP model that can do a zero-shot classification of animal species. To conserve bandwidth, you need to retain at most **6.25%** of the pixels of each image, while keeping classification accuracy as high as possible.\n",
+    "\n",
+    "More specifically, your task is to return **one rectangle mask** for each image, which contain a single rectangular area indicating the area to keep. Each mask is defined by two coordinate tuples: one for the top-left corner and one for the bottom-right corner of the rectangle. Below is a visualization of what the image would look like after applying a rectangular mask using the process from the baseline:\n",
+    "\n",
+    "<img src=\"./figs/Pixel Fig 2.png\" width=\"400\">\n",
+    "\n",
+    "**Coordinate Convention:**\n",
+    "- Top-left corner coordinates are **inclusive** (the pixel at this position is included in the mask) \n",
+    "- Bottom-right corner coordinates are **exclusive** (the pixel at this position is NOT included in the mask)\n",
+    "\n",
+    "For example, if you specify coordinates `((10, 20), (15, 25))`, the mask will cover pixels from row 10 to 14 (inclusive) and column 20 to 24 (inclusive), for a total area of 25 pixels.\n",
+    "\n",
+    "As an illustration, if an image size is 3x3 and we wanted to keep only the top-right pixel using coordinates `((0, 2), (1, 3))`, the resulting binary mask would be:\n",
+    "\n",
+    "```\n",
+    "[[0, 0, 1],\n",
+    " [0, 0, 0],\n",
+    " [0, 0, 0]]\n",
+    "```\n",
+    "\n",
+    "Below is a summary of the requirements for your masks:\n",
+    "\n",
+    "- Return one rectangle mask defined by coordinate tuples: `((top, left), (bottom, right))`\n",
+    "- Top-left corner coordinates are inclusive, bottom-right corner coordinates are exclusive\n",
+    "- The rectangle mask should cover at most *6.25%* of the original pixels (minimum 93.75% reduction of the original pixels)\n",
+    "- All images are of size (224, 224), so coordinate values should be within the range [0, 224]\n",
+    "\n",
+    "\n",
+    "Images would be masked using the mask you created, outside the masked rectangle, all pixels outside the masked rectangle will be replaced with RGB(0, 0, 0) (black) values. The masked image will be then passed through the CLIP model during evaluation, and your task is to keep the classification accuracy of the CLIP model on these masked images as high as possible. **An additional `other` class would be added into the classes for classification** to ensure that your masked image retains actual useful information for the researchers back at Starr Park Headquarters. So for example, if your image doesn't contain any animal information, the model will predict the `others` class instead of predicting a random animal and having a chance of getting it correct.\n",
+    "\n",
+    "You need to work only with the provided CLIP model and dataset. As a reminder, CLIP generates representations for both text and image, and it can compute a similarity score between them. So if you have ten animal classes, CLIP can look at the provided image and decide which text (class) is closest to the image. \n",
+    "\n",
+    "To ensure that your solution would handle the traffic of images for the research center, your code should run in **UNDER 8 MINUTES for the 698 images in the test dataset**. It is recommended that you test your solution on the training set first, which contain 700 images, to understand how much time your solution takes (testing set would take slightly longer due to dataset loading).\n",
+    "\n",
+    "## 4. Submission\n",
+    "\n",
+    "Contestants need to submit a notebook file named `submission.ipynb`. The file should output a `.jsonl` file titled `submission.jsonl`, which contains all the generated masks for the dataset split. Each mask in the `submission.jsonl` file should be stored as a tuple of two coordinate tuples: `((top, left), (bottom, right))`, where the top-left corner is inclusive and the bottom-right corner is exclusive.\n",
+    "\n",
+    "Contestants don't need to separate test sets into Leaderboard A and Leaderboard B, the evaluation machine will read `submission.jsonl` and automatically calculate the scores for Leaderboard A and Leaderboard B based on the prediction results and true labels. \n",
+    "\n",
+    "The submission files must strictly follow the above format and naming; otherwise, the system will not be able to read them correctly. \n",
+    "\n",
+    "## 5. Score\n",
+    "\n",
+    "The evaluation metric will be **classification accuracy**, defined as the proportion of correctly predicted samples over the total number of evaluated samples.\n",
+    "\n",
+    "Your score is the zero-shot classification accuracy of CLIP on the masked test images. **If a submitted mask for an image is invalid (wrong shape, more than 6.25% pixels retained, etc.), that image is counted as incorrect. A sample script is provided to compute the training split score.**\n",
+    "\n",
+    "\n",
+    "## 6. Baseline and Training Set\n",
+    "\n",
+    "- Below you can find the baseline solution.\n",
+    "- The dataset is in `training_set` folder.\n",
+    "- The highest score by the Scientific Committee for this task is 0.83 in Leader Board B, this score is used for score unification.\n",
+    "- The baseline score by the Scientific Committee for this task is 0.19 in Leader Board B, this score is used for score unification."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d1ad03b-ba1e-4c24-b866-fe6a138b58c9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "\n",
+    "seed = 42\n",
+    "\n",
+    "random.seed(seed)                  # Python built-in random\n",
+    "np.random.seed(seed)               # NumPy\n",
+    "torch.manual_seed(seed)            # PyTorch (CPU)\n",
+    "torch.cuda.manual_seed(seed)       # PyTorch (single GPU)\n",
+    "torch.cuda.manual_seed_all(seed)   # PyTorch (all GPUs)\n",
+    "\n",
+    "# Ensures deterministic behavior\n",
+    "torch.backends.cudnn.deterministic = True\n",
+    "torch.backends.cudnn.benchmark = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "af37a8ed",
+   "metadata": {},
+   "source": [
+    "### Dependencies and Config Variables"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "23b68a41",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from collections import Counter\n",
+    "from PIL import Image\n",
+    "from tqdm import tqdm\n",
+    "import glob\n",
+    "import json\n",
+    "import math\n",
+    "import torch\n",
+    "import matplotlib.pyplot as plt\n",
+    "from datasets import load_dataset, load_from_disk\n",
+    "from transformers import CLIPProcessor, CLIPModel\n",
+    "from PIL import Image\n",
+    "from tqdm.auto import tqdm \n",
+    "\n",
+    "TRAIN_PATH = \"./training_set/\"\n",
+    "# The training set is deployed automatically in the testing machine. \n",
+    "# You notebook can access the TRAIN_PATH even if you do not mount it along with notebook.\n",
+    "\n",
+    "MODEL_PATH = \"./clip-vit-large-patch14\"\n",
+    "# The clip model is deployed automatically in the testing machine. \n",
+    "# You notebook can access the MODEL_PATH even if you do not mount it along with notebook.\n",
+    "\n",
+    "DATASET_PATH = TRAIN_PATH + \"train_dataset\"\n",
+    "SPLIT = \"train\"\n",
+    "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "BACKGROUND_CLASS = \"other\" # Class used to catch masked images that have no useful information, preventing completely off masks from \"guessing\" the answer from the 10 classes\n",
+    "\n",
+    "# Image and Masking Configuration\n",
+    "HEIGHT = 224\n",
+    "WIDTH = 224\n",
+    "RETAIN_RATIO = 0.0625  # Retain 6.25% of pixels\n",
+    "MEAN_COLOR = (0, 0, 0)  # RGB mean values for masked out areas\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b888c040",
+   "metadata": {},
+   "source": [
+    "### Dataset loading\n",
+    "\n",
+    "Let's first load the dataset in and see what's in it:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "857ab7ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the dataset\n",
+    "print(\"Loading dataset...\")\n",
+    "dataset_whole = load_from_disk(DATASET_PATH)\n",
+    "dataset = dataset_whole[SPLIT]\n",
+    "\n",
+    "# Print first item to check available fields\n",
+    "print(\"\\nFirst item keys:\")\n",
+    "print(dataset_whole[SPLIT][0].keys())\n",
+    "\n",
+    "# Show basic dataset statistics without converting fields yet\n",
+    "print(f\"\\nDataset loaded successfully!\")\n",
+    "print(f\"Total samples: {len(dataset)}\")\n",
+    "\n",
+    "print(f\"\\nSample item structure:\")\n",
+    "sample_item = dataset[0]\n",
+    "print(f\"  Keys: {list(sample_item.keys())}\")\n",
+    "print(f\"  Image type: {type(sample_item['image'])}\")\n",
+    "print(f\"  Image size: {sample_item['image'].size}\")\n",
+    "print(f\"  Index: {sample_item['idx']}\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "37c2dbfa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Visualize first 10 samples\n",
+    "fig, axes = plt.subplots(2, 5, figsize=(15, 8))\n",
+    "axes = axes.flatten()\n",
+    "\n",
+    "print(\"Visualizing first 10 samples...\")\n",
+    "\n",
+    "for i in range(10):\n",
+    "    sample = dataset[i]\n",
+    "    image = sample['image']\n",
+    "    label = sample['name']\n",
+    "    \n",
+    "    axes[i].imshow(image)\n",
+    "    axes[i].set_title(f\"{label}\\n\", fontsize=12)\n",
+    "    axes[i].axis('off')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.suptitle('First 10 Samples from Dataset', fontsize=16, y=1.02)\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "24cee96a",
+   "metadata": {},
+   "source": [
+    "### Model\n",
+    "\n",
+    "Now let's load the model and see some predictions:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fd92b376",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(f\"Loading CLIP model and processor: {MODEL_PATH}...\")\n",
+    "model = CLIPModel.from_pretrained(MODEL_PATH).to(DEVICE)\n",
+    "processor = CLIPProcessor.from_pretrained(MODEL_PATH)\n",
+    "print(\"Model and processor loaded successfully.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a2e25924",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image = dataset[0]['image']\n",
+    "# Visualize the image with its true label\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "plt.imshow(image)\n",
+    "plt.title(f\"Sample Image\\nTrue Label: {dataset[0]['name']}\", fontsize=14)\n",
+    "plt.axis('off')\n",
+    "plt.show()\n",
+    "\n",
+    "\n",
+    "labels = sorted(list(set(dataset['name']))) + [BACKGROUND_CLASS]\n",
+    "text_inputs = processor(text=labels, return_tensors=\"pt\", padding=True).to(DEVICE)\n",
+    "image_processed = processor(images=image, return_tensors=\"pt\").to(DEVICE)\n",
+    "pixel_values = image_processed['pixel_values']\n",
+    "outputs_full = model(pixel_values=pixel_values, **text_inputs)\n",
+    "logits_full = outputs_full.logits_per_image  # Shape: (1, num_styles)\n",
+    "predicted_index_full = logits_full.argmax(dim=-1).item()\n",
+    "\n",
+    "print(f\"Predicted label: {labels[predicted_index_full]}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "54467f0c",
+   "metadata": {},
+   "source": [
+    "### Baseline: A trivial masking method\n",
+    "\n",
+    "We will now be implementing a trivial masking solution, one that randomly masks out 90% of the pixels."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ee24b90",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def generate_center_crop_coordinates(image):\n",
+    "    \"\"\"\n",
+    "    Generate coordinates for a center crop mask.\n",
+    "    \n",
+    "    Returns:\n",
+    "        tuple: ((top, left), (bottom, right)) coordinates for the crop\n",
+    "    \"\"\"\n",
+    "    H, W = image.size\n",
+    "    total_px = H * W\n",
+    "    k = int(total_px * RETAIN_RATIO)\n",
+    "    \n",
+    "    # Calculate side length of the square crop\n",
+    "    side_length = int(np.sqrt(k))\n",
+    "    \n",
+    "    # Calculate center coordinates\n",
+    "    center_h, center_w = H // 2, W // 2\n",
+    "    \n",
+    "    # Calculate crop boundaries\n",
+    "    half_side = side_length // 2\n",
+    "    top = max(0, center_h - half_side)\n",
+    "    left = max(0, center_w - half_side)\n",
+    "    bottom = min(H, top + side_length)\n",
+    "    right = min(W, left + side_length)\n",
+    "    \n",
+    "    return ((top, left), (bottom, right))\n",
+    "\n",
+    "def generate_mask_from_coordinates(image, coordinates):\n",
+    "    \"\"\"\n",
+    "    Generate a binary mask from crop coordinates.\n",
+    "    \n",
+    "    Parameters:\n",
+    "        image: PIL Image\n",
+    "        coordinates: tuple of ((top, left), (bottom, right))\n",
+    "    \n",
+    "    Returns:\n",
+    "        numpy array: Binary mask with 1s in the crop area\n",
+    "    \"\"\"\n",
+    "    H, W = image.size\n",
+    "    mask = np.zeros((H, W), dtype=np.int8)\n",
+    "    \n",
+    "    (top, left), (bottom, right) = coordinates\n",
+    "    mask[top:bottom, left:right] = 1\n",
+    "    \n",
+    "    return mask"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e87f8f85",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def apply_mask_with_mean(image, mask, mean_rgb=MEAN_COLOR):\n",
+    "    \"\"\"\n",
+    "    Apply arbitrary binary mask to image, replacing masked areas with mean values\n",
+    "\n",
+    "    Parameters:\n",
+    "    - image: PIL Image (224x224)\n",
+    "    - mask: Binary numpy array or PIL Image (224x224) where 0 is the area to drop and 1 is the area to keep\n",
+    "    - mean_rgb: RGB mean values to use (default: from config)\n",
+    "\n",
+    "    Returns: Modified PIL Image\n",
+    "    \"\"\"\n",
+    "    # Convert images to numpy arrays\n",
+    "    img_array = np.array(image).copy()\n",
+    "\n",
+    "    # Ensure mask is numpy array\n",
+    "    if isinstance(mask, Image.Image):\n",
+    "        mask_array = np.array(mask.convert('L')) > 127  # Convert to binary\n",
+    "    else:\n",
+    "        mask_array = mask > 0\n",
+    "\n",
+    "    # Reshape mask for broadcasting with RGB\n",
+    "    mask_3d = np.stack([mask_array] * 3, axis=2)\n",
+    "\n",
+    "    # Convert mean values to 0-255 range\n",
+    "    mean_values = np.array([int(m * 255) for m in mean_rgb])\n",
+    "    # Apply mask - replace areas where mask is 0 (drop) with mean values, keep areas where mask is 1\n",
+    "    img_array = np.where(mask_3d, img_array, mean_values.reshape(1, 1, 3))\n",
+    "\n",
+    "    return Image.fromarray(img_array.astype(np.uint8))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a84ed28b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image = dataset[0]['image']\n",
+    "# Visualize the image with its true label\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "plt.imshow(image)\n",
+    "plt.title(f\"Sample Image\\nTrue Label: {dataset[0]['name']}\", fontsize=14)\n",
+    "plt.axis('off')\n",
+    "plt.show()\n",
+    "\n",
+    "\n",
+    "labels = sorted(list(set(dataset['name']))) + [BACKGROUND_CLASS]\n",
+    "text_inputs = processor(text=labels, return_tensors=\"pt\", padding=True).to(DEVICE)\n",
+    "\n",
+    "mask = generate_mask_from_coordinates(image, generate_center_crop_coordinates(image))\n",
+    "image_masked = apply_mask_with_mean(image, mask)\n",
+    "\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "plt.imshow(image_masked)\n",
+    "plt.title(f\"Masked Image\\nTrue Label: {dataset[0]['name']}\", fontsize=14)\n",
+    "plt.axis('off')\n",
+    "plt.show()\n",
+    "\n",
+    "image_processed = processor(images=image_masked, return_tensors=\"pt\").to(DEVICE)\n",
+    "pixel_values = image_processed['pixel_values']\n",
+    "outputs_full = model(pixel_values=pixel_values, **text_inputs)\n",
+    "logits_full = outputs_full.logits_per_image  # Shape: (1, num_styles)\n",
+    "predicted_index_full = logits_full.argmax(dim=-1).item()\n",
+    "\n",
+    "print(f\"Predicted label: {labels[predicted_index_full]}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d6987536",
+   "metadata": {},
+   "source": [
+    "### Exporting the masks\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8aa65a80",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#DATA_PATH is the secret environment variable to point the address of the validation set and test set on the testing machine. \n",
+    "#Contestants cannot access this address locally.\n",
+    "import os\n",
+    "if os.environ.get('DATA_PATH'):\n",
+    "    TEST_PATH = os.environ.get(\"DATA_PATH\") + \"/\" \n",
+    "else:\n",
+    "    TEST_PATH = \"\"  # Fallback for local testing\n",
+    "\n",
+    "dataset = load_from_disk(TEST_PATH + \"test_dataset\")\n",
+    "split = \"test\"\n",
+    "dataset = dataset[split]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5cae01f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Exporting results and validating on full dataset\n",
+    "RETAIN_RATIO = 0.0625\n",
+    "\n",
+    "masks = {}\n",
+    "for item in tqdm(dataset):\n",
+    "    image = item['image']\n",
+    "\n",
+    "    ## you should replace mask generation with your function\n",
+    "    coordinates = generate_center_crop_coordinates(image)\n",
+    "    \n",
+    "    # don't need to change below, it's just saving to file\n",
+    "    idx = item['idx']\n",
+    "    # For validation, we still need to generate the full mask\n",
+    "    mask = generate_mask_from_coordinates(image, coordinates)\n",
+    "    assert mask.shape == (224, 224), \"Mask should be 224x224\"\n",
+    "    assert mask.sum() <= RETAIN_RATIO * 224 * 224, \"You should leave only 6.25% of pixels\"\n",
+    "    \n",
+    "    # Save only the coordinates (topleft, bottomright) instead of the full mask\n",
+    "    masks[idx] = coordinates\n",
+    "\n",
+    "# Save as JSONL (one JSON object per line) - much safer than pickle\n",
+    "with open('submission.jsonl', 'w') as f:\n",
+    "    for idx, coordinates in masks.items():\n",
+    "        json.dump({\"idx\": idx, \"coordinates\": coordinates}, f)\n",
+    "        f.write('\\n')\n",
+    "\n",
+    "print(\"Masks saved to masks.jsonl\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ed60e044",
+   "metadata": {},
+   "source": [
+    "### Validation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3d1ef680",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # Validation code for generated masks\n",
+    "\n",
+    "# def check_validity(coordinates):\n",
+    "#     \"\"\"\n",
+    "#     Check if coordinates are valid according to the requirements.\n",
+    "#     Returns True if valid, False otherwise.\n",
+    "#     \"\"\"\n",
+    "#     try:\n",
+    "#         # Check if coordinates is a tuple of two tuples\n",
+    "#         if not isinstance(coordinates, tuple) or len(coordinates) != 2:\n",
+    "#             print(f\"Coordinates is not a tuple of two tuples\")\n",
+    "#             return False\n",
+    "        \n",
+    "#         (top, left), (bottom, right) = coordinates\n",
+    "        \n",
+    "#         # Check if all coordinates are integers\n",
+    "#         if not all(isinstance(coord, (int, np.integer)) for coord in [top, left, bottom, right]):\n",
+    "#             print(f\"Coordinates are not integers\")\n",
+    "#             return False\n",
+    "        \n",
+    "#         # Check if coordinates are within image bounds\n",
+    "#         # For slicing mask[top:bottom, left:right], valid ranges are:\n",
+    "#         # top, left: [0, 223] (inclusive)\n",
+    "#         # bottom, right: [1, 224] (inclusive) since we need top < bottom and left < right\n",
+    "#         if not (0 <= top < 224 and 0 <= left < 224 and 1 <= bottom <= 224 and 1 <= right <= 224):\n",
+    "#             print(f\"Coordinates are not within image bounds\")\n",
+    "#             return False\n",
+    "        \n",
+    "#         # Check if top-left is actually top-left of bottom-right (proper ordering)\n",
+    "#         if not (top < bottom and left < right):\n",
+    "#             print(f\"Top-left is not actually top-left of bottom-right\")\n",
+    "#             return False\n",
+    "        \n",
+    "#         # Check that the crop area doesn't exceed RETAIN_RATIO\n",
+    "#         crop_area = (bottom - top) * (right - left)\n",
+    "#         max_area = RETAIN_RATIO * 224 * 224\n",
+    "#         if crop_area > max_area:\n",
+    "#             print(f\"Crop area {crop_area} exceeds max area {max_area}\")\n",
+    "#             return False\n",
+    "        \n",
+    "#         return True\n",
+    "#     except Exception:\n",
+    "#         return False\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "# def validate_masks(masks):\n",
+    "#     \"\"\"Simple validation of generated masks on the dataset\"\"\"\n",
+    "#     correct = 0\n",
+    "#     total = 0\n",
+    "\n",
+    "#     labels = sorted(list(set(dataset['name']))) + ['other']\n",
+    "#     text_inputs = processor(text=labels, return_tensors=\"pt\", padding=True).to(DEVICE)\n",
+    "\n",
+    "#     with torch.no_grad():\n",
+    "#         for item in tqdm(dataset, desc=\"Validating masks\"):\n",
+    "#             idx = item['idx']\n",
+    "#             if idx not in masks:\n",
+    "#                 continue\n",
+    "\n",
+    "#             if not check_validity(masks[idx]):\n",
+    "#                 continue\n",
+    "                \n",
+    "#             mask_coordinates = masks[idx]\n",
+    "#             image = item['image']\n",
+    "#             true_label = item['name']\n",
+    "            \n",
+    "#             # Apply mask to image\n",
+    "#             if image.mode != \"RGB\":\n",
+    "#                 image = image.convert(\"RGB\")\n",
+    "            \n",
+    "#             mask = generate_mask_from_coordinates(image, mask_coordinates)\n",
+    "\n",
+    "#             # Apply mask with mean color replacement\n",
+    "#             img_array = np.array(image).copy()\n",
+    "#             mask_array = mask > 0\n",
+    "#             mask_3d = np.stack([mask_array] * 3, axis=2)\n",
+    "#             mean_values = np.array([0, 0, 0])  # Black mean color\n",
+    "#             img_array = np.where(mask_3d, img_array, mean_values.reshape(1, 1, 3))\n",
+    "#             masked_image = Image.fromarray(img_array.astype(np.uint8))\n",
+    "            \n",
+    "#             # Get prediction on masked image\n",
+    "#             image_processed = processor(images=masked_image, return_tensors=\"pt\").to(DEVICE)\n",
+    "#             pixel_values = image_processed['pixel_values']\n",
+    "#             outputs = model(pixel_values=pixel_values, **text_inputs)\n",
+    "#             logits = outputs.logits_per_image\n",
+    "#             predicted_idx = logits.argmax(dim=-1).item()\n",
+    "#             predicted_label = labels[predicted_idx]\n",
+    "            \n",
+    "#             # Check if prediction is correct\n",
+    "#             if predicted_label == true_label:\n",
+    "#                 correct += 1\n",
+    "#             total += 1\n",
+    "    \n",
+    "#     accuracy = correct / total if total > 0 else 0\n",
+    "#     print(f\"Validation Results:\")\n",
+    "#     print(f\"Total samples: {total}\")\n",
+    "#     print(f\"Correct predictions: {correct}\")\n",
+    "#     print(f\"Accuracy: {accuracy:.4f} ({accuracy*100:.2f}%)\")\n",
+    "    \n",
+    "#     return accuracy\n",
+    "\n",
+    "# # Run validation\n",
+    "# accuracy = validate_masks(masks)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Individual-Contest/Pixel/Solution/Pixel_Solution.ipynb

@@ -0,0 +1,519 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "2051e891-2bcf-42a6-9a1e-f773baff8808",
+   "metadata": {},
+   "source": [
+    "<img src=\"./figs/IOAI-Logo.png\" alt=\"IOAI Logo\" width=\"200\" height=\"auto\">\n",
+    "\n",
+    "[IOAI 2025 (Beijing, China), Individual Contest](https://ioai-official.org/china-2025)\n",
+    "\n",
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/IOAI-official/IOAI-2025/blob/main/Individual-Contest/Pixel/Solution/Pixel_Solution.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "441c46a0-b20a-4dc1-9227-f659833a7d2f",
+   "metadata": {},
+   "source": [
+    "# Pixel Efficiency: Reference Solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2df5ae63",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import numpy as np\n",
+    "from PIL import Image\n",
+    "from tqdm import tqdm\n",
+    "import json\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from datasets import load_from_disk\n",
+    "from transformers import CLIPProcessor, CLIPModel\n",
+    "from typing import Optional\n",
+    "from transformers.models.clip.modeling_clip import CLIPVisionTransformer, CLIPVisionConfig, BaseModelOutputWithPooling\n",
+    "\n",
+    "\n",
+    "# Dataset configuration\n",
+    "DATASET_PATH = os.environ.get(\"DATA_PATH\") + \"/test_dataset\"\n",
+    "SPLIT = \"test\"\n",
+    "\n",
+    "# Model Configuration\n",
+    "MODEL_PATH = \"./clip-vit-large-patch14\"\n",
+    "DEVICE = \"cuda\"\n",
+    "BACKGROUND_CLASS = \"other\"\n",
+    "\n",
+    "# Image and Masking Configuration\n",
+    "HEIGHT = 224\n",
+    "WIDTH = 224\n",
+    "RETAIN_RATIO = 0.0625\n",
+    "MEAN_COLOR = (0, 0, 0)\n",
+    "STRIDE = 2\n",
+    "TOP_K = 3\n",
+    "\n",
+    "# Load the dataset\n",
+    "print(\"Loading dataset...\")\n",
+    "dataset_whole = load_from_disk(DATASET_PATH)\n",
+    "dataset = dataset_whole[SPLIT]\n",
+    "\n",
+    "print(f\"Dataset loaded successfully! Total samples: {len(dataset)}\")\n",
+    "\n",
+    "print(f\"Loading CLIP model and processor: {MODEL_PATH}...\")\n",
+    "model = CLIPModel.from_pretrained(MODEL_PATH).to(DEVICE)\n",
+    "processor = CLIPProcessor.from_pretrained(MODEL_PATH)\n",
+    "print(\"Model and processor loaded successfully.\")\n",
+    "\n",
+    "\n",
+    "def generate_all_rectangular_regions(image_size=224, patch_size=14, retain_ratio=RETAIN_RATIO, max_aspect_ratio=1.2, stride=1):\n",
+    "    \"\"\"Generate rectangular regions with optimizations for speed\"\"\"\n",
+    "    max_pixels = int(retain_ratio * image_size * image_size)\n",
+    "    patches_per_side = image_size // patch_size\n",
+    "    patch_area = patch_size * patch_size\n",
+    "    target_patches = max_pixels // patch_area\n",
+    "    \n",
+    "    min_patches = max(1, target_patches - 1)\n",
+    "    max_patches = target_patches + 1\n",
+    "    \n",
+    "    regions = []\n",
+    "    region_to_patches = []\n",
+    "    \n",
+    "    # Pre-compute valid rectangle dimensions\n",
+    "    valid_dims = []\n",
+    "    for width_patches in range(1, patches_per_side + 1):\n",
+    "        for height_patches in range(1, patches_per_side + 1):\n",
+    "            total_patches = width_patches * height_patches\n",
+    "            if min_patches <= total_patches <= max_patches:\n",
+    "                aspect_ratio = max(width_patches, height_patches) / min(width_patches, height_patches)\n",
+    "                if aspect_ratio <= max_aspect_ratio:\n",
+    "                    valid_dims.append((width_patches, height_patches, total_patches))\n",
+    "    \n",
+    "    # Generate rectangles using stride for positions\n",
+    "    for width_patches, height_patches, total_patches in valid_dims:\n",
+    "        for top_patch in range(0, patches_per_side - height_patches + 1, stride):\n",
+    "            for left_patch in range(0, patches_per_side - width_patches + 1, stride):\n",
+    "                bottom_patch = top_patch + height_patches\n",
+    "                right_patch = left_patch + width_patches\n",
+    "                \n",
+    "                pixel_coords = (\n",
+    "                    top_patch * patch_size,\n",
+    "                    left_patch * patch_size,\n",
+    "                    bottom_patch * patch_size,\n",
+    "                    right_patch * patch_size\n",
+    "                )\n",
+    "                regions.append(pixel_coords)\n",
+    "                \n",
+    "                covered_patches = []\n",
+    "                for p_row in range(top_patch, bottom_patch):\n",
+    "                    for p_col in range(left_patch, right_patch):\n",
+    "                        patch_idx = p_row * patches_per_side + p_col\n",
+    "                        covered_patches.append(patch_idx)\n",
+    "                region_to_patches.append(covered_patches)\n",
+    "    \n",
+    "    return regions, region_to_patches\n",
+    "\n",
+    "\n",
+    "class MaskCLIPVisionTransformer(CLIPVisionTransformer):\n",
+    "    \"\"\"Modified CLIP Vision Transformer that supports mask tokens for all possible rectangular regions\"\"\"\n",
+    "    \n",
+    "    def __init__(self, config: CLIPVisionConfig, retain_ratio=RETAIN_RATIO):\n",
+    "        super().__init__(config)\n",
+    "        self.retain_ratio = retain_ratio\n",
+    "        self.num_patches = (config.image_size // config.patch_size) ** 2\n",
+    "        \n",
+    "        self.regions, self.region_to_patches = generate_all_rectangular_regions(\n",
+    "            image_size=config.image_size, \n",
+    "            patch_size=config.patch_size, \n",
+    "            retain_ratio=retain_ratio,\n",
+    "            max_aspect_ratio=1.2,\n",
+    "            stride=STRIDE\n",
+    "        )\n",
+    "        self.num_mask_tokens = len(self.regions)\n",
+    "        \n",
+    "        self.mask_tokens = nn.Parameter(torch.randn(1, self.num_mask_tokens, config.hidden_size))\n",
+    "        \n",
+    "    def create_mask_attention_matrix(self, batch_size):\n",
+    "        \"\"\"Create attention mask matrix for all rectangular regions\"\"\"\n",
+    "        N = self.num_patches\n",
+    "        M = self.num_mask_tokens\n",
+    "        total_tokens = N + 1 + M\n",
+    "        \n",
+    "        attention_mask = torch.zeros(total_tokens, total_tokens, dtype=torch.bool, device=self.mask_tokens.device)\n",
+    "        \n",
+    "        # Class token and image patches do NOT attend to mask tokens\n",
+    "        attention_mask[:N+1, N+1:] = True\n",
+    "        \n",
+    "        # Each mask token attends to its specific image patches (not CLS)\n",
+    "        attention_mask[N+1:, 1:N+1] = True\n",
+    "        \n",
+    "        # Then allow each mask token to attend to its assigned patches\n",
+    "        for mask_idx in range(M):\n",
+    "            covered_patches = self.region_to_patches[mask_idx]\n",
+    "            for patch_idx in covered_patches:\n",
+    "                token_pos = 1 + patch_idx\n",
+    "                attention_mask[N + 1 + mask_idx, token_pos] = False\n",
+    "        \n",
+    "        # Mask tokens do NOT attend to each other\n",
+    "        attention_mask[N+1:, N+1:] = True\n",
+    "        # Allow self-attention for each mask token\n",
+    "        for i in range(M):\n",
+    "            attention_mask[N + 1 + i, N + 1 + i] = False\n",
+    "        \n",
+    "        return attention_mask\n",
+    "    \n",
+    "    def forward(\n",
+    "        self,\n",
+    "        pixel_values: Optional[torch.FloatTensor] = None,\n",
+    "        output_attentions: Optional[bool] = None,\n",
+    "        output_hidden_states: Optional[bool] = None,\n",
+    "        interpolate_pos_encoding: Optional[bool] = False,\n",
+    "        use_mask_tokens: bool = False,\n",
+    "    ) -> BaseModelOutputWithPooling:\n",
+    "        \"\"\"Forward pass with optional mask tokens\"\"\"\n",
+    "        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions\n",
+    "        output_hidden_states = (\n",
+    "            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states\n",
+    "        )\n",
+    "\n",
+    "        if pixel_values is None:\n",
+    "            raise ValueError(\"You have to specify pixel_values\")\n",
+    "\n",
+    "        # Get embeddings (patches + class token)\n",
+    "        hidden_states = self.embeddings(pixel_values, interpolate_pos_encoding=interpolate_pos_encoding)\n",
+    "        hidden_states = self.pre_layrnorm(hidden_states)\n",
+    "        \n",
+    "        if use_mask_tokens:\n",
+    "            # Add mask tokens to the sequence\n",
+    "            batch_size = hidden_states.shape[0]\n",
+    "            \n",
+    "            cls_token_embedding = hidden_states[:, 0:1, :]\n",
+    "            mask_tokens_expanded = cls_token_embedding.expand(batch_size, self.num_mask_tokens, -1)\n",
+    "            \n",
+    "            if mask_tokens_expanded.device != hidden_states.device:\n",
+    "                mask_tokens_expanded = mask_tokens_expanded.to(hidden_states.device)\n",
+    "                \n",
+    "            hidden_states = torch.cat([hidden_states, mask_tokens_expanded], dim=1)\n",
+    "            \n",
+    "            # Create custom attention mask\n",
+    "            attention_mask = self.create_mask_attention_matrix(batch_size)\n",
+    "            \n",
+    "            seq_len = hidden_states.shape[1]\n",
+    "            attention_mask_4d = attention_mask.unsqueeze(0).unsqueeze(0).expand(batch_size, 1, -1, -1)\n",
+    "            attention_mask_4d = attention_mask_4d.float()\n",
+    "            attention_mask_4d = attention_mask_4d.masked_fill(attention_mask_4d == 1, float('-inf'))\n",
+    "            attention_mask_4d = attention_mask_4d.masked_fill(attention_mask_4d == 0, 0.0)\n",
+    "        else:\n",
+    "            attention_mask_4d = None\n",
+    "\n",
+    "        # Process through encoder layers\n",
+    "        encoder_outputs = self.encoder(\n",
+    "            inputs_embeds=hidden_states,\n",
+    "            attention_mask=attention_mask_4d,\n",
+    "            causal_attention_mask=None,\n",
+    "            output_attentions=output_attentions,\n",
+    "            output_hidden_states=output_hidden_states,\n",
+    "        )\n",
+    "\n",
+    "        last_hidden_state = encoder_outputs.last_hidden_state\n",
+    "        \n",
+    "        if use_mask_tokens:\n",
+    "            # Extract different token types\n",
+    "            class_token_output = last_hidden_state[:, 0]\n",
+    "            mask_tokens_output = last_hidden_state[:, self.num_patches + 1:]\n",
+    "            \n",
+    "            # Apply post layer norm\n",
+    "            pooled_output = self.post_layernorm(class_token_output)\n",
+    "            mask_tokens_output = self.post_layernorm(mask_tokens_output)\n",
+    "            \n",
+    "            return {\n",
+    "                'last_hidden_state': last_hidden_state,\n",
+    "                'pooler_output': pooled_output,\n",
+    "                'mask_tokens_output': mask_tokens_output,\n",
+    "                'hidden_states': encoder_outputs.hidden_states,\n",
+    "                'attentions': encoder_outputs.attentions,\n",
+    "            }\n",
+    "        else:\n",
+    "            # Standard CLIP behavior\n",
+    "            pooled_output = last_hidden_state[:, 0, :]\n",
+    "            pooled_output = self.post_layernorm(pooled_output)\n",
+    "\n",
+    "            return BaseModelOutputWithPooling(\n",
+    "                last_hidden_state=last_hidden_state,\n",
+    "                pooler_output=pooled_output,\n",
+    "                hidden_states=encoder_outputs.hidden_states,\n",
+    "                attentions=encoder_outputs.attentions,\n",
+    "            )\n",
+    "\n",
+    "\n",
+    "def apply_mask_with_mean(image, mask, mean_rgb=MEAN_COLOR):\n",
+    "    \"\"\"Apply arbitrary binary mask to image, replacing masked areas with mean values\"\"\"\n",
+    "    img_array = np.array(image).copy()\n",
+    "\n",
+    "    if isinstance(mask, Image.Image):\n",
+    "        mask_array = np.array(mask.convert('L')) > 127\n",
+    "    else:\n",
+    "        mask_array = mask > 0\n",
+    "\n",
+    "    mask_3d = np.stack([mask_array] * 3, axis=2)\n",
+    "    mean_values = np.array([int(m * 255) for m in mean_rgb])\n",
+    "    img_array = np.where(mask_3d, img_array, mean_values.reshape(1, 1, 3))\n",
+    "\n",
+    "    return Image.fromarray(img_array.astype(np.uint8))\n",
+    "\n",
+    "\n",
+    "def compute_vision_features_once(model, image, mask_vision_model):\n",
+    "    \"\"\"\n",
+    "    Compute vision features once for efficient reuse across multiple mask selection functions.\n",
+    "    This eliminates redundant forward passes.\n",
+    "    \"\"\"\n",
+    "    image_inputs = processor(images=image, return_tensors=\"pt\").to(DEVICE)\n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        vision_outputs = mask_vision_model(\n",
+    "            pixel_values=image_inputs['pixel_values'],\n",
+    "            use_mask_tokens=True\n",
+    "        )\n",
+    "        \n",
+    "        full_image_features = vision_outputs['pooler_output']\n",
+    "        if hasattr(model, 'visual_projection') and model.visual_projection is not None:\n",
+    "            full_image_features = model.visual_projection(full_image_features)\n",
+    "        \n",
+    "        mask_tokens_features = vision_outputs['mask_tokens_output']\n",
+    "        if hasattr(model, 'visual_projection') and model.visual_projection is not None:\n",
+    "            batch_size, num_tokens, embed_dim = mask_tokens_features.shape\n",
+    "            mask_tokens_features = mask_tokens_features.view(-1, embed_dim)\n",
+    "            mask_tokens_features = model.visual_projection(mask_tokens_features)\n",
+    "            mask_tokens_features = mask_tokens_features.view(batch_size, num_tokens, -1)\n",
+    "        \n",
+    "        full_image_features = full_image_features / full_image_features.norm(dim=-1, keepdim=True)\n",
+    "        mask_tokens_features = mask_tokens_features / mask_tokens_features.norm(dim=-1, keepdim=True)\n",
+    "    \n",
+    "    return vision_outputs, full_image_features, mask_tokens_features\n",
+    "\n",
+    "\n",
+    "def find_best_mask_region_calibrated(model, image, class_names, mask_vision_model, text_features, \n",
+    "                                   vision_outputs=None, full_image_features=None, mask_tokens_features=None, \n",
+    "                                   return_detailed=False):\n",
+    "    \"\"\"Find the best mask region using MaskCLIP approach with calibration for black-pixel masking\"\"\"\n",
+    "    num_mask_tokens = mask_vision_model.num_mask_tokens\n",
+    "    \n",
+    "    # Use pre-computed features if provided, otherwise compute them\n",
+    "    if vision_outputs is None or full_image_features is None or mask_tokens_features is None:\n",
+    "        image_inputs = processor(images=image, return_tensors=\"pt\").to(DEVICE)\n",
+    "        \n",
+    "        with torch.no_grad():\n",
+    "            vision_outputs = mask_vision_model(\n",
+    "                pixel_values=image_inputs['pixel_values'],\n",
+    "                use_mask_tokens=True\n",
+    "            )\n",
+    "            \n",
+    "            full_image_features = vision_outputs['pooler_output']\n",
+    "            if hasattr(model, 'visual_projection') and model.visual_projection is not None:\n",
+    "                full_image_features = model.visual_projection(full_image_features)\n",
+    "            \n",
+    "            mask_tokens_features = vision_outputs['mask_tokens_output']\n",
+    "            if hasattr(model, 'visual_projection') and model.visual_projection is not None:\n",
+    "                batch_size, num_tokens, embed_dim = mask_tokens_features.shape\n",
+    "                mask_tokens_features = mask_tokens_features.view(-1, embed_dim)\n",
+    "                mask_tokens_features = model.visual_projection(mask_tokens_features)\n",
+    "                mask_tokens_features = mask_tokens_features.view(batch_size, num_tokens, -1)\n",
+    "            \n",
+    "            full_image_features = full_image_features / full_image_features.norm(dim=-1, keepdim=True)\n",
+    "            mask_tokens_features = mask_tokens_features / mask_tokens_features.norm(dim=-1, keepdim=True)\n",
+    "    \n",
+    "    # Compute similarity between full image and text\n",
+    "    full_image_similarities = torch.matmul(full_image_features, text_features.T)\n",
+    "    full_image_prediction = torch.argmax(full_image_similarities, dim=-1)\n",
+    "    predicted_class_idx = full_image_prediction.item()\n",
+    "    \n",
+    "    # Compute similarities for each mask token\n",
+    "    mask_similarities = torch.matmul(mask_tokens_features.squeeze(0), text_features.T)\n",
+    "    mask_predictions = torch.argmax(mask_similarities, dim=-1)\n",
+    "    \n",
+    "    # Get candidates that predict the same class as full image, sorted by confidence\n",
+    "    matching_masks = (mask_predictions == predicted_class_idx)\n",
+    "    \n",
+    "    if matching_masks.any():\n",
+    "        candidate_indices = torch.where(matching_masks)[0]\n",
+    "        candidate_confidences = mask_similarities[candidate_indices, predicted_class_idx]\n",
+    "        sorted_indices = torch.argsort(candidate_confidences, descending=True)\n",
+    "        sorted_candidates = candidate_indices[sorted_indices]\n",
+    "    else:\n",
+    "        # If no exact matches, use all candidates sorted by confidence for predicted class\n",
+    "        candidate_confidences = mask_similarities[:, predicted_class_idx]\n",
+    "        sorted_candidates = torch.topk(candidate_confidences, len(candidate_confidences)).indices\n",
+    "    \n",
+    "    # OPTIMIZATION: If TOP_K=1, skip calibration and return best candidate directly\n",
+    "    if TOP_K == 1:\n",
+    "        return sorted_candidates[0].item()\n",
+    "    \n",
+    "    # CALIBRATION STEP: Test top K candidates, return immediately when one is correct\n",
+    "    calibration_results = []\n",
+    "    candidates_to_test = sorted_candidates[:TOP_K]\n",
+    "    \n",
+    "    for i, candidate_idx in enumerate(candidates_to_test):\n",
+    "        candidate_idx_item = candidate_idx.item()\n",
+    "        \n",
+    "        # Create masked image for this candidate\n",
+    "        coordinates = mask_idx_to_coordinates(candidate_idx_item, mask_vision_model)\n",
+    "        mask = generate_mask_from_coordinates(image, coordinates)\n",
+    "        masked_image = apply_mask_with_mean(image, mask)\n",
+    "        \n",
+    "        # Test with actual forward pass\n",
+    "        with torch.no_grad():\n",
+    "            masked_image_inputs = processor(images=masked_image, return_tensors=\"pt\").to(DEVICE)\n",
+    "            masked_image_features = model.get_image_features(**masked_image_inputs)\n",
+    "            masked_image_features = masked_image_features / masked_image_features.norm(dim=-1, keepdim=True)\n",
+    "            \n",
+    "            masked_similarities = torch.matmul(masked_image_features, text_features.T)\n",
+    "            masked_prediction = torch.argmax(masked_similarities, dim=-1).item()\n",
+    "            masked_confidence = masked_similarities[0, predicted_class_idx].item()\n",
+    "        \n",
+    "        # If this candidate predicts correctly, return it immediately (early exit optimization)\n",
+    "        if masked_prediction == predicted_class_idx:\n",
+    "            return candidate_idx_item\n",
+    "        \n",
+    "        # Store failed calibration result\n",
+    "        calibration_results.append((candidate_idx_item, masked_confidence))\n",
+    "    \n",
+    "    # If we reach here, all TOP_K candidates failed calibration\n",
+    "    # Fall back to the next best candidate from sorted list WITHOUT additional calibration\n",
+    "    if len(sorted_candidates) > TOP_K:\n",
+    "        return sorted_candidates[TOP_K].item()\n",
+    "    else:\n",
+    "        # If no more candidates available, return the best failed calibration result\n",
+    "        if calibration_results:\n",
+    "            return max(calibration_results, key=lambda x: x[1])[0]\n",
+    "        else:\n",
+    "            # Ultimate fallback: return the best mask token prediction\n",
+    "            return sorted_candidates[0].item()\n",
+    "\n",
+    "\n",
+    "def mask_idx_to_coordinates(mask_idx, mask_vision_model):\n",
+    "    \"\"\"Convert mask token index to image coordinates using the pre-computed regions\"\"\"\n",
+    "    if mask_idx >= len(mask_vision_model.regions):\n",
+    "        raise ValueError(f\"mask_idx {mask_idx} is out of range. Only {len(mask_vision_model.regions)} regions available.\")\n",
+    "    \n",
+    "    top, left, bottom, right = mask_vision_model.regions[mask_idx]\n",
+    "    return ((top, left), (bottom, right))\n",
+    "\n",
+    "\n",
+    "def generate_mask_from_coordinates(image, coordinates):\n",
+    "    \"\"\"Generate a binary mask from crop coordinates\"\"\"\n",
+    "    H, W = 224, 224\n",
+    "    mask = np.zeros((H, W), dtype=np.int8)\n",
+    "    \n",
+    "    (top, left), (bottom, right) = coordinates\n",
+    "    mask[top:bottom, left:right] = 1\n",
+    "    \n",
+    "    return mask\n",
+    "\n",
+    "\n",
+    "# Create the MaskCLIP model\n",
+    "print(\"Creating MaskCLIP model...\")\n",
+    "mask_vision_model = MaskCLIPVisionTransformer(model.vision_model.config, retain_ratio=RETAIN_RATIO)\n",
+    "mask_vision_model.load_state_dict(model.vision_model.state_dict(), strict=False)\n",
+    "mask_vision_model = mask_vision_model.to(DEVICE)\n",
+    "mask_vision_model.eval()\n",
+    "print(\"MaskCLIP model created successfully.\")\n",
+    "\n",
+    "dataset_eval = load_from_disk(DATASET_PATH)\n",
+    "dataset_eval = dataset_eval[SPLIT]\n",
+    "\n",
+    "# Get class names from training dataset for consistent evaluation  \n",
+    "train_dataset = load_from_disk(\"/bohr/train-yzfn/v1/train_dataset\")[\"train\"] # TODO: This part needs changing!\n",
+    "class_names_eval = list(set([item['name'] for item in train_dataset])) + [BACKGROUND_CLASS]\n",
+    "\n",
+    "# Prepare text features once for efficiency\n",
+    "print(\"Preparing text features...\")\n",
+    "text_inputs_eval = processor(text=class_names_eval, return_tensors=\"pt\", padding=True).to(DEVICE)\n",
+    "with torch.no_grad():\n",
+    "    text_features_eval = model.get_text_features(**text_inputs_eval)\n",
+    "    text_features_eval = text_features_eval / text_features_eval.norm(dim=-1, keepdim=True)\n",
+    "print(\"Text features prepared.\")\n",
+    "\n",
+    "# Main evaluation loop\n",
+    "masks = {}\n",
+    "total_correct = 0\n",
+    "total_processed = 0\n",
+    "\n",
+    "for item in tqdm(dataset_eval):\n",
+    "    image = item['image']\n",
+    "    total_processed += 1\n",
+    "\n",
+    "    try:\n",
+    "        # Compute vision features once for efficiency (eliminates redundant forward passes)\n",
+    "        vision_outputs, full_image_features, mask_tokens_features = compute_vision_features_once(\n",
+    "            model, image, mask_vision_model\n",
+    "        )\n",
+    "        \n",
+    "        # Get prediction from pre-computed features\n",
+    "        full_image_similarities = torch.matmul(full_image_features, text_features_eval.T)\n",
+    "        predicted_class_idx = torch.argmax(full_image_similarities, dim=-1).item()\n",
+    "            \n",
+    "        best_mask_idx = find_best_mask_region_calibrated(\n",
+    "            model, image, class_names_eval, mask_vision_model, text_features_eval,\n",
+    "            vision_outputs=vision_outputs, full_image_features=full_image_features, \n",
+    "            mask_tokens_features=mask_tokens_features\n",
+    "        )\n",
+    "        \n",
+    "        coordinates = mask_idx_to_coordinates(best_mask_idx, mask_vision_model)\n",
+    "        \n",
+    "        # Validate the mask\n",
+    "        mask = generate_mask_from_coordinates(image, coordinates)\n",
+    "        assert mask.shape == (224, 224), \"Mask should be 224x224\"\n",
+    "        assert mask.sum() <= RETAIN_RATIO * 224 * 224, \"You should leave only 6.25% of pixels\"\n",
+    "\n",
+    "        \n",
+    "        # Save the coordinates\n",
+    "        idx = item['idx']\n",
+    "        masks[idx] = coordinates\n",
+    "        \n",
+    "    except Exception as e:\n",
+    "        print(f\"Error processing image {item['idx']}: {e}\")\n",
+    "        # Fallback to a small center region if there's an error\n",
+    "        if len(mask_vision_model.regions) > 0:\n",
+    "            region_sizes = [(r[2]-r[0])*(r[3]-r[1]) for r in mask_vision_model.regions]\n",
+    "            min_region_idx = region_sizes.index(min(region_sizes))\n",
+    "            fallback_coords = mask_idx_to_coordinates(min_region_idx, mask_vision_model)\n",
+    "        else:\n",
+    "            fallback_coords = ((84, 84), (140, 140))\n",
+    "        masks[item['idx']] = fallback_coords\n",
+    "\n",
+    "# Save as JSONL (one JSON object per line) - much safer than pickle\n",
+    "with open('submission.jsonl', 'w') as f:\n",
+    "    for idx, coordinates in masks.items():\n",
+    "        json.dump({\"idx\": idx, \"coordinates\": coordinates}, f)\n",
+    "        f.write('\\n')\n",
+    "\n",
+    "print(\"Masks saved to masks.jsonl\")\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Individual-Contest/Pixel/Solution/Scoring/metrics.py

@@ -0,0 +1,549 @@
+import json
+from pathlib import Path 
+from argparse import ArgumentParser
+import os
+
+import torch
+from transformers import CLIPProcessor, CLIPModel
+from datasets import load_from_disk, load_dataset
+from PIL import Image
+import numpy as np
+import math
+from tqdm.auto import tqdm  # Progress bar
+import random
+import matplotlib.pyplot as plt
+
+if os.environ.get('METRIC_PATH'):
+    METRIC_PATH = os.environ.get("METRIC_PATH") + "/" 
+else:
+    METRIC_PATH = ""  # Fallback for local testing
+H, W = 224, 224
+MODEL_PATH = "/bohr/clip-vit-large-patch14-aft9/v1/clip-vit-large-patch14"
+DATASET_PATH = METRIC_PATH + "reference_dataset"
+MASK_PATH = "masks.jsonl"
+SPLIT = "test"
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+RETAIN_RATIO = 0.0625
+SCORE_OUTPUT_FILE = "score.json"
+MEAN_COLOR = (0, 0, 0)
+
+
+parser = ArgumentParser()
+parser.add_argument("--mask-file", default='masks.npy', type=str)
+parser.add_argument("--debug", default=False, action='store_true')
+args = parser.parse_args()
+
+
+def write_error_score(error_message):
+    """Write error score to JSON file"""
+    error_json = {
+        "status": False,
+        "score": {
+            "public_a": 0.0,
+            "public_detail": {
+                "Score": 0.0,
+                "Accuracy": 0.0,
+            },
+            "private_b": 0.0,
+            "private_detail": {
+                "Score": 0.0,
+                "Accuracy": 0.0,
+            },
+        },
+        "msg": f"Error: {error_message}",
+    }
+    
+    with open(SCORE_OUTPUT_FILE, 'w') as f:
+        json.dump(error_json, f, indent=2)
+    print(f"Error written to {SCORE_OUTPUT_FILE}: {error_message}")
+
+
+def safe_load_masks(mask_file_path, expected_dataset_size):
+    """
+    Safely load and validate the masks file from contestants.
+    
+    Parameters:
+        mask_file_path: Path to the masks file
+        expected_dataset_size: Expected number of test cases
+        
+    Returns:
+        dict: Validated masks dictionary or None if invalid
+    """
+    try:
+        # Check if file exists
+        if not os.path.exists(mask_file_path):
+            write_error_score("Mask file not found.")
+            return None
+        
+        # Check file size (prevent extremely large files)
+        file_size = os.path.getsize(mask_file_path)
+        max_file_size = 50 * 1024 * 1024  # 50MB limit
+        if file_size > max_file_size:
+            write_error_score("Mask file too large.")
+            return None
+        
+        masks = {}
+        
+        # Load based on file extension
+        if mask_file_path.endswith('.jsonl'):
+            # Load JSONL format (one JSON object per line)
+            try:
+                with open(mask_file_path, 'r') as f:
+                    for line_num, line in enumerate(f, 1):
+                        if line.strip():  # Skip empty lines
+                            try:
+                                data = json.loads(line.strip())
+                                idx = data.get('idx')
+                                coordinates = data.get('coordinates')
+                                
+                                if idx is None or coordinates is None:
+                                    write_error_score("Invalid JSONL format.")
+                                    return None
+                                
+                                masks[idx] = coordinates
+                            except json.JSONDecodeError:
+                                write_error_score("Invalid JSON in mask file.")
+                                return None
+            except Exception:
+                write_error_score("Unable to load JSONL mask file.")
+                return None
+                
+        # Validate it's a dictionary
+        if not isinstance(masks, dict):
+            write_error_score("Mask data must be a dictionary.")
+            return None
+        
+        # Check number of entries
+        if len(masks) != expected_dataset_size:
+            # print(len(masks), expected_dataset_size)
+            write_error_score("Incorrect number of mask entries.")
+            return None
+        
+        # Validate each mask entry
+        for idx, coordinates in masks.items():
+            # Validate index
+            if not isinstance(idx, (int, np.integer, str)):
+                write_error_score("Invalid mask index format.")
+                return None
+            
+            # Validate coordinates structure
+            if not isinstance(coordinates, (tuple, list)) or len(coordinates) != 2:
+                write_error_score("Invalid mask coordinate structure.")
+                return None
+            
+            try:
+                (top, left), (bottom, right) = coordinates
+            except (ValueError, TypeError):
+                write_error_score("Invalid mask coordinate format.")
+                return None
+            
+            # Validate coordinate types and values
+            coords = [top, left, bottom, right]
+            for coord in coords:
+                if not isinstance(coord, (int, np.integer)):
+                    write_error_score("Mask coordinates must be integers.")
+                    return None
+                
+                if not (0 <= coord <= 224):
+                    write_error_score("Mask coordinates out of valid range.")
+                    return None
+            
+            # Validate coordinate ordering
+            if not (top < bottom and left < right):
+                write_error_score("Invalid mask coordinate ordering.")
+                return None
+            
+            # Validate area constraint
+            crop_area = (bottom - top) * (right - left)
+            max_area = RETAIN_RATIO * 224 * 224
+            if crop_area > max_area:
+                write_error_score("Mask area exceeds allowed limit.")
+                return None
+            
+            # Additional security: prevent degenerate cases
+            if crop_area <= 0:
+                write_error_score("Invalid mask area.")
+                return None
+        
+        return masks
+        
+    except Exception as e:
+        write_error_score("Unexpected error loading mask file.")
+        return None
+
+
+def check_validity(coordinates):
+    """
+    Check if coordinates are valid according to the requirements.
+    Returns True if valid, False otherwise.
+    """
+    try:
+        # Check if coordinates is a tuple of two tuples
+        if not hasattr(coordinates, '__iter__') or len(coordinates) != 2:
+            return False
+        
+        (top, left), (bottom, right) = coordinates
+        
+        # Check if all coordinates are integers
+        if not all(isinstance(coord, (int, np.integer)) for coord in [top, left, bottom, right]):
+            return False
+        
+        # Check if coordinates are within image bounds
+        # For slicing mask[top:bottom, left:right], valid ranges are:
+        # top, left: [0, 223] (inclusive)
+        # bottom, right: [1, 224] (inclusive) since we need top < bottom and left < right
+        if not (0 <= top < 224 and 0 <= left < 224 and 1 <= bottom <= 224 and 1 <= right <= 224):
+            return False
+        
+        # Check if top-left is actually top-left of bottom-right (proper ordering)
+        if not (top < bottom and left < right):
+            return False
+        
+        # Check that the crop area doesn't exceed RETAIN_RATIO
+        crop_area = (bottom - top) * (right - left)
+        max_area = RETAIN_RATIO * 224 * 224
+        if crop_area > max_area:
+            return False
+        
+        return True
+    except Exception:
+        return False
+
+def generate_mask_from_coordinates(image, coordinates):
+    """
+    Generate a binary mask from crop coordinates.
+    
+    Parameters:
+        image: PIL Image
+        coordinates: tuple of ((top, left), (bottom, right))
+    
+    Returns:
+        numpy array: Binary mask with 1s in the crop area
+    """
+    H, W = 224, 224  # Standard image size
+    mask = np.zeros((H, W), dtype=np.int8)
+    
+    (top, left), (bottom, right) = coordinates
+    mask[top:bottom, left:right] = 1
+    
+    return mask
+
+def apply_mask_with_mean(image, mask, mean_rgb=MEAN_COLOR):
+    """
+    Apply arbitrary binary mask to image, replacing masked areas with mean values
+
+    Parameters:
+    - image: PIL Image (224x224)
+    - mask: Binary numpy array or PIL Image (224x224) where 0 is the area to drop and 1 is the area to keep
+    - mean_rgb: RGB mean values to use (default: from config)
+
+    Returns: Modified PIL Image
+    """
+    # Convert images to numpy arrays
+    img_array = np.array(image).copy()
+
+    # Ensure mask is numpy array
+    if isinstance(mask, Image.Image):
+        mask_array = np.array(mask.convert('L')) > 127  # Convert to binary
+    else:
+        mask_array = mask > 0
+
+    # Reshape mask for broadcasting with RGB
+    mask_3d = np.stack([mask_array] * 3, axis=2)
+
+    # Convert mean values to 0-255 range
+    mean_values = np.array([int(m * 255) for m in mean_rgb])
+    # Apply mask - replace areas where mask is 0 (drop) with mean values, keep areas where mask is 1
+    img_array = np.where(mask_3d, img_array, mean_values.reshape(1, 1, 3))
+
+    return Image.fromarray(img_array.astype(np.uint8))
+
+
+if __name__ == '__main__':
+    try:
+        # Load the animals dataset using the function from animal_dataset.py
+        try:
+            dataset = load_from_disk(DATASET_PATH)
+            dataset = dataset[SPLIT]
+        except Exception:
+            write_error_score("Unable to load reference dataset.")
+            exit(1)
+
+        # Safely load and validate masks
+        masks = safe_load_masks(MASK_PATH, len(dataset))
+        if masks is None:
+            exit(1)  # Error already written by safe_load_masks
+
+        # Check validity of coordinates and report invalid ones
+        invalid_coordinates = []
+        valid_coordinates = 0
+        for idx, coordinates in masks.items():
+            if not check_validity(coordinates):
+                invalid_coordinates.append(idx)
+            else:
+                valid_coordinates += 1
+        
+        if invalid_coordinates:
+            print(f"Warning: Found {len(invalid_coordinates)} invalid coordinates (indices: {invalid_coordinates[:10]}{'...' if len(invalid_coordinates) > 10 else ''})")
+            print(f"Invalid coordinates will be treated as incorrect predictions")
+        print(f"Valid coordinates: {valid_coordinates}/{len(masks)}")
+
+        #dataset = dataset.select(range(10)) # debug remove later
+
+        # --- Step 1: Load Model and Processor ---
+        print(f"Loading CLIP model and processor: {MODEL_PATH}...")
+        try:
+            model = CLIPModel.from_pretrained(MODEL_PATH).to(DEVICE)
+            processor = CLIPProcessor.from_pretrained(MODEL_PATH)
+            model.eval()  # Set to evaluation mode
+            print("Model and processor loaded successfully.")
+        except Exception as e:
+            write_error_score("Unable to load model.")
+            exit(1)
+
+        try:
+            labels = sorted(list(set(dataset['name']))) + ['other']
+            text_inputs = processor(text=labels, return_tensors="pt", padding=True).to(DEVICE)
+        except Exception:
+            write_error_score("Unable to process labels.")
+            exit(1)
+
+        # Map label names to indices for later comparison
+        label_to_index = {label: i for i, label in enumerate(labels)}
+        index_to_label = {i: label for label, i in label_to_index.items()}  # For mapping prediction back
+
+        def predict_with_coordinates(image, coordinates):
+            try:
+                # Generate mask from coordinates
+                mask = generate_mask_from_coordinates(image, coordinates)
+                assert len(mask.shape) == 2
+
+                if image.mode != "RGB":
+                    image = image.convert("RGB")
+                image = apply_mask_with_mean(image, mask)
+                image_processed = processor(images=image, return_tensors="pt").to(DEVICE)
+                pixel_values = image_processed['pixel_values']
+                outputs_full = model(pixel_values=pixel_values, **text_inputs)
+                logits_full = outputs_full.logits_per_image  # Shape: (1, num_labels)
+                predicted_index_full = logits_full.argmax(dim=-1).item()
+                return predicted_index_full
+            except Exception:
+                # Return a random prediction if processing fails
+                return len(labels) - 1  # Return 'other' class
+
+        def get_accuracy(masks):
+            try:
+                with torch.no_grad():  # Disable gradient calculations for inference
+                    correct = 0
+                    for item in tqdm(dataset):
+                        idx = item['idx']
+                        if idx not in masks:
+                            continue
+                        coordinates = masks[idx]
+                        
+                        # Check coordinates validity - if invalid, mark as incorrect
+                        if not check_validity(coordinates):
+                            print(f"Invalid coordinates for item {idx}")
+                            continue  # Skip this item, treating it as incorrect
+                        
+                        image = item['image']
+                        true_label_label = item['name']  # This is now the animal class name
+
+                        # Store true label for confusion matrix
+                        true_label_idx = label_to_index[true_label_label]
+                        if predict_with_coordinates(image, coordinates) == true_label_idx:
+                            correct += 1
+                return correct / len(masks)
+            except Exception:
+                return 0.0
+
+        def get_accuracy_by_sets(masks):
+            """Calculate accuracy for A set (smaller) and B set (larger) with 30:70 split"""
+            try:
+                # Set random seed for reproducible shuffling
+                random.seed(42)
+                
+                with torch.no_grad():
+                    correct_a = 0
+                    correct_b = 0
+                    total_a = 0
+                    total_b = 0
+                    
+                    # First, collect all valid items that have masks
+                    valid_items = []
+                    for item in dataset:
+                        idx = item['idx']
+                        if idx in masks:
+                            valid_items.append(item)
+                    
+                    # Group items by class name for stratified sampling
+                    items_by_class = {}
+                    for item in valid_items:
+                        class_name = item['name']
+                        if class_name not in items_by_class:
+                            items_by_class[class_name] = []
+                        items_by_class[class_name].append(item)
+                    
+                    # Stratified split: for each class, allocate 30% to A and 70% to B
+                    set_a_items = []
+                    set_b_items = []
+                    
+                    for class_name, class_items in items_by_class.items():
+                        # Shuffle items within each class for random stratified sampling
+                        random.shuffle(class_items)
+                        
+                        # Calculate split point for this class (30% to A, 70% to B)
+                        split_point = int(len(class_items) * 0.3)
+                        
+                        # Ensure at least one item goes to each set if possible
+                        if len(class_items) >= 2:
+                            if split_point == 0:
+                                split_point = 1
+                            elif split_point == len(class_items):
+                                split_point = len(class_items) - 1
+                        
+                        class_a_items = class_items[:split_point]
+                        class_b_items = class_items[split_point:]
+                        
+                        set_a_items.extend(class_a_items)
+                        set_b_items.extend(class_b_items)
+                        
+                        print(f"Class '{class_name}': {len(class_items)} total, {len(class_a_items)} to A, {len(class_b_items)} to B")
+                    
+                    print(f"Stratified split: Set A has {len(set_a_items)} items, Set B has {len(set_b_items)} items")
+                    
+                    # Verify class distribution
+                    a_class_counts = {}
+                    b_class_counts = {}
+                    for item in set_a_items:
+                        class_name = item['name']
+                        a_class_counts[class_name] = a_class_counts.get(class_name, 0) + 1
+                    for item in set_b_items:
+                        class_name = item['name']
+                        b_class_counts[class_name] = b_class_counts.get(class_name, 0) + 1
+                    
+                    print("Class distribution verification:")
+                    for class_name in sorted(labels):
+                        a_count = a_class_counts.get(class_name, 0)
+                        b_count = b_class_counts.get(class_name, 0)
+                        total_count = a_count + b_count
+                        if total_count > 0:
+                            a_ratio = a_count / total_count
+                            b_ratio = b_count / total_count
+                            print(f"  {class_name}: A={a_count} ({a_ratio:.1%}), B={b_count} ({b_ratio:.1%})")
+                    
+                    # Process Set A
+                    for item in tqdm(set_a_items, desc="Processing Set A"):
+                        idx = item['idx']
+                        coordinates = masks[idx]
+                        
+                        # Check coordinates validity - if invalid, mark as incorrect
+                        if not check_validity(coordinates):
+                            total_a += 1
+                            continue  # Skip prediction, treating as incorrect
+                        
+                        image = item['image']
+                        true_label_label = item['name']  # This is now the animal class name
+                        true_label_idx = label_to_index[true_label_label]
+                        
+                        # Get prediction on masked image
+                        masked_pred_idx = predict_with_coordinates(image, coordinates)
+                        
+                        is_correct = masked_pred_idx == true_label_idx
+                        
+                        total_a += 1
+                        if is_correct:
+                            correct_a += 1
+                    
+                    # Process Set B
+                    for item in tqdm(set_b_items, desc="Processing Set B"):
+                        idx = item['idx']
+                        coordinates = masks[idx]
+                        
+                        # Check coordinates validity - if invalid, mark as incorrect
+                        if not check_validity(coordinates):
+                            total_b += 1
+                            continue  # Skip prediction, treating as incorrect
+                        
+                        image = item['image']
+                        true_label_label = item['name']  # This is now the animal class name
+                        true_label_idx = label_to_index[true_label_label]
+                        
+                        # Get prediction on masked image
+                        masked_pred_idx = predict_with_coordinates(image, coordinates)
+                        
+                        is_correct = masked_pred_idx == true_label_idx
+                        
+                        total_b += 1
+                        if is_correct:
+                            correct_b += 1
+                    
+                    accuracy_a = correct_a / total_a if total_a > 0 else 0
+                    accuracy_b = correct_b / total_b if total_b > 0 else 0
+                    
+                    print(f"Set A (30%): {total_a} samples, accuracy: {accuracy_a:.4f}")
+                    print(f"Set B (70%): {total_b} samples, accuracy: {accuracy_b:.4f}")
+                    
+                    return accuracy_a, accuracy_b
+            except Exception:
+                return 0.0, 0.0
+
+        def predict_without_mask(image):
+            """Predict on original image without mask"""
+            try:
+                if image.mode != "RGB":
+                    image = image.convert("RGB")
+                image_processed = processor(images=image, return_tensors="pt").to(DEVICE)
+                pixel_values = image_processed['pixel_values']
+                outputs_full = model(pixel_values=pixel_values, **text_inputs)
+                logits_full = outputs_full.logits_per_image
+                predicted_index_full = logits_full.argmax(dim=-1).item()
+                return predicted_index_full
+            except Exception:
+                return len(labels) - 1  # Return 'other' class
+
+        # Calculate accuracies for A and B sets
+        accuracy_a, accuracy_b = get_accuracy_by_sets(masks)
+
+        
+        score_a = accuracy_a
+        score_b = accuracy_b
+        
+        # Ensure scores are within valid bounds [0.0, 1.0]
+        if not (0.0 <= score_a <= 1.0) or not isinstance(score_a, (int, float)) or math.isnan(score_a) or math.isinf(score_a):
+            score_a = 0.0
+        if not (0.0 <= score_b <= 1.0) or not isinstance(score_b, (int, float)) or math.isnan(score_b) or math.isinf(score_b):
+            score_b = 0.0
+        
+        print(f"Score A: {score_a}, Score B: {score_b}")
+        
+        #----------calculate the score on the leaderboard------------#
+        score = {
+            "public_a": score_a,
+            "public_detail": {
+                "Score": score_a,
+                "Accuracy": accuracy_a,
+            },
+            "private_b": score_b,
+            "private_detail": {
+                "Score": score_b,
+                "Accuracy": accuracy_b,
+            },
+        }
+        
+        ret_json = {
+            "status": True,
+            "score": score,
+            "msg": "Success!",
+        }
+        
+        # Save the score to JSON file
+        with open(SCORE_OUTPUT_FILE, 'w') as f:
+            json.dump(ret_json, f, indent=2)
+        
+        print(f"Score saved to {SCORE_OUTPUT_FILE}")
+
+    except Exception as e:
+        # Catch any unexpected errors during execution
+        write_error_score("Unexpected error during evaluation.")
+        exit(1)

Individual-Contest/Pixel/Solution/Scoring/reference_dataset/dataset_dict.json

@@ -0,0 +1 @@
+{"splits": ["test"]}

Individual-Contest/Pixel/Solution/Scoring/reference_dataset/test/data-00000-of-00001.arrow

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc613e30c79b865d0ce146cf080f8a0e8f8e62eb9134fe96e73e160a957f65cc
+size 66694656

Individual-Contest/Pixel/Solution/Scoring/reference_dataset/test/dataset_info.json

@@ -0,0 +1,49 @@
+{
+  "builder_name": "parquet",
+  "citation": "",
+  "config_name": "default",
+  "dataset_name": "private_do_not_share_2025_6_pixel_test_reference",
+  "dataset_size": 66689696,
+  "description": "",
+  "download_checksums": {
+    "hf://datasets/fedyanin/PRIVATE_DO_NOT_SHARE_2025_6_pixel_test_reference@70a41c3eda0606d8e873d1e1fa8d19600870a600/data/test-00000-of-00001.parquet": {
+      "num_bytes": 66551523,
+      "checksum": null
+    }
+  },
+  "download_size": 66551523,
+  "features": {
+    "image": {
+      "_type": "Image"
+    },
+    "name": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "meta": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "idx": {
+      "dtype": "string",
+      "_type": "Value"
+    }
+  },
+  "homepage": "",
+  "license": "",
+  "size_in_bytes": 133241219,
+  "splits": {
+    "test": {
+      "name": "test",
+      "num_bytes": 66689696,
+      "num_examples": 698,
+      "dataset_name": "private_do_not_share_2025_6_pixel_test_reference"
+    }
+  },
+  "version": {
+    "version_str": "0.0.0",
+    "major": 0,
+    "minor": 0,
+    "patch": 0
+  }
+}

Individual-Contest/Pixel/Solution/Scoring/reference_dataset/test/state.json

@@ -0,0 +1,13 @@
+{
+  "_data_files": [
+    {
+      "filename": "data-00000-of-00001.arrow"
+    }
+  ],
+  "_fingerprint": "e1588b9c5d07a415",
+  "_format_columns": null,
+  "_format_kwargs": {},
+  "_format_type": null,
+  "_output_all_columns": false,
+  "_split": "test"
+}

Individual-Contest/Pixel/Solution/test_set/dataset_dict.json

@@ -0,0 +1 @@
+{"splits": ["test"]}

Individual-Contest/Pixel/Solution/test_set/test/data-00000-of-00001.arrow

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4855d3cef6910dc41ac3f6621d4421534e7fb8330f2df71a04fd2761d0b4f9d0
+size 66491192

Individual-Contest/Pixel/Solution/test_set/test/dataset_info.json

@@ -0,0 +1,41 @@
+{
+  "builder_name": "parquet",
+  "citation": "",
+  "config_name": "default",
+  "dataset_name": "2025_6_pixel_test",
+  "dataset_size": 66487813,
+  "description": "",
+  "download_checksums": {
+    "hf://datasets/InternationalOlympiadAI/2025_6_pixel_test@ba4c48588115e61c9cadb9fa8e1bd073c2837435/data/test-00000-of-00001.parquet": {
+      "num_bytes": 66472867,
+      "checksum": null
+    }
+  },
+  "download_size": 66472867,
+  "features": {
+    "image": {
+      "_type": "Image"
+    },
+    "idx": {
+      "dtype": "string",
+      "_type": "Value"
+    }
+  },
+  "homepage": "",
+  "license": "",
+  "size_in_bytes": 132960680,
+  "splits": {
+    "test": {
+      "name": "test",
+      "num_bytes": 66487813,
+      "num_examples": 698,
+      "dataset_name": "2025_6_pixel_test"
+    }
+  },
+  "version": {
+    "version_str": "0.0.0",
+    "major": 0,
+    "minor": 0,
+    "patch": 0
+  }
+}

Individual-Contest/Pixel/Solution/test_set/test/state.json

@@ -0,0 +1,13 @@
+{
+  "_data_files": [
+    {
+      "filename": "data-00000-of-00001.arrow"
+    }
+  ],
+  "_fingerprint": "3783220c01b30a7c",
+  "_format_columns": null,
+  "_format_kwargs": {},
+  "_format_type": null,
+  "_output_all_columns": false,
+  "_split": "test"
+}

Individual-Contest/Pixel/clip-vit-large-patch14/config.json

@@ -0,0 +1,46 @@
+{
+  "architectures": [
+    "CLIPModel"
+  ],
+  "initializer_factor": 1.0,
+  "logit_scale_init_value": 2.6592,
+  "model_type": "clip",
+  "projection_dim": 768,
+  "text_config": {
+    "attention_dropout": 0.0,
+    "dropout": 0.0,
+    "hidden_act": "quick_gelu",
+    "hidden_size": 768,
+    "initializer_factor": 1.0,
+    "initializer_range": 0.02,
+    "intermediate_size": 3072,
+    "layer_norm_eps": 1e-05,
+    "max_position_embeddings": 77,
+    "model_type": "clip_text_model",
+    "num_attention_heads": 12,
+    "num_hidden_layers": 12,
+    "projection_dim": 768,
+    "torch_dtype": "float32",
+    "vocab_size": 49408
+  },
+  "torch_dtype": "float32",
+  "transformers_version": "4.51.3",
+  "vision_config": {
+    "attention_dropout": 0.0,
+    "dropout": 0.0,
+    "hidden_act": "quick_gelu",
+    "hidden_size": 1024,
+    "image_size": 224,
+    "initializer_factor": 1.0,
+    "initializer_range": 0.02,
+    "intermediate_size": 4096,
+    "layer_norm_eps": 1e-05,
+    "model_type": "clip_vision_model",
+    "num_attention_heads": 16,
+    "num_channels": 3,
+    "num_hidden_layers": 24,
+    "patch_size": 14,
+    "projection_dim": 768,
+    "torch_dtype": "float32"
+  }
+}

Individual-Contest/Pixel/clip-vit-large-patch14/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:522913128f8e780c6c3755a2451fa2ed52363b562a3e3cf8e1598c050004e910
+size 135

Individual-Contest/Pixel/clip-vit-large-patch14/preprocessor_config.json

@@ -0,0 +1,28 @@
+{
+  "crop_size": {
+    "height": 224,
+    "width": 224
+  },
+  "do_center_crop": true,
+  "do_convert_rgb": true,
+  "do_normalize": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "image_mean": [
+    0.48145466,
+    0.4578275,
+    0.40821073
+  ],
+  "image_processor_type": "CLIPImageProcessor",
+  "image_std": [
+    0.26862954,
+    0.26130258,
+    0.27577711
+  ],
+  "processor_class": "CLIPProcessor",
+  "resample": 3,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "shortest_edge": 224
+  }
+}

Individual-Contest/Pixel/clip-vit-large-patch14/special_tokens_map.json

@@ -0,0 +1,30 @@
+{
+  "bos_token": {
+    "content": "<|startoftext|>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

Individual-Contest/Pixel/clip-vit-large-patch14/tokenizer_config.json

@@ -0,0 +1,32 @@
+{
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "49406": {
+      "content": "<|startoftext|>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "49407": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<|startoftext|>",
+  "clean_up_tokenization_spaces": false,
+  "do_lower_case": true,
+  "eos_token": "<|endoftext|>",
+  "errors": "replace",
+  "extra_special_tokens": {},
+  "model_max_length": 77,
+  "pad_token": "<|endoftext|>",
+  "processor_class": "CLIPProcessor",
+  "tokenizer_class": "CLIPTokenizer",
+  "unk_token": "<|endoftext|>"
+}

Individual-Contest/Pixel/training_set/dataset_dict.json

@@ -0,0 +1 @@
+{"splits": ["train"]}

Individual-Contest/Pixel/training_set/train/data-00000-of-00001.arrow

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc96339b675cda03d917ae9401f099e705a02fefc7b9bacd37ca4ac5558814ea
+size 66293080

Individual-Contest/Pixel/training_set/train/dataset_info.json

@@ -0,0 +1,45 @@
+{
+  "builder_name": "parquet",
+  "citation": "",
+  "config_name": "default",
+  "dataset_name": "2025_6_pixel_train",
+  "dataset_size": 66289069,
+  "description": "",
+  "download_checksums": {
+    "hf://datasets/InternationalOlympiadAI/2025_6_pixel_train@e559471b7f6f163c671b62ac7fdafd800c378af9/data/train-00000-of-00001.parquet": {
+      "num_bytes": 66270582,
+      "checksum": null
+    }
+  },
+  "download_size": 66270582,
+  "features": {
+    "name": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "image": {
+      "_type": "Image"
+    },
+    "idx": {
+      "dtype": "string",
+      "_type": "Value"
+    }
+  },
+  "homepage": "",
+  "license": "",
+  "size_in_bytes": 132559651,
+  "splits": {
+    "train": {
+      "name": "train",
+      "num_bytes": 66289069,
+      "num_examples": 700,
+      "dataset_name": "2025_6_pixel_train"
+    }
+  },
+  "version": {
+    "version_str": "0.0.0",
+    "major": 0,
+    "minor": 0,
+    "patch": 0
+  }
+}

Individual-Contest/Pixel/training_set/train/state.json

@@ -0,0 +1,13 @@
+{
+  "_data_files": [
+    {
+      "filename": "data-00000-of-00001.arrow"
+    }
+  ],
+  "_fingerprint": "55cd60415fe29420",
+  "_format_columns": null,
+  "_format_kwargs": {},
+  "_format_type": null,
+  "_output_all_columns": false,
+  "_split": "train"
+}