Upload DEFAKE.ipynb

DEFAKE.ipynb

@@ -0,0 +1,570 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
+    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
+    "execution": {
+     "iopub.execute_input": "2026-01-28T10:49:46.444522Z",
+     "iopub.status.busy": "2026-01-28T10:49:46.443865Z",
+     "iopub.status.idle": "2026-01-28T10:49:50.728742Z",
+     "shell.execute_reply": "2026-01-28T10:49:50.727972Z",
+     "shell.execute_reply.started": "2026-01-28T10:49:46.444482Z"
+    },
+    "trusted": true
+   },
+   "outputs": [],
+   "source": [
+    "!pip install -q transformers timm scikit-image opencv-python\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-01-28T10:49:50.730620Z",
+     "iopub.status.busy": "2026-01-28T10:49:50.730385Z",
+     "iopub.status.idle": "2026-01-28T10:50:27.546572Z",
+     "shell.execute_reply": "2026-01-28T10:50:27.545920Z",
+     "shell.execute_reply.started": "2026-01-28T10:49:50.730595Z"
+    },
+    "trusted": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Data source import complete.\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m41.2/41.2 MB\u001b[0m \u001b[31m49.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m:00:01\u001b[0m00:01\u001b[0m\n",
+      "\u001b[?25h"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2026-01-28 10:50:07.856840: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "E0000 00:00:1769597408.048489      54 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "E0000 00:00:1769597408.112429      54 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "W0000 00:00:1769597408.576061      54 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n",
+      "W0000 00:00:1769597408.576094      54 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n",
+      "W0000 00:00:1769597408.576097      54 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n",
+      "W0000 00:00:1769597408.576099      54 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✓ All dependencies imported successfully!\n",
+      "Loading backbone model: prithivMLmods/AI-vs-Deepfake-vs-Real-9999\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d457f454bcc645c0bfe7dd10d614a497",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "preprocessor_config.json:   0%|          | 0.00/394 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using a slow image processor as `use_fast` is unset and a slow processor was saved with this model. `use_fast=True` will be the default behavior in v4.52, even if the model was saved with a slow processor. This will result in minor differences in outputs. You'll still be able to use a slow processor with `use_fast=False`.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "10b47f29308b48c88ab56a5b075dbc1a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "config.json: 0.00B [00:00, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d2c3fac19db446788eaefc3e51abba4e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model.safetensors:   0%|          | 0.00/372M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✓ Backbone model loaded successfully on cuda!\n",
+      "✓ Forensic signal functions defined!\n",
+      "✓ Backbone classification function defined!\n",
+      "✓ VLM Analyzer class defined!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# ============================================================================\n",
+    "# COMPLETE DEEPFAKE DETECTION PIPELINE WITH CONDITIONAL VLM REASONING\n",
+    "# ============================================================================\n",
+    "# Import Kaggle datasets\n",
+    "import kagglehub\n",
+    "\n",
+    "saurabhbagchi_deepfake_image_detection_path = kagglehub.dataset_download('saurabhbagchi/deepfake-image-detection')\n",
+    "\n",
+    "print('Data source import complete.')\n",
+    "\n",
+    "# ============================================================================\n",
+    "# SECTION 1: SETUP AND DEPENDENCIES\n",
+    "# ============================================================================\n",
+    "\n",
+    "\n",
+    "# Install required packages\n",
+    "!pip install -q transformers timm accelerate scikit-learn qwen-vl-utils\n",
+    "\n",
+    "# Import libraries\n",
+    "import os\n",
+    "import torch\n",
+    "import numpy as np\n",
+    "import cv2\n",
+    "import json\n",
+    "from PIL import Image\n",
+    "from typing import Dict, List\n",
+    "from transformers import AutoImageProcessor, SiglipForImageClassification\n",
+    "from transformers import Qwen2VLForConditionalGeneration, AutoProcessor\n",
+    "from skimage.feature import local_binary_pattern\n",
+    "from scipy.fftpack import fft2, fftshift, dct\n",
+    "from qwen_vl_utils import process_vision_info\n",
+    "\n",
+    "print(\"✓ All dependencies imported successfully!\")\n",
+    "\n",
+    "# ============================================================================\n",
+    "# SECTION 2: BACKBONE CLASSIFIER INITIALIZATION\n",
+    "# ============================================================================\n",
+    "\n",
+    "MODEL_NAME = \"prithivMLmods/AI-vs-Deepfake-vs-Real-9999\"\n",
+    "\n",
+    "print(f\"Loading backbone model: {MODEL_NAME}\")\n",
+    "processor = AutoImageProcessor.from_pretrained(MODEL_NAME)\n",
+    "model = SiglipForImageClassification.from_pretrained(MODEL_NAME)\n",
+    "\n",
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "model = model.to(device)\n",
+    "model.eval()\n",
+    "\n",
+    "CLASS_NAMES = [\"Artificial\", \"Deepfake\", \"Real\"]\n",
+    "\n",
+    "print(f\"✓ Backbone model loaded successfully on {device}!\")\n",
+    "\n",
+    "# ============================================================================\n",
+    "# SECTION 3: FORENSIC SIGNAL EXTRACTION FUNCTIONS\n",
+    "# ============================================================================\n",
+    "\n",
+    "def compute_texture_laplacian(gray):\n",
+    "    \"\"\"\n",
+    "    Measures texture sharpness and natural variation.\n",
+    "    Low variance → unnaturally smooth regions (common in synthesis).\n",
+    "    \"\"\"\n",
+    "    lap = cv2.Laplacian(gray, cv2.CV_64F)\n",
+    "    return float(lap.var())\n",
+    "\n",
+    "\n",
+    "def compute_lbp(gray):\n",
+    "    \"\"\"\n",
+    "    Local Binary Patterns (LBP)\n",
+    "    Captures micro-texture irregularities.\n",
+    "    Low variance often indicates synthetic or filtered textures.\n",
+    "    \"\"\"\n",
+    "    lbp = local_binary_pattern(gray, P=8, R=1, method=\"uniform\")\n",
+    "    return float(np.var(lbp))\n",
+    "\n",
+    "\n",
+    "def compute_fft(gray):\n",
+    "    \"\"\"\n",
+    "    Frequency domain analysis using FFT.\n",
+    "    Detects unnatural spectral energy caused by upsampling,\n",
+    "    diffusion models, or GAN artifacts.\n",
+    "    \"\"\"\n",
+    "    spectrum = fftshift(fft2(gray))\n",
+    "    magnitude = np.log(np.abs(spectrum) + 1)\n",
+    "    return float(np.mean(magnitude))\n",
+    "\n",
+    "\n",
+    "def compute_dct(gray):\n",
+    "    \"\"\"\n",
+    "    Discrete Cosine Transform (DCT) analysis.\n",
+    "    Captures JPEG compression inconsistencies introduced\n",
+    "    by splicing, in-painting, or recompression.\n",
+    "    \"\"\"\n",
+    "    gray = np.float32(gray) / 255.0\n",
+    "    d = dct(dct(gray.T, norm=\"ortho\").T, norm=\"ortho\")\n",
+    "    return float(np.std(d[:40, :40]))\n",
+    "\n",
+    "\n",
+    "def extract_forensic_signals(image_path):\n",
+    "    \"\"\"\n",
+    "    Runs all forensic signal extractors on an image.\n",
+    "    Returns a dictionary of low-level forensic measurements.\n",
+    "    \"\"\"\n",
+    "    img = cv2.imread(image_path)\n",
+    "    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
+    "\n",
+    "    return {\n",
+    "        \"texture_laplacian\": compute_texture_laplacian(gray),\n",
+    "        \"lbp_texture\": compute_lbp(gray),\n",
+    "        \"fft_frequency\": compute_fft(gray),\n",
+    "        \"dct_compression\": compute_dct(gray)\n",
+    "    }\n",
+    "\n",
+    "print(\"✓ Forensic signal functions defined!\")\n",
+    "\n",
+    "# ============================================================================\n",
+    "# SECTION 4: BACKBONE CLASSIFICATION FUNCTION\n",
+    "# ============================================================================\n",
+    "\n",
+    "def classify_image(image_path):\n",
+    "    \"\"\"\n",
+    "    Classify image using backbone model.\n",
+    "    Returns prediction label and confidence.\n",
+    "    \"\"\"\n",
+    "    # Load image\n",
+    "    image = Image.open(image_path).convert(\"RGB\")\n",
+    "\n",
+    "    # Preprocess\n",
+    "    inputs = processor(images=image, return_tensors=\"pt\").to(device)\n",
+    "\n",
+    "    # Forward pass\n",
+    "    with torch.no_grad():\n",
+    "        outputs = model(**inputs)\n",
+    "        logits = outputs.logits\n",
+    "        probs = torch.softmax(logits, dim=1).squeeze().cpu().numpy()\n",
+    "\n",
+    "    # Get highest probability and label\n",
+    "    max_idx = int(np.argmax(probs))\n",
+    "    manipulation_type = CLASS_NAMES[max_idx]\n",
+    "    \n",
+    "    prob_real = float(probs[CLASS_NAMES.index(\"Real\")])\n",
+    "    authenticity_score = float(1.0 - prob_real)\n",
+    "\n",
+    "    return {\n",
+    "        \"manipulation_type\": manipulation_type,\n",
+    "        \"authenticity_score\": authenticity_score\n",
+    "    }\n",
+    "\n",
+    "print(\"✓ Backbone classification function defined!\")\n",
+    "\n",
+    "# ============================================================================\n",
+    "# SECTION 5: VLM ANALYZER CLASS\n",
+    "# ============================================================================\n",
+    "\n",
+    "class VLMAnalyzer:\n",
+    "    \"\"\"\n",
+    "    Qwen2-VL-2B analyzer.\n",
+    "    Only runs if backbone predicts NON-REAL or low-confidence REAL.\n",
+    "    Output: EXACTLY two sentences explaining why the image is not real.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, device: str = \"cuda\"):\n",
+    "        self.device = device\n",
+    "        self.model_name = \"Qwen/Qwen2-VL-2B-Instruct\"\n",
+    "\n",
+    "        print(f\"Loading VLM: {self.model_name}\")\n",
+    "        self.model = Qwen2VLForConditionalGeneration.from_pretrained(\n",
+    "            self.model_name,\n",
+    "            torch_dtype=torch.float16,\n",
+    "            device_map=\"auto\"\n",
+    "        )\n",
+    "        self.processor = AutoProcessor.from_pretrained(self.model_name)\n",
+    "        print(\"✓ VLM loaded successfully!\")\n",
+    "\n",
+    "    def _create_prompt(self, backbone_result: Dict, signals: Dict) -> str:\n",
+    "        \"\"\"\n",
+    "        Prompt focused ONLY on explaining why the image is NOT real.\n",
+    "        \"\"\"\n",
+    "        return f\"\"\"You are an expert forensic image analyst.\n",
+    "\n",
+    "This image has been classified as NOT REAL by an automated detection system.\n",
+    "\n",
+    "Model prediction: {backbone_result['manipulation_type']}\n",
+    "Confidence: {backbone_result['authenticity_score']:.2%}\n",
+    "\n",
+    "Forensic signals:\n",
+    "- Texture Laplacian: {signals['texture_laplacian']:.2f}\n",
+    "- LBP Texture Variance: {signals['lbp_texture']:.2f}\n",
+    "- FFT Frequency Energy: {signals['fft_frequency']:.2f}\n",
+    "- DCT Compression Std: {signals['dct_compression']:.4f}\n",
+    "\n",
+    "TASK:\n",
+    "Explain WHY this image is not real.\n",
+    "Based on what can be visually observed in the image, explain why the image is not authentic.\n",
+    "Describe concrete visual or physical inconsistencies (e.g., texture behavior, edges, lighting, frequency artifacts)\n",
+    "Point out specific visual or physical inconsistencies that indicate synthetic or manipulated content.\n",
+    "\n",
+    "RULES:\n",
+    "- Respond with EXACTLY two sentences\n",
+    "- Plain text only\n",
+    "- Do NOT mention probabilities, scores, or model confidence.\n",
+    "- No bullet points\n",
+    "- Do NOT say \"this image may be real\"\n",
+    "- Do NOT mention uncertainty\n",
+    "- Focus ONLY on manipulation evidence\n",
+    "- Be very specific to the content of THIS image.\n",
+    "\n",
+    "\n",
+    "Response:\"\"\"\n",
+    "\n",
+    "    def analyze(\n",
+    "        self,\n",
+    "        image_path: str,\n",
+    "        backbone_result: Dict,\n",
+    "        signals: Dict\n",
+    "    ) -> str:\n",
+    "        \"\"\"\n",
+    "        Run VLM only if image is non-real or low-confidence real.\n",
+    "        \"\"\"\n",
+    "        # ⛔ Skip VLM if Real (this check is now done in pipeline, but keeping for safety)\n",
+    "        if backbone_result[\"manipulation_type\"] == \"Real\":\n",
+    "            return \"this image is real\"\n",
+    "\n",
+    "        try:\n",
+    "            prompt_text = self._create_prompt(backbone_result, signals)\n",
+    "\n",
+    "            messages = [\n",
+    "                {\n",
+    "                    \"role\": \"user\",\n",
+    "                    \"content\": [\n",
+    "                        {\"type\": \"image\", \"image\": image_path},\n",
+    "                        {\"type\": \"text\", \"text\": prompt_text}\n",
+    "                    ]\n",
+    "                }\n",
+    "            ]\n",
+    "\n",
+    "            text = self.processor.apply_chat_template(\n",
+    "                messages,\n",
+    "                tokenize=False,\n",
+    "                add_generation_prompt=True\n",
+    "            )\n",
+    "\n",
+    "            image_inputs, video_inputs = process_vision_info(messages)\n",
+    "\n",
+    "            inputs = self.processor(\n",
+    "                text=[text],\n",
+    "                images=image_inputs,\n",
+    "                videos=video_inputs,\n",
+    "                padding=True,\n",
+    "                return_tensors=\"pt\"\n",
+    "            ).to(self.device)\n",
+    "\n",
+    "            with torch.no_grad():\n",
+    "                generated_ids = self.model.generate(\n",
+    "                    **inputs,\n",
+    "                    max_new_tokens=128,\n",
+    "                    temperature=0.1,\n",
+    "                    do_sample=False\n",
+    "                )\n",
+    "\n",
+    "            generated_ids_trimmed = [\n",
+    "                out_ids[len(in_ids):]\n",
+    "                for in_ids, out_ids in zip(inputs.input_ids, generated_ids)\n",
+    "            ]\n",
+    "\n",
+    "            output_text = self.processor.batch_decode(\n",
+    "                generated_ids_trimmed,\n",
+    "                skip_special_tokens=True,\n",
+    "                clean_up_tokenization_spaces=False\n",
+    "            )[0].strip()\n",
+    "\n",
+    "            # Hard enforce EXACTLY two sentences\n",
+    "            sentences = [s.strip() for s in output_text.split(\".\") if s.strip()]\n",
+    "            output_text = \". \".join(sentences[:2]) + \".\"\n",
+    "\n",
+    "            return output_text\n",
+    "\n",
+    "        except Exception as e:\n",
+    "            print(f\"⚠ VLM error: {e}\")\n",
+    "            return (\n",
+    "                \"The image contains visual inconsistencies that are not consistent with natural image formation. \"\n",
+    "                \"These artifacts align with patterns commonly seen in synthetic or manipulated imagery.\"\n",
+    "            )\n",
+    "\n",
+    "print(\"✓ VLM Analyzer class defined!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-01-28T10:50:27.548134Z",
+     "iopub.status.busy": "2026-01-28T10:50:27.547591Z",
+     "iopub.status.idle": "2026-01-28T10:50:27.555354Z",
+     "shell.execute_reply": "2026-01-28T10:50:27.554667Z",
+     "shell.execute_reply.started": "2026-01-28T10:50:27.548106Z"
+    },
+    "trusted": true
+   },
+   "outputs": [],
+   "source": [
+    "# ============================================================================\n",
+    "# SECTION 6: FULL PIPELINE EXECUTION\n",
+    "# ============================================================================\n",
+    "\n",
+    "def run_pipeline(\n",
+    "    image_dir: str,\n",
+    "    output_json: str = \"predictions.json\",\n",
+    "    real_threshold: float = 0.90\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Runs full deepfake detection pipeline on all images in a directory.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    vlm = VLMAnalyzer(device=device)\n",
+    "    results = []\n",
+    "\n",
+    "    image_files = [\n",
+    "        f for f in os.listdir(image_dir)\n",
+    "        if f.lower().endswith((\".jpg\", \".jpeg\", \".png\"))\n",
+    "    ]\n",
+    "\n",
+    "    for image_name in image_files:\n",
+    "        image_path = os.path.join(image_dir, image_name)\n",
+    "        print(f\"🔍 Processing: {image_name}\")\n",
+    "\n",
+    "        # 1️⃣ Backbone classification\n",
+    "        backbone_result = classify_image(image_path)\n",
+    "\n",
+    "        prediction = {\n",
+    "            \"image_name\": image_name,\n",
+    "            \"manipulation_type\": backbone_result[\"manipulation_type\"],\n",
+    "            \"authenticity_score\": round(backbone_result[\"authenticity_score\"], 4),\n",
+    "        }\n",
+    "\n",
+    "        # 2️⃣ REAL → no VLM\n",
+    "        if (\n",
+    "            backbone_result[\"manipulation_type\"] == \"Real\"\n",
+    "            and backbone_result[\"authenticity_score\"] >= real_threshold\n",
+    "        ):\n",
+    "            prediction[\"explanation\"] = \"The image is real.\"\n",
+    "\n",
+    "        # 3️⃣ NON-REAL → forensic + VLM\n",
+    "        else:\n",
+    "            signals = extract_forensic_signals(image_path)\n",
+    "\n",
+    "            explanation = vlm.analyze(\n",
+    "                image_path=image_path,\n",
+    "                backbone_result=backbone_result,\n",
+    "                signals=signals\n",
+    "            )\n",
+    "\n",
+    "            prediction[\"explanation\"] = explanation\n",
+    "\n",
+    "        results.append(prediction)\n",
+    "\n",
+    "    # 4️⃣ Save JSON\n",
+    "    with open(output_json, \"w\") as f:\n",
+    "        json.dump(results, f, indent=2)\n",
+    "\n",
+    "    print(f\"\\n✅ Pipeline finished. Results saved to {output_json}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-01-28T10:51:04.642509Z",
+     "iopub.status.busy": "2026-01-28T10:51:04.642250Z",
+     "iopub.status.idle": "2026-01-28T10:51:04.649270Z",
+     "shell.execute_reply": "2026-01-28T10:51:04.648349Z",
+     "shell.execute_reply.started": "2026-01-28T10:51:04.642486Z"
+    },
+    "trusted": true
+   },
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'argparse' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipykernel_54/786051155.py\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m__name__\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"__main__\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m     \u001b[0mparser\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0margparse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mArgumentParser\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m     \u001b[0mparser\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_argument\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"--input_dir\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrequired\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0mparser\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_argument\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"--output_file\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrequired\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'argparse' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "# -----------------------\n",
+    "# CLI\n",
+    "# -----------------------\n",
+    "if __name__ == \"__main__\":\n",
+    "    parser = argparse.ArgumentParser()\n",
+    "    parser.add_argument(\"--input_dir\", required=True, help=\"Path to folder with images\")\n",
+    "    parser.add_argument(\"--output_file\", required=True, help=\"JSON file to save predictions\")\n",
+    "    args = parser.parse_args()\n",
+    "\n",
+    "    run_pipeline(args.input_dir, args.output_file)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kaggle": {
+   "accelerator": "gpu",
+   "dataSources": [
+    {
+     "databundleVersionId": 10798002,
+     "datasetId": 6482454,
+     "isSourceIdPinned": false,
+     "sourceId": 10473785,
+     "sourceType": "datasetVersion"
+    }
+   ],
+   "dockerImageVersionId": 31259,
+   "isGpuEnabled": true,
+   "isInternetEnabled": true,
+   "language": "python",
+   "sourceType": "notebook"
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}