Sync from GitHub Actions

notebooks/autocatalogai_model_comparison.ipynb

@@ -219,7 +219,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "1ac434ae",
    "metadata": {
     "execution": {
@@ -249,16 +249,9 @@
     "\n",
     "def safe_torch_load(path, map_location=\"cpu\"):\n",
     "    try:\n",
-    "        return torch.load(\n",
-    "            path,\n",
-    "            map_location=map_location,\n",
-    "            weights_only=True,\n",
-    "        )\n",
+    "        return torch.load(path, map_location=map_location, weights_only=True)\n",
     "    except (TypeError, RuntimeError):\n",
-    "        return torch.load(\n",
-    "            path,\n",
-    "            map_location=map_location,\n",
-    "        )\n",
+    "        return torch.load(path, map_location=map_location)\n",
     "\n",
     "\n",
     "def download_repo_artifacts(repo_id, include_rules=False):\n",
@@ -287,24 +280,16 @@
     "    }\n",
     "\n",
     "    if include_rules:\n",
-    "        artifacts[\"consistency_rules\"] = load_json(\n",
-    "            paths[\"consistency_rules.json\"]\n",
-    "        )\n",
+    "        artifacts[\"consistency_rules\"] = load_json(paths[\"consistency_rules.json\"])\n",
     "\n",
     "    return artifacts\n",
     "\n",
     "\n",
     "v1_artifacts = download_repo_artifacts(V1_REPO_ID)\n",
-    "v2_artifacts = download_repo_artifacts(\n",
-    "    V2_REPO_ID,\n",
-    "    include_rules=True,\n",
-    ")\n",
+    "v2_artifacts = download_repo_artifacts(V2_REPO_ID,include_rules=True)\n",
     "\n",
     "if v1_artifacts[\"label_maps\"] != v2_artifacts[\"label_maps\"]:\n",
-    "    raise ValueError(\n",
-    "        \"V1 and V2 label maps are different. \"\n",
-    "        \"A direct comparison would not be valid.\"\n",
-    "    )\n",
+    "    raise ValueError(\"V1 and V2 label maps are different. \")\n",
     "\n",
     "label_maps = v2_artifacts[\"label_maps\"]\n",
     "v1_config = v1_artifacts[\"config\"]\n",
@@ -325,7 +310,7 @@
     "}\n",
     "\n",
     "print(\"Base model:\", MODEL_NAME)\n",
-    "print(\"Task classes:\", task_num_classes)\n"
+    "print(\"Task classes:\", task_num_classes)"
    ]
   },
   {
@@ -340,7 +325,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "bf1f57de",
    "metadata": {
     "execution": {
@@ -378,11 +363,7 @@
     }
    ],
    "source": [
-    "raw_dataset = load_dataset(\n",
-    "    DATASET_NAME,\n",
-    "    split=\"train\",\n",
-    ")\n",
-    "\n",
+    "raw_dataset = load_dataset(DATASET_NAME, split=\"train\")\n",
     "missing_columns = [\n",
     "    task\n",
     "    for task in TASKS\n",
@@ -393,9 +374,7 @@
     "    raise ValueError(\"Dataset must contain an image column.\")\n",
     "\n",
     "if missing_columns:\n",
-    "    raise ValueError(\n",
-    "        f\"Dataset is missing task columns: {missing_columns}\"\n",
-    "    )\n",
+    "    raise ValueError(f\"Dataset is missing task columns: {missing_columns}\")\n",
     "\n",
     "\n",
     "def is_valid_row(row):\n",
@@ -404,12 +383,10 @@
     "\n",
     "    for task in TASKS:\n",
     "        value = row.get(task)\n",
-    "\n",
     "        if value is None:\n",
     "            return False\n",
     "\n",
     "        value = str(value).strip()\n",
-    "\n",
     "        if not value:\n",
     "            return False\n",
     "\n",
@@ -420,7 +397,6 @@
     "\n",
     "\n",
     "clean_dataset = raw_dataset.filter(is_valid_row)\n",
-    "\n",
     "print(\"Raw samples:\", len(raw_dataset))\n",
     "print(\"Clean samples:\", len(clean_dataset))\n",
     "print(\"Dataset fingerprint:\", clean_dataset._fingerprint)\n"
@@ -438,7 +414,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "2f6aa87a",
    "metadata": {
     "execution": {
@@ -474,29 +450,20 @@
     "df = pd.DataFrame(metadata)\n",
     "df[\"dataset_idx\"] = np.arange(len(clean_dataset))\n",
     "\n",
-    "\n",
     "def make_safe_stratify_labels(series):\n",
     "    counts = series.value_counts()\n",
-    "\n",
     "    return series.apply(\n",
-    "        lambda value: (\n",
-    "            value\n",
-    "            if counts[value] >= 2\n",
-    "            else \"__rare__\"\n",
-    "        )\n",
+    "        lambda value: (value if counts[value] >= 2 else \"__rare__\")\n",
     "    )\n",
     "\n",
     "\n",
     "all_indices = df.index.to_numpy()\n",
-    "\n",
     "try:\n",
     "    train_idx, temporary_idx = train_test_split(\n",
     "        all_indices,\n",
     "        test_size=VAL_RATIO + TEST_RATIO,\n",
     "        random_state=SEED,\n",
-    "        stratify=make_safe_stratify_labels(\n",
-    "            df[\"articleType\"]\n",
-    "        ),\n",
+    "        stratify=make_safe_stratify_labels(df[\"articleType\"])\n",
     "    )\n",
     "except ValueError:\n",
     "    train_idx, temporary_idx = train_test_split(\n",
@@ -506,15 +473,12 @@
     "    )\n",
     "\n",
     "temporary_df = df.loc[temporary_idx]\n",
-    "\n",
     "try:\n",
     "    val_idx, test_idx = train_test_split(\n",
     "        temporary_idx,\n",
     "        test_size=TEST_RATIO / (VAL_RATIO + TEST_RATIO),\n",
     "        random_state=SEED,\n",
-    "        stratify=make_safe_stratify_labels(\n",
-    "            temporary_df[\"articleType\"]\n",
-    "        ),\n",
+    "        stratify=make_safe_stratify_labels(temporary_df[\"articleType\"])\n",
     "    )\n",
     "except ValueError:\n",
     "    val_idx, test_idx = train_test_split(\n",
@@ -531,27 +495,12 @@
     "assert set(train_idx).isdisjoint(test_idx)\n",
     "assert set(val_idx).isdisjoint(test_idx)\n",
     "\n",
-    "train_df.to_csv(\n",
-    "    PROCESSED_DIR / \"train_v2.csv\",\n",
-    "    index=False,\n",
-    ")\n",
-    "val_df.to_csv(\n",
-    "    PROCESSED_DIR / \"val_v2.csv\",\n",
-    "    index=False,\n",
-    ")\n",
-    "test_df.to_csv(\n",
-    "    PROCESSED_DIR / \"test_v2.csv\",\n",
-    "    index=False,\n",
-    ")\n",
-    "\n",
-    "test_index_bytes = np.asarray(\n",
-    "    sorted(test_idx),\n",
-    "    dtype=np.int64,\n",
-    ").tobytes()\n",
+    "train_df.to_csv(PROCESSED_DIR / \"train_v2.csv\", index=False)\n",
+    "val_df.to_csv(PROCESSED_DIR / \"val_v2.csv\", index=False)\n",
+    "test_df.to_csv(PROCESSED_DIR / \"test_v2.csv\", index=False)\n",
     "\n",
-    "test_split_sha256 = hashlib.sha256(\n",
-    "    test_index_bytes\n",
-    ").hexdigest()\n",
+    "test_index_bytes = np.asarray(sorted(test_idx), dtype=np.int64).tobytes()\n",
+    "test_split_sha256 = hashlib.sha256(test_index_bytes).hexdigest()\n",
     "\n",
     "print(\"Train:\", len(train_df))\n",
     "print(\"Validation:\", len(val_df))\n",
@@ -569,7 +518,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "ee239b3e",
    "metadata": {
     "execution": {
@@ -591,39 +540,20 @@
     }
    ],
    "source": [
-    "processor = CLIPImageProcessor.from_pretrained(\n",
-    "    MODEL_NAME\n",
-    ")\n",
-    "\n",
-    "\n",
-    "def extract_color_features(\n",
-    "    image,\n",
-    "    image_size=COLOR_IMAGE_SIZE,\n",
-    "):\n",
-    "    image = image.convert(\"RGB\").resize(\n",
-    "        (image_size, image_size)\n",
-    "    )\n",
+    "processor = CLIPImageProcessor.from_pretrained(MODEL_NAME)\n",
     "\n",
+    "def extract_color_features(image, image_size=COLOR_IMAGE_SIZE):\n",
+    "    image = image.convert(\"RGB\").resize((image_size, image_size))\n",
     "    margin = int(image_size * 0.10)\n",
-    "\n",
     "    image = image.crop(\n",
     "        (\n",
-    "            margin,\n",
-    "            margin,\n",
-    "            image_size - margin,\n",
-    "            image_size - margin,\n",
+    "            margin, margin,\n",
+    "            image_size - margin, image_size - margin,\n",
     "        )\n",
     "    )\n",
     "\n",
-    "    rgb = np.asarray(\n",
-    "        image,\n",
-    "        dtype=np.float32,\n",
-    "    ) / 255.0\n",
-    "\n",
-    "    hsv = np.asarray(\n",
-    "        image.convert(\"HSV\"),\n",
-    "        dtype=np.float32,\n",
-    "    ) / 255.0\n",
+    "    rgb = np.asarray(image, dtype=np.float32) / 255.0\n",
+    "    hsv = np.asarray(image.convert(\"HSV\"), dtype=np.float32) / 255.0\n",
     "\n",
     "    rgb_flat = rgb.reshape(-1, 3)\n",
     "    hsv_flat = hsv.reshape(-1, 3)\n",
@@ -631,90 +561,43 @@
     "    saturation = hsv_flat[:, 1]\n",
     "    value = hsv_flat[:, 2]\n",
     "\n",
-    "    foreground_mask = (\n",
-    "        (saturation > 0.08)\n",
-    "        | (value < 0.92)\n",
-    "    )\n",
-    "\n",
+    "    foreground_mask = ((saturation > 0.08) | (value < 0.92))\n",
     "    if foreground_mask.sum() < 256:\n",
-    "        foreground_mask = np.ones(\n",
-    "            len(hsv_flat),\n",
-    "            dtype=bool,\n",
-    "        )\n",
+    "        foreground_mask = np.ones(len(hsv_flat), dtype=bool)\n",
     "\n",
     "    selected_rgb = rgb_flat[foreground_mask]\n",
     "    selected_hsv = hsv_flat[foreground_mask]\n",
     "\n",
-    "    hue_hist, _ = np.histogram(\n",
-    "        selected_hsv[:, 0],\n",
-    "        bins=12,\n",
-    "        range=(0.0, 1.0),\n",
-    "    )\n",
-    "\n",
-    "    saturation_hist, _ = np.histogram(\n",
-    "        selected_hsv[:, 1],\n",
-    "        bins=8,\n",
-    "        range=(0.0, 1.0),\n",
-    "    )\n",
-    "\n",
-    "    value_hist, _ = np.histogram(\n",
-    "        selected_hsv[:, 2],\n",
-    "        bins=8,\n",
-    "        range=(0.0, 1.0),\n",
-    "    )\n",
+    "    hue_hist, _ = np.histogram(selected_hsv[:, 0], bins=12, range=(0.0, 1.0))\n",
+    "    saturation_hist, _ = np.histogram(selected_hsv[:, 1], bins=8, range=(0.0, 1.0))\n",
+    "    value_hist, _ = np.histogram(selected_hsv[:, 2], bins=8, range=(0.0, 1.0))\n",
     "\n",
     "    hue_hist = hue_hist.astype(np.float32)\n",
     "    saturation_hist = saturation_hist.astype(np.float32)\n",
     "    value_hist = value_hist.astype(np.float32)\n",
     "\n",
     "    hue_hist /= max(hue_hist.sum(), 1.0)\n",
-    "    saturation_hist /= max(\n",
-    "        saturation_hist.sum(),\n",
-    "        1.0,\n",
-    "    )\n",
+    "    saturation_hist /= max(saturation_hist.sum(), 1.0)\n",
     "    value_hist /= max(value_hist.sum(), 1.0)\n",
     "\n",
-    "    rgb_mean = selected_rgb.mean(\n",
-    "        axis=0\n",
-    "    ).astype(np.float32)\n",
-    "\n",
-    "    rgb_std = selected_rgb.std(\n",
-    "        axis=0\n",
-    "    ).astype(np.float32)\n",
-    "\n",
-    "    rgb_median = np.median(\n",
-    "        selected_rgb,\n",
-    "        axis=0,\n",
-    "    ).astype(np.float32)\n",
+    "    rgb_mean = selected_rgb.mean(axis=0).astype(np.float32)\n",
+    "    rgb_std = selected_rgb.std(axis=0).astype(np.float32)\n",
+    "    rgb_median = np.median(selected_rgb, axis=0).astype(np.float32)\n",
     "\n",
     "    features = np.concatenate(\n",
     "        [\n",
-    "            hue_hist,\n",
-    "            saturation_hist,\n",
-    "            value_hist,\n",
-    "            rgb_mean,\n",
-    "            rgb_std,\n",
-    "            rgb_median,\n",
+    "            hue_hist, saturation_hist,\n",
+    "            value_hist, rgb_mean,\n",
+    "            rgb_std, rgb_median,\n",
     "        ]\n",
     "    ).astype(np.float32)\n",
     "\n",
     "    if features.shape[0] != COLOR_FEATURE_DIM:\n",
-    "        raise ValueError(\n",
-    "            f\"Expected {COLOR_FEATURE_DIM} color features, \"\n",
-    "            f\"got {features.shape[0]}\"\n",
-    "        )\n",
-    "\n",
+    "        raise ValueError(f\"Expected {COLOR_FEATURE_DIM} color features, \")\n",
     "    return features\n",
     "\n",
-    "\n",
     "class ComparisonDataset(Dataset):\n",
-    "    def __init__(\n",
-    "        self,\n",
-    "        source_dataset,\n",
-    "        indices,\n",
-    "        processor,\n",
-    "        label_maps,\n",
-    "    ):\n",
+    "    def __init__(self, source_dataset, indices, processor, label_maps):\n",
     "        self.source_dataset = source_dataset\n",
     "        self.indices = list(map(int, indices))\n",
     "        self.processor = processor\n",
@@ -726,14 +609,12 @@
     "    def __getitem__(self, index):\n",
     "        global_index = self.indices[index]\n",
     "        item = self.source_dataset[global_index]\n",
-    "\n",
     "        image = item[\"image\"]\n",
     "\n",
     "        if not isinstance(image, Image.Image):\n",
     "            image = Image.open(image)\n",
     "\n",
     "        image = image.convert(\"RGB\")\n",
-    "\n",
     "        pixel_values = self.processor(\n",
     "            images=image,\n",
     "            return_tensors=\"pt\",\n",
@@ -764,12 +645,8 @@
     "\n",
     "def collate_batch(batch):\n",
     "    return {\n",
-    "        \"pixel_values\": torch.stack(\n",
-    "            [item[\"pixel_values\"] for item in batch]\n",
-    "        ),\n",
-    "        \"color_features\": torch.stack(\n",
-    "            [item[\"color_features\"] for item in batch]\n",
-    "        ),\n",
+    "        \"pixel_values\": torch.stack([item[\"pixel_values\"] for item in batch]),\n",
+    "        \"color_features\": torch.stack([item[\"color_features\"] for item in batch]),\n",
     "        \"labels\": {\n",
     "            task: torch.stack(\n",
     "                [item[\"labels\"][task] for item in batch]\n",
@@ -799,7 +676,7 @@
     "    collate_fn=collate_batch,\n",
     ")\n",
     "\n",
-    "print(\"Test samples:\", len(test_dataset))\n"
+    "print(\"Test samples:\", len(test_dataset))"
    ]
   },
   {
@@ -812,7 +689,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "65d75793",
    "metadata": {
     "execution": {
@@ -827,15 +704,8 @@
    "outputs": [],
    "source": [
     "class ClassificationHead(nn.Module):\n",
-    "    def __init__(\n",
-    "        self,\n",
-    "        embedding_dim,\n",
-    "        num_classes,\n",
-    "        hidden_dim=512,\n",
-    "        dropout=0.2,\n",
-    "    ):\n",
+    "    def __init__(self, embedding_dim, num_classes, hidden_dim=512, dropout=0.2,):\n",
     "        super().__init__()\n",
-    "\n",
     "        self.net = nn.Sequential(\n",
     "            nn.LayerNorm(embedding_dim),\n",
     "            nn.Linear(embedding_dim, hidden_dim),\n",
@@ -857,15 +727,8 @@
     "        dropout=0.2,\n",
     "    ):\n",
     "        super().__init__()\n",
-    "\n",
-    "        self.clip = CLIPModel.from_pretrained(\n",
-    "            model_name\n",
-    "        )\n",
-    "\n",
-    "        embedding_dim = (\n",
-    "            self.clip.config.projection_dim\n",
-    "        )\n",
-    "\n",
+    "        self.clip = CLIPModel.from_pretrained(model_name)\n",
+    "        embedding_dim = (self.clip.config.projection_dim)\n",
     "        self.heads = nn.ModuleDict(\n",
     "            {\n",
     "                task: ClassificationHead(\n",
@@ -880,17 +743,8 @@
     "        )\n",
     "\n",
     "    def forward(self, pixel_values):\n",
-    "        image_features = (\n",
-    "            self.clip.get_image_features(\n",
-    "                pixel_values=pixel_values\n",
-    "            )\n",
-    "        )\n",
-    "\n",
-    "        image_features = F.normalize(\n",
-    "            image_features,\n",
-    "            dim=-1,\n",
-    "        )\n",
-    "\n",
+    "        image_features = (self.clip.get_image_features(pixel_values=pixel_values))\n",
+    "        image_features = F.normalize(image_features, dim=-1)\n",
     "        return {\n",
     "            task: head(image_features)\n",
     "            for task, head in self.heads.items()\n",
@@ -907,15 +761,8 @@
     "        color_feature_dim=37,\n",
     "    ):\n",
     "        super().__init__()\n",
-    "\n",
-    "        self.clip = CLIPModel.from_pretrained(\n",
-    "            model_name\n",
-    "        )\n",
-    "\n",
-    "        embedding_dim = (\n",
-    "            self.clip.config.projection_dim\n",
-    "        )\n",
-    "\n",
+    "        self.clip = CLIPModel.from_pretrained(model_name)\n",
+    "        embedding_dim = (self.clip.config.projection_dim)\n",
     "        self.heads = nn.ModuleDict(\n",
     "            {\n",
     "                task: ClassificationHead(\n",
@@ -964,11 +811,7 @@
     "            ),\n",
     "        )\n",
     "\n",
-    "    def forward(\n",
-    "        self,\n",
-    "        pixel_values,\n",
-    "        color_features,\n",
-    "    ):\n",
+    "    def forward(self,pixel_values,color_features,):\n",
     "        image_features = (\n",
     "            self.clip.get_image_features(\n",
     "                pixel_values=pixel_values\n",